@agentwonderland/mcp 0.1.23 → 0.1.25

package/dist/core/__tests__/amount-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/amount-utils.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { toAtomicAmount } from "../amount-utils.js";
+describe("toAtomicAmount", () => {
+    it("converts decimal USDC challenge amounts into atomic units", () => {
+        expect(toAtomicAmount("0.020000")).toBe(20000n);
+        expect(toAtomicAmount("1.000000")).toBe(1000000n);
+    });
+    it("supports different decimal precisions", () => {
+        expect(toAtomicAmount("0.50", 2)).toBe(50n);
+    });
+});

package/dist/core/__tests__/card-setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/card-setup.test.js

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+class MockApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+let pendingToken = null;
+const savedCards = [];
+vi.mock("../api-client.js", () => ({
+    ApiError: MockApiError,
+    apiGet: (...args) => mockApiGet(...args),
+    apiPost: (...args) => mockApiPost(...args),
+}));
+vi.mock("../config.js", () => ({
+    getApiUrl: () => "http://api.test",
+    getPendingCardSetupToken: () => pendingToken,
+    setCardConfig: (card) => {
+        savedCards.push(card);
+    },
+    setPendingCardSetupToken: (token) => {
+        pendingToken = token;
+    },
+}));
+describe("card setup helpers", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pendingToken = null;
+        savedCards.length = 0;
+    });
+    it("reuses the existing pending setup token", async () => {
+        pendingToken = "tok_existing";
+        const { getOrCreatePendingCardSetup } = await import("../card-setup.js");
+        const result = await getOrCreatePendingCardSetup();
+        expect(mockApiPost).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            token: "tok_existing",
+            url: "http://api.test/card/handoff/tok_existing",
+            isNew: false,
+        });
+    });
+    it("stores a newly created setup token for later resume", async () => {
+        mockApiPost.mockResolvedValueOnce({ token: "tok_new" });
+        const { getOrCreatePendingCardSetup } = await import("../card-setup.js");
+        const result = await getOrCreatePendingCardSetup();
+        expect(mockApiPost).toHaveBeenCalledWith("/card/setup", {});
+        expect(pendingToken).toBe("tok_new");
+        expect(result).toMatchObject({
+            token: "tok_new",
+            url: "http://api.test/card/handoff/tok_new",
+            isNew: true,
+        });
+    });
+    it("persists the card and clears pending setup on successful completion", async () => {
+        pendingToken = "tok_ready";
+        mockApiGet.mockResolvedValueOnce({
+            status: "complete",
+            card_last4: "4242",
+            card_brand: "visa",
+            consumer_token: "consumer_123",
+            payment_method_id: "pm_123",
+        });
+        const { pollCardSetup } = await import("../card-setup.js");
+        const result = await pollCardSetup("tok_ready", 50);
+        expect(result).toEqual({
+            last4: "4242",
+            brand: "visa",
+            consumerToken: "consumer_123",
+        });
+        expect(savedCards).toEqual([{
+                consumerToken: "consumer_123",
+                paymentMethodId: "pm_123",
+                last4: "4242",
+                brand: "visa",
+            }]);
+        expect(pendingToken).toBeNull();
+    });
+    it("clears expired pending setup tokens", async () => {
+        pendingToken = "tok_expired";
+        mockApiGet.mockRejectedValueOnce(new MockApiError(404, "Setup not found"));
+        const { pollCardSetup } = await import("../card-setup.js");
+        const result = await pollCardSetup("tok_expired", 50);
+        expect(result).toBeNull();
+        expect(pendingToken).toBeNull();
+    });
+    it("formats card setup as a single visible message with the setup page URL", async () => {
+        const { formatCardSetupBlocks } = await import("../card-setup.js");
+        const blocks = formatCardSetupBlocks("http://api.test/card/handoff/tok");
+        expect(blocks).toHaveLength(1);
+        expect(blocks[0]).toContain("Open this setup page to connect your card:");
+        expect(blocks[0]).toContain("http://api.test/card/handoff/tok");
+        expect(blocks[0]).toContain("securely save the card");
+        expect(blocks[0]).not.toContain("QR code above");
+    });
+});

package/dist/core/__tests__/formatters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/formatters.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { formatRunResult } from "../formatters.js";
+describe("formatRunResult", () => {
+    it("does not show a paid line for credit-pack-backed runs with zero cost", () => {
+        const output = formatRunResult({
+            agent_name: "Credit Pack Agent",
+            status: "success",
+            cost: 0,
+            consumption_mode: "credit_pack",
+            credit_pack_id: "pack-123",
+        }, { paymentMethod: "card" });
+        expect(output).toContain("Covered by credit pack (pack-123)");
+        expect(output).not.toContain("Paid:");
+    });
+});

