Quickstart

1
import { randomUUID } from "node:crypto";
2
import { createServer, IncomingMessage, ServerResponse } from "node:http";
3
4
import * as jose from "jose";
5
import { Gwop } from "@gwop/sdk";
6
7
const gwop = new Gwop({
8
  merchantApiKey: process.env.GWOP_MERCHANT_API_KEY!,
9
  webhookSecret: process.env.GWOP_WEBHOOK_SECRET!,
10
  timeoutMs: 8_000,
11
});
12
13
const identityRequestOptions = {
14
  serverURL: process.env.GWOP_IDENTITY_BASE_URL ?? "https://identity.gwop.io",
15
  timeoutMs: 8_000,
16
} as const;
17
18
let cachedJwks = await gwop.auth.getJwks(identityRequestOptions);
19
let getKey = jose.createLocalJWKSet({ keys: cachedJwks.result.keys });
20
21
async function verifyAccessToken(accessToken: string) {
22
  try {
23
    const { payload } = await jose.jwtVerify(accessToken, getKey, {
24
      issuer: "https://identity.gwop.io",
25
      algorithms: ["RS256"],
26
    });
27
28
    return {
29
      subject: payload.sub,
30
      sessionId: payload.sid,
31
    };
32
  } catch (error) {
33
    if (error instanceof jose.errors.JWKSNoMatchingKey) {
34
      cachedJwks = await gwop.auth.getJwks(identityRequestOptions);
35
      getKey = jose.createLocalJWKSet({ keys: cachedJwks.result.keys });
36
      return verifyAccessToken(accessToken);
37
    }
38
39
    throw error;
40
  }
41
}

1
const { result: intent } = await gwop.authIntents.create(
2
  {
3
    idempotencyKey: randomUUID(),
4
    body: {
5
      metadata: {
6
        source: "quickstart",
7
      },
8
    },
9
  },
10
  identityRequestOptions,
11
);
12
13
console.log(intent.authIntentId);
14
console.log(intent.challenge.paymentMethods);
15
16
// After the wallet settles one of the returned payment URLs:
17
const { result: token } = await gwop.authIntents.exchange(
18
  {
19
    authIntentId: intent.authIntentId,
20
    idempotencyKey: randomUUID(),
21
  },
22
  identityRequestOptions,
23
);
24
25
const verified = await verifyAccessToken(token.accessToken);
26
27
console.log(verified.subject);   // "{chain}:{address}"
28
console.log(verified.sessionId); // revocable session identifier

1
const { result: invoice } = await gwop.invoices.create({
2
  idempotencyKey: randomUUID(),
3
  body: {
4
    amountUsdc: 5_000_000, // $5.00 USDC
5
    description: "Starter plan",
6
  },
7
});
8
9
console.log(invoice.id);              // merchant-side UUID — store internally
10
console.log(invoice.publicInvoiceId); // payer-facing inv_* — hand to the agent
11
console.log(invoice.agentProtocol);   // machine-readable checkout session

1
function readBody(req: IncomingMessage): Promise<string> {
2
  return new Promise((resolve, reject) => {
3
    const chunks: Buffer[] = [];
4
    req.on("data", (chunk) => chunks.push(chunk));
5
    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
6
    req.on("error", reject);
7
  });
8
}
9
10
const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
11
  if (req.method === "POST" && req.url === "/webhooks/gwop") {
12
    const rawBody = await readBody(req);
13
14
    const event = await gwop.validateWebhook({
15
      request: {
16
        body: rawBody,
17
        headers: {
18
          "x-gwop-signature": req.headers["x-gwop-signature"] as string,
19
          "x-gwop-event-id": req.headers["x-gwop-event-id"] as string,
20
          "x-gwop-event-type": req.headers["x-gwop-event-type"] as string,
21
          "content-type": "application/json",
22
        },
23
        url: `http://localhost:3000${req.url}`,
24
        method: "POST",
25
      },
26
    });
27
28
    if (event.body.eventType === "invoice.paid") {
29
      console.log("Paid:", event.body.data.publicInvoiceId);
30
      console.log("Chain:", event.body.data.paymentChain);
31
32
      // Activate the subscription, grant credits, or unlock the purchase here.
33
    }
34
35
    res.writeHead(200);
36
    res.end("ok");
37
  }
38
});
39
40
server.listen(3000, () => console.log("Listening on :3000"));