@crossmint/lobster.cash 0.1.1

package/src/api.test.ts

@@ -0,0 +1,439 @@
+import { Keypair } from "@solana/web3.js";
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import {
+  ProxyApiError,
+  buildAmazonProductLocator,
+  createOrder,
+  createTransfer,
+  getOrder,
+  getWalletBalance,
+  isAccessTokenExpiredError,
+  purchaseProduct,
+  startSetup,
+  submitPaymentConfirmation,
+  verifySetup,
+  refreshInit,
+  refreshToken,
+  waitForTransactionBroadcast,
+  type CrossmintApiConfig,
+} from "./api.js";
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}
+
+describe("plugin api (server-backed)", () => {
+  const config: CrossmintApiConfig = {
+    serverBaseUrl: "https://example.com",
+    requestTimeoutMs: 5000,
+    accessToken: "test-access-token",
+  };
+
+  const fetchMock = vi.fn();
+
+  beforeEach(() => {
+    fetchMock.mockReset();
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  describe("buildAmazonProductLocator", () => {
+    it("returns existing amazon: locator unchanged", () => {
+      expect(buildAmazonProductLocator("amazon:B00O79SKV6")).toBe("amazon:B00O79SKV6");
+    });
+
+    it("wraps Amazon URL with amazon: prefix", () => {
+      expect(buildAmazonProductLocator("https://www.amazon.com/dp/B00O79SKV6")).toBe(
+        "amazon:https://www.amazon.com/dp/B00O79SKV6"
+      );
+    });
+
+    it("wraps ASIN with amazon: prefix", () => {
+      expect(buildAmazonProductLocator("B00O79SKV6")).toBe("amazon:B00O79SKV6");
+    });
+  });
+
+  describe("setup endpoints", () => {
+    it("calls /setup/start", async () => {
+      fetchMock.mockResolvedValueOnce(
+        jsonResponse({ pairingId: "pair-1", pairingNonce: "nonce-1", expiresAt: 12345 })
+      );
+
+      const response = await startSetup(
+        { serverBaseUrl: "https://example.com", requestTimeoutMs: 5000 },
+        {
+          agentId: "agent-1",
+          agentPubKey: "pubkey",
+        }
+      );
+
+      expect(response.pairingId).toBe("pair-1");
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      const [url, request] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe("https://example.com/api/claw/setup/start");
+      expect(request.method).toBe("POST");
+      expect(request.body).toBe(JSON.stringify({ agentId: "agent-1", agentPubKey: "pubkey" }));
+    });
+
+    it("calls /setup/verify and refresh endpoints", async () => {
+      fetchMock
+        .mockResolvedValueOnce(jsonResponse({ verified: true, consentUrl: "https://x/consent" }))
+        .mockResolvedValueOnce(jsonResponse({ nonceId: "nonce-id", refreshNonce: "nonce" }))
+        .mockResolvedValueOnce(
+          jsonResponse({ accessToken: "a2", refreshToken: "r2", expiresAt: 999999 })
+        );
+
+      const verify = await verifySetup(
+        { serverBaseUrl: "https://example.com", requestTimeoutMs: 5000 },
+        { pairingId: "pair-1", signature: "sig" }
+      );
+      expect(verify.verified).toBe(true);
+
+      const init = await refreshInit(
+        { serverBaseUrl: "https://example.com", requestTimeoutMs: 5000 },
+        { agentId: "agent-1", agentPubKey: "pubkey" }
+      );
+      expect(init.nonceId).toBe("nonce-id");
+
+      const refreshed = await refreshToken(
+        { serverBaseUrl: "https://example.com", requestTimeoutMs: 5000 },
+        {
+          agentId: "agent-1",
+          agentPubKey: "pubkey",
+          nonceId: "nonce-id",
+          refreshToken: "r1",
+          refreshSignature: "sig2",
+        }
+      );
+      expect(refreshed.accessToken).toBe("a2");
+
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe("wallet + tx endpoints", () => {
+    it("requires access token for authenticated endpoints", async () => {
+      await expect(
+        getWalletBalance(
+          {
+            serverBaseUrl: "https://example.com",
+            requestTimeoutMs: 5000,
+          },
+          "wallet-1"
+        )
+      ).rejects.toThrow("Missing access token");
+
+      expect(fetchMock).toHaveBeenCalledTimes(0);
+    });
+
+    it("creates and approves a transfer using proxy endpoints", async () => {
+      const keypair = Keypair.generate();
+
+      fetchMock
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-1",
+            status: "awaiting-approval",
+            messageToSign: "hello",
+            messageToSignEncoding: "utf8",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-1",
+            status: "pending",
+            txHash: "hash-1",
+            explorerUrl: "https://explorer/tx/hash-1",
+          })
+        );
+
+      const tx = await createTransfer(config, "wallet-1", "recipient-1", "usdc", "1.5", keypair);
+
+      expect(tx.id).toBe("tx-1");
+      expect(tx.hash).toBe("hash-1");
+      expect(tx.explorerLink).toBe("https://explorer/tx/hash-1");
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+
+      const [, createReq] = fetchMock.mock.calls[0] as [string, RequestInit];
+      const createHeaders = createReq.headers as Record<string, string>;
+      expect(createHeaders.Authorization).toBe("Bearer test-access-token");
+      expect(createReq.body).toBe(
+        JSON.stringify({ type: "transfer", to: "recipient-1", token: "usdc", amount: "1.5" })
+      );
+
+      const [, approveReq] = fetchMock.mock.calls[1] as [string, RequestInit];
+      const approveBody = JSON.parse(approveReq.body as string) as { signature: string };
+      expect(approveBody.signature).toMatch(/^[0-9a-f]+$/i);
+      expect(approveBody.signature.length).toBeGreaterThan(0);
+    });
+
+    it("maps ACCESS_TOKEN_EXPIRED errors", async () => {
+      fetchMock.mockResolvedValueOnce(
+        jsonResponse(
+          {
+            error: {
+              code: "ACCESS_TOKEN_EXPIRED",
+              message: "token expired",
+            },
+          },
+          401
+        )
+      );
+
+      try {
+        await getWalletBalance(config, "wallet-1");
+        expect.fail("Expected getWalletBalance to throw");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ProxyApiError);
+        expect(isAccessTokenExpiredError(error)).toBe(true);
+      }
+    });
+
+    it("preserves proxy error metadata for non-expired failures", async () => {
+      fetchMock.mockResolvedValueOnce(
+        jsonResponse(
+          {
+            error: {
+              code: "RATE_LIMITED",
+              message: "Too many requests",
+              details: { retryAfterSeconds: 10 },
+            },
+          },
+          429
+        )
+      );
+
+      try {
+        await getWalletBalance(config, "wallet-1");
+        expect.fail("Expected getWalletBalance to throw");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ProxyApiError);
+        expect(isAccessTokenExpiredError(error)).toBe(false);
+        expect((error as ProxyApiError).status).toBe(429);
+        expect((error as ProxyApiError).code).toBe("RATE_LIMITED");
+        expect((error as ProxyApiError).details).toEqual({ retryAfterSeconds: 10 });
+      }
+    });
+
+    it("throws when broadcast polling observes failed transaction", async () => {
+      fetchMock.mockResolvedValueOnce(
+        jsonResponse({
+          transactionId: "tx-failed",
+          status: "failed",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          updatedAt: "2026-01-01T00:00:01.000Z",
+        })
+      );
+
+      await expect(
+        waitForTransactionBroadcast(config, "wallet-1", "tx-failed", 1000, 1)
+      ).rejects.toThrow("Transaction failed: tx-failed");
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("orders endpoints", () => {
+    it("includes x-order-client-secret for order follow-up calls", async () => {
+      fetchMock
+        .mockResolvedValueOnce(
+          jsonResponse({
+            orderId: "order-1",
+            clientSecret: "secret-1",
+            phase: "payment",
+            serializedTransaction: "serialized",
+          })
+        )
+        .mockResolvedValueOnce(jsonResponse({ orderId: "order-1", phase: "payment" }))
+        .mockResolvedValueOnce(jsonResponse({ orderId: "order-1", phase: "completed" }));
+
+      const create = await createOrder(config, {
+        recipient: {
+          email: "test@example.com",
+          physicalAddress: {
+            name: "Test",
+            line1: "123 Main",
+            city: "Miami",
+            postalCode: "33101",
+            country: "US",
+          },
+        },
+        payment: {
+          receiptEmail: "test@example.com",
+          method: "solana",
+          currency: "usdc",
+          payerAddress: "wallet-1",
+        },
+        lineItems: [{ productLocator: "amazon:B00O79SKV6" }],
+      });
+      expect(create.clientSecret).toBe("secret-1");
+
+      await getOrder(config, "order-1", "secret-1");
+      await submitPaymentConfirmation(config, "order-1", "tx-1", "secret-1");
+
+      const [, getReq] = fetchMock.mock.calls[1] as [string, RequestInit];
+      const getHeaders = getReq.headers as Record<string, string>;
+      expect(getHeaders["x-order-client-secret"]).toBe("secret-1");
+
+      const [, payReq] = fetchMock.mock.calls[2] as [string, RequestInit];
+      const payHeaders = payReq.headers as Record<string, string>;
+      expect(payHeaders["x-order-client-secret"]).toBe("secret-1");
+    });
+
+    it("completes purchaseProduct flow", async () => {
+      const keypair = Keypair.generate();
+
+      fetchMock
+        .mockResolvedValueOnce(
+          jsonResponse({
+            orderId: "order-2",
+            clientSecret: "secret-2",
+            phase: "payment",
+            serializedTransaction: "serialized-tx",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-2",
+            status: "awaiting-approval",
+            messageToSign: "hello",
+            messageToSignEncoding: "utf8",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-2",
+            status: "success",
+            txHash: "on-chain-2",
+            explorerUrl: "https://explorer/tx/on-chain-2",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            orderId: "order-2",
+            phase: "completed",
+            payment: { status: "completed" },
+          })
+        );
+
+      const result = await purchaseProduct(
+        config,
+        {
+          recipient: {
+            email: "test@example.com",
+            physicalAddress: {
+              name: "Test",
+              line1: "123 Main",
+              city: "Miami",
+              postalCode: "33101",
+              country: "US",
+            },
+          },
+          payment: {
+            receiptEmail: "test@example.com",
+            method: "solana",
+            currency: "usdc",
+            payerAddress: "wallet-1",
+          },
+          lineItems: [{ productLocator: "amazon:B00O79SKV6" }],
+        },
+        keypair
+      );
+
+      expect(result.orderId).toBe("order-2");
+      expect(result.clientSecret).toBe("secret-2");
+      expect(result.transactionId).toBe("tx-2");
+      expect(result.onChainTxId).toBe("on-chain-2");
+      expect(result.explorerLink).toBe("https://explorer/tx/on-chain-2");
+      expect(fetchMock).toHaveBeenCalledTimes(4);
+    });
+
+    it("falls back to broadcast polling when approve returns no tx hash", async () => {
+      const keypair = Keypair.generate();
+      const prodConfig: CrossmintApiConfig = {
+        serverBaseUrl: "https://api.crossmint.com",
+        requestTimeoutMs: 5000,
+        accessToken: "test-access-token",
+      };
+
+      fetchMock
+        .mockResolvedValueOnce(
+          jsonResponse({
+            orderId: "order-3",
+            clientSecret: "secret-3",
+            phase: "payment",
+            serializedTransaction: "serialized-tx-3",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-3",
+            status: "awaiting-approval",
+            messageToSign: "hello",
+            messageToSignEncoding: "utf8",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-3",
+            status: "pending",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            transactionId: "tx-3",
+            status: "pending",
+            txHash: "on-chain-3",
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:01.000Z",
+          })
+        )
+        .mockResolvedValueOnce(
+          jsonResponse({
+            orderId: "order-3",
+            phase: "completed",
+            payment: { status: "completed" },
+          })
+        );
+
+      const result = await purchaseProduct(
+        prodConfig,
+        {
+          recipient: {
+            email: "test@example.com",
+            physicalAddress: {
+              name: "Test",
+              line1: "123 Main",
+              city: "Miami",
+              postalCode: "33101",
+              country: "US",
+            },
+          },
+          payment: {
+            receiptEmail: "test@example.com",
+            method: "solana",
+            currency: "usdc",
+            payerAddress: "wallet-1",
+          },
+          lineItems: [{ productLocator: "amazon:B00O79SKV6" }],
+        },
+        keypair
+      );
+
+      expect(result.orderId).toBe("order-3");
+      expect(result.transactionId).toBe("tx-3");
+      expect(result.onChainTxId).toBe("on-chain-3");
+      expect(result.explorerLink).toBe("https://explorer.solana.com/tx/on-chain-3");
+      expect(fetchMock).toHaveBeenCalledTimes(5);
+    });
+  });
+});