package/dist/core/__tests__/passes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/passes.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { formatCreditPack, formatCreditPackOffer, getActiveCreditPack, getCreditPackProgram, } from "../passes.js";
+const baseAgent = {
+    id: "agent-1",
+    name: "Test Agent",
+    payment: {
+        credit_packs: {
+            unit_type: "run",
+            packs: [
+                { key: "starter", name: "Starter Pack", included_units: 5, price_usd: "1.00" },
+                { key: "growth", name: "Growth Pack", included_units: 20, price_usd: "3.00" },
+            ],
+        },
+    },
+};
+describe("getCreditPackProgram", () => {
+    it("returns the configured credit-pack program from agent metadata", () => {
+        expect(getCreditPackProgram(baseAgent)).toEqual({
+            unit_type: "run",
+            packs: [
+                { key: "starter", name: "Starter Pack", included_units: 5, price_usd: "1.00" },
+                { key: "growth", name: "Growth Pack", included_units: 20, price_usd: "3.00" },
+            ],
+        });
+    });
+});
+describe("formatCreditPackOffer", () => {
+    it("shows units and per-unit price", () => {
+        expect(formatCreditPackOffer({
+            pack_id: "starter",
+            label: "Starter Pack",
+            included_units: 5,
+            price_usd: "1.00",
+            effective_price_per_unit_usd: "0.200000",
+        })).toContain("Starter Pack");
+    });
+});
+describe("formatCreditPack", () => {
+    it("includes the pack status when it is no longer active", () => {
+        expect(formatCreditPack({
+            id: "pack-1",
+            status: "depleted",
+            unit_type: "run",
+            included_units: 5,
+            remaining_units: 0,
+            price_usd: "1.00",
+            purchased_at: "2026-05-04T15:08:28.700Z",
+            pack: { key: "starter", name: "Starter Pack" },
+        })).toContain("depleted");
+    });
+});
+describe("getActiveCreditPack", () => {
+    it("returns the oldest active balance with remaining units", () => {
+        const pack = getActiveCreditPack({
+            consumer_principal: "did:pkh:eip155:8453:0x1111111111111111111111111111111111111111",
+            offers: [],
+            balances: [
+                {
+                    id: "newer",
+                    status: "active",
+                    unit_type: "run",
+                    included_units: 20,
+                    remaining_units: 20,
+                    price_usd: "3.00",
+                    purchased_at: "2026-04-10T00:00:00Z",
+                    pack: { key: "growth", name: "Growth Pack" },
+                },
+                {
+                    id: "older",
+                    status: "active",
+                    unit_type: "run",
+                    included_units: 5,
+                    remaining_units: 2,
+                    price_usd: "1.00",
+                    purchased_at: "2026-04-01T00:00:00Z",
+                    pack: { key: "starter", name: "Starter Pack" },
+                },
+            ],
+        });
+        expect(pack?.id).toBe("older");
+    });
+});

package/dist/core/__tests__/payments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/payments.test.js

@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const TEST_KEY = "1111111111111111111111111111111111111111111111111111111111111111";
+let currentCard = {
+    consumerToken: "consumer_one",
+    paymentMethodId: "pm_one",
+    last4: "1111",
+    brand: "visa",
+};
+let currentDefaultWallet;
+let currentWallets = [];
+let currentResolvedMethod = null;
+const createdFetches = [vi.fn(), vi.fn(), vi.fn(), vi.fn()];
+const mockMppxCreate = vi.fn();
+const mockStripe = vi.fn((opts) => opts);
+const mockTempo = vi.fn((..._args) => "tempo_method");
+const mockBaseChargeClient = vi.fn((..._args) => "base_method");
+vi.mock("../config.js", () => ({
+    getApiUrl: () => "http://api.test",
+    getCardConfig: () => currentCard,
+    getConfig: () => ({ defaultPaymentMethod: "card" }),
+    getDefaultWallet: () => currentDefaultWallet,
+    getWallets: () => currentWallets,
+    resolveWalletAndChain: () => currentResolvedMethod,
+}));
+vi.mock("mppx/client", () => ({
+    Mppx: {
+        create: (config) => mockMppxCreate(config),
+    },
+    stripe: (config) => mockStripe(config),
+    tempo: (config) => mockTempo(config),
+}));
+vi.mock("../base-charge.js", () => ({
+    baseChargeClient: (config) => mockBaseChargeClient(config),
+}));
+describe("payment method initialization", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        currentCard = {
+            consumerToken: "consumer_one",
+            paymentMethodId: "pm_one",
+            last4: "1111",
+            brand: "visa",
+        };
+        currentDefaultWallet = undefined;
+        currentWallets = [];
+        currentResolvedMethod = null;
+        mockMppxCreate
+            .mockReturnValueOnce({ fetch: createdFetches[0] })
+            .mockReturnValueOnce({ fetch: createdFetches[1] })
+            .mockReturnValueOnce({ fetch: createdFetches[2] })
+            .mockReturnValueOnce({ fetch: createdFetches[3] });
+    });
+    it("rebuilds the cached card fetch when the card config changes", async () => {
+        const { getPaymentFetch } = await import("../payments.js");
+        const firstFetch = await getPaymentFetch("card");
+        currentCard = {
+            consumerToken: "consumer_two",
+            paymentMethodId: "pm_two",
+            last4: "2222",
+            brand: "mastercard",
+        };
+        const secondFetch = await getPaymentFetch("card");
+        expect(firstFetch).not.toBe(secondFetch);
+        expect(mockMppxCreate).toHaveBeenCalledTimes(2);
+    });
+    it("initializes only the Base method when base is requested", async () => {
+        const wallet = {
+            id: "aw-main",
+            keyType: "raw",
+            key: TEST_KEY,
+            chains: ["tempo", "base"],
+            defaultChain: "base",
+        };
+        currentDefaultWallet = wallet;
+        currentWallets = [wallet];
+        currentResolvedMethod = { wallet, chain: "base" };
+        const { getPaymentFetch } = await import("../payments.js");
+        await getPaymentFetch("base");
+        expect(mockBaseChargeClient).toHaveBeenCalledTimes(1);
+        expect(mockTempo).not.toHaveBeenCalled();
+        expect(mockMppxCreate).toHaveBeenCalledWith(expect.objectContaining({ methods: ["base_method"] }));
+    });
+    it("initializes only the Tempo method when tempo is requested", async () => {
+        const wallet = {
+            id: "aw-main",
+            keyType: "raw",
+            key: TEST_KEY,
+            chains: ["tempo", "base"],
+            defaultChain: "tempo",
+        };
+        currentDefaultWallet = wallet;
+        currentWallets = [wallet];
+        currentResolvedMethod = { wallet, chain: "tempo" };
+        const { getPaymentFetch } = await import("../payments.js");
+        await getPaymentFetch("tempo");
+        expect(mockTempo).toHaveBeenCalledTimes(1);
+        expect(mockBaseChargeClient).not.toHaveBeenCalled();
+        expect(mockMppxCreate).toHaveBeenCalledWith(expect.objectContaining({ methods: ["tempo_method"] }));
+    });
+});

package/dist/core/__tests__/principal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/principal.test.js

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = vi.hoisted(() => ({
+    wallets: [],
+    addresses: {},
+    addedWallets: [],
+    owsAvailable: false,
+    owsWallets: [],
+}));
+vi.mock("../config.js", () => ({
+    addWallet: (wallet) => {
+        state.addedWallets.push(wallet);
+        state.wallets.push(wallet);
+    },
+    getDefaultWallet: () => state.wallets[0],
+    getWallets: () => state.wallets,
+}));
+vi.mock("../payments.js", () => ({
+    getWalletAddress: async (walletId) => {
+        if (walletId in state.addresses) {
+            return state.addresses[walletId] ?? null;
+        }
+        const wallet = state.wallets.find((entry) => entry.id === walletId);
+        if (wallet?.key) {
+            const { privateKeyToAccount } = await import("viem/accounts");
+            return privateKeyToAccount(wallet.key).address;
+        }
+        return null;
+    },
+}));
+vi.mock("../ows-adapter.js", () => ({
+    createOwsWallet: async (name) => ({
+        walletId: `ows-${name}`,
+        address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    }),
+    isOwsAvailable: async () => state.owsAvailable,
+    listOwsWallets: async () => state.owsWallets,
+}));
+describe("consumer principal helpers", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        state.wallets = [];
+        state.addresses = {};
+        state.addedWallets = [];
+        state.owsAvailable = false;
+        state.owsWallets = [];
+    });
+    it("prefers an EVM-backed principal when both EVM and Solana wallets exist", async () => {
+        state.wallets = [
+            { id: "sol-wallet", keyType: "ows", owsWalletId: "ows-sol", chains: ["solana"], defaultChain: "solana" },
+            { id: "evm-wallet", keyType: "evm", key: "0x1234", chains: ["tempo", "base"], defaultChain: "base" },
+        ];
+        state.addresses = {
+            "sol-wallet": "So1ana11111111111111111111111111111111111111",
+            "evm-wallet": "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+        };
+        const { getConsumerPrincipal } = await import("../principal.js");
+        const principal = await getConsumerPrincipal();
+        expect(principal).toBe("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    });
+    it("creates a fallback EVM identity wallet when none exists", async () => {
+        const { ensureConsumerPrincipal } = await import("../principal.js");
+        const principal = await ensureConsumerPrincipal();
+        expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
+        expect(state.addedWallets).toHaveLength(1);
+        expect(state.addedWallets[0]?.chains).toEqual(["tempo", "base"]);
+    });
+});

package/dist/core/__tests__/spend-policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/spend-policy.test.js

@@ -0,0 +1,40 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = {
+    policies: {},
+    ledger: [],
+};
+vi.mock("../config.js", () => ({
+    getSpendPolicy: (method) => state.policies[method] ?? null,
+    getSpendLedger: () => state.ledger,
+    saveSpendLedger: (entries) => {
+        state.ledger = entries;
+    },
+}));
+import { canSpend, getDailySpend, recordSpend, requiresPolicyConfirmation, } from "../spend-policy.js";
+describe("spend-policy", () => {
+    beforeEach(() => {
+        state.policies = {};
+        state.ledger = [];
+    });
+    it("allows spend when no policy is set", () => {
+        expect(canSpend({ method: "wallet-1", amountUsd: 5 })).toEqual({ ok: true });
+    });
+    it("blocks spends above max_per_tx", () => {
+        state.policies["wallet-1"] = { maxPerTxUsd: 2 };
+        const result = canSpend({ method: "wallet-1", amountUsd: 3 });
+        expect(result.ok).toBe(false);
+    });
+    it("tracks daily spend totals per method", () => {
+        const now = new Date("2026-04-08T12:00:00.000Z");
+        recordSpend("wallet-1", 1.25, now);
+        recordSpend("wallet-1", 0.75, now);
+        recordSpend("wallet-2", 10, now);
+        expect(getDailySpend("wallet-1", now)).toBeCloseTo(2);
+        expect(getDailySpend("wallet-2", now)).toBeCloseTo(10);
+    });
+    it("requires explicit confirmation above configured threshold", () => {
+        state.policies["wallet-1"] = { requireConfirmationAboveUsd: 2 };
+        expect(requiresPolicyConfirmation("wallet-1", 1.99)).toBe(false);
+        expect(requiresPolicyConfirmation("wallet-1", 2)).toBe(true);
+    });
+});

package/dist/core/amount-utils.d.ts

@@ -0,0 +1 @@
+export declare function toAtomicAmount(amount: string, decimals?: number): bigint;

package/dist/core/amount-utils.js

@@ -0,0 +1,4 @@
+import { parseUnits } from "viem";
+export function toAtomicAmount(amount, decimals = 6) {
+    return parseUnits(amount, decimals);
+}

package/dist/core/api-client.d.ts

@@ -3,12 +3,17 @@ export declare class ApiError extends Error {
     readonly body?: unknown | undefined;
     constructor(status: number, message: string, body?: unknown | undefined);
 }
-export declare function apiGet<T>(path: string): Promise<T>;
-export declare function apiPost<T>(path: string, body: unknown): Promise<T>;
+interface RequestOptions {
+    ensureConsumerPrincipal?: boolean;
+    extraHeaders?: Record<string, string>;
+}
+export declare function apiGet<T>(path: string, options?: RequestOptions): Promise<T>;
+export declare function apiPost<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
 /**
  * POST with payment support. Uses the configured payment method to
  * auto-handle 402 → sign → retry for paid endpoints.
  * Pass `payWith` to specify a method, or omit for auto-detection.
  */
-export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string): Promise<T>;
-export declare function apiPut<T>(path: string, body: unknown): Promise<T>;
+export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string, options?: RequestOptions): Promise<T>;
+export declare function apiPut<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+export {};

package/dist/core/api-client.js

@@ -1,5 +1,6 @@
 import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
+import { ensureConsumerPrincipal, getConsumerPrincipal } from "./principal.js";
 // ── Error class ────────────────────────────────────────────────────
 export class ApiError extends Error {
     status;
@@ -11,8 +12,7 @@ export class ApiError extends Error {
         this.name = "ApiError";
     }
 }
-// ── Internal helpers ───────────────────────────────────────────────
-function buildHeaders() {
+async function buildHeaders(options) {
     const headers = {
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -21,6 +21,15 @@ function buildHeaders() {
     if (apiKey) {
         headers["Authorization"] = `Bearer ${apiKey}`;
     }
+    const principal = options?.ensureConsumerPrincipal
+        ? await ensureConsumerPrincipal()
+        : await getConsumerPrincipal();
+    if (principal) {
+        headers["X-AW-Consumer-Principal"] = principal;
+    }
+    if (options?.extraHeaders) {
+        Object.assign(headers, options.extraHeaders);
+    }
     return headers;
 }
 async function handleResponse(response) {
@@ -45,54 +54,75 @@ async function handleResponse(response) {
     }
     return body;
 }
+function attachResponseMetadata(result, response) {
+    if (!result || typeof result !== "object") {
+        return result;
+    }
+    const record = result;
+    const headerToken = response.headers.get("x-feedback-token");
+    if (headerToken && !("feedback_token" in record)) {
+        record.feedback_token = headerToken;
+    }
+    const consumptionMode = response.headers.get("x-aw-consumption-mode");
+    if (consumptionMode) {
+        record.consumption_mode = consumptionMode;
+    }
+    const creditPackId = response.headers.get("x-aw-credit-pack-id");
+    if (creditPackId) {
+        record.credit_pack_id = creditPackId;
+    }
+    const principal = response.headers.get("x-aw-consumer-principal");
+    if (principal) {
+        record.consumer_principal = principal;
+    }
+    return result;
+}
 // ── Public API ─────────────────────────────────────────────────────
-export async function apiGet(path) {
+export async function apiGet(path, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "GET",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }
-export async function apiPost(path, body) {
+export async function apiPost(path, body, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "POST",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
         body: JSON.stringify(body),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }
 /**
  * POST with payment support. Uses the configured payment method to
  * auto-handle 402 → sign → retry for paid endpoints.
  * Pass `payWith` to specify a method, or omit for auto-detection.
  */
-export async function apiPostWithPayment(path, body, payWith) {
+export async function apiPostWithPayment(path, body, payWith, options) {
     const url = `${getApiUrl()}${path}`;
     const paymentFetch = await getPaymentFetch(payWith);
     const response = await paymentFetch(url, {
         method: "POST",
-        headers: buildHeaders(),
+        headers: await buildHeaders({
+            ensureConsumerPrincipal: true,
+            ...options,
+        }),
         body: JSON.stringify(body),
     });
     const result = await handleResponse(response);
-    // mppx may strip extra fields from the response body during receipt processing.
-    // The gateway also sends feedback_token as a header to survive this.
-    if (result && typeof result === "object" && !("feedback_token" in result)) {
-        const headerToken = response.headers.get("x-feedback-token");
-        if (headerToken) {
-            result.feedback_token = headerToken;
-        }
-    }
-    return result;
+    return attachResponseMetadata(result, response);
 }
-export async function apiPut(path, body) {
+export async function apiPut(path, body, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "PUT",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
         body: JSON.stringify(body),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }

package/dist/core/base-charge.js

@@ -5,6 +5,7 @@
  * the tx hash as a credential. Plugs into mppx's compose/dispatch system.
  */
 import { Method, Credential, z } from "mppx";
+import { toAtomicAmount } from "./amount-utils.js";
 // Base USDC (Circle native)
 const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 const BASE_CHAIN_ID = 8453;
@@ -50,11 +51,11 @@ export function baseChargeClient(config) {
     return Method.toClient(baseChargeMethod, {
         async createCredential({ challenge }) {
             const { request } = challenge;
-            const amount = BigInt(request.amount);
+            const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
             const recipient = request.recipient;
             const currency = (request.currency ?? BASE_USDC);
             // Dynamic imports to keep the module lightweight
-            const { createWalletClient, createPublicClient, http, encodeFunctionData } = await import("viem");
+            const { createWalletClient, createPublicClient, http } = await import("viem");
             const { base } = await import("viem/chains");
             const rpcUrl = config.rpcUrl ?? "https://mainnet.base.org";
             const walletClient = createWalletClient({