@agentwonderland/mcp 0.1.24 → 0.1.26

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__/api-client.test.d.ts

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

package/dist/core/__tests__/api-client.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPrincipalForMethod, mockGetConsumerPrincipalForMethod, mockGetBaseRebatePrincipal, mockPaymentFetch, } = vi.hoisted(() => ({
+    mockGetApiUrl: vi.fn(),
+    mockGetApiKey: vi.fn(),
+    mockGetPaymentFetch: vi.fn(),
+    mockEnsureConsumerPrincipalForMethod: vi.fn(),
+    mockGetConsumerPrincipalForMethod: vi.fn(),
+    mockGetBaseRebatePrincipal: vi.fn(),
+    mockPaymentFetch: vi.fn(),
+}));
+vi.mock("../config.js", () => ({
+    getApiUrl: () => mockGetApiUrl(),
+    getApiKey: () => mockGetApiKey(),
+}));
+vi.mock("../payments.js", () => ({
+    getPaymentFetch: (...args) => mockGetPaymentFetch(...args),
+}));
+vi.mock("../principal.js", () => ({
+    ensureConsumerPrincipal: vi.fn(),
+    ensureConsumerPrincipalForMethod: (...args) => mockEnsureConsumerPrincipalForMethod(...args),
+    getConsumerPrincipal: vi.fn(),
+    getConsumerPrincipalForMethod: (...args) => mockGetConsumerPrincipalForMethod(...args),
+    getBaseRebatePrincipal: (...args) => mockGetBaseRebatePrincipal(...args),
+}));
+describe("api-client headers", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGetApiUrl.mockReturnValue("https://api.agentwonderland.test");
+        mockGetApiKey.mockReturnValue(null);
+        mockGetPaymentFetch.mockResolvedValue(mockPaymentFetch);
+        mockEnsureConsumerPrincipalForMethod.mockResolvedValue("did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF");
+        mockGetConsumerPrincipalForMethod.mockResolvedValue("did:pkh:eip155:8453:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+        mockGetBaseRebatePrincipal.mockResolvedValue("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+        mockPaymentFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        }));
+    });
+    it("includes the Base rebate principal alongside the method-specific consumer principal", async () => {
+        const { apiPostWithPayment } = await import("../api-client.js");
+        await apiPostWithPayment("/agents/agent-1/run", { input: { text: "hello" } }, "solana");
+        expect(mockPaymentFetch).toHaveBeenCalledWith("https://api.agentwonderland.test/agents/agent-1/run", expect.objectContaining({
+            headers: expect.objectContaining({
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                "X-AW-Consumer-Principal": "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+                "X-AW-Rebate-Principal": "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+            }),
+        }));
+    });
+});

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

@@ -12,4 +12,14 @@ describe("formatRunResult", () => {
         expect(output).toContain("Covered by credit pack (pack-123)");
         expect(output).not.toContain("Paid:");
     });
+    it("formats string-valued settled amounts from job lookups", () => {
+        const output = formatRunResult({
+            agent_name: "Async Analyzer",
+            status: "completed",
+            settled_amount: "0.100000",
+            job_id: "job-123",
+        }, { paymentMethod: "card" });
+        expect(output).toContain("Paid: $0.10 via card");
+        expect(output).toContain("Job ID: job-123");
+    });
 });

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

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

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

@@ -0,0 +1,27 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = vi.hoisted(() => ({
+    apiGet: vi.fn(),
+}));
+vi.mock("../api-client.js", () => ({
+    apiGet: (...args) => state.apiGet(...args),
+}));
+describe("getCreditPackInventory", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        state.apiGet.mockReset();
+    });
+    it("requests inventory for the selected payment method principal", async () => {
+        state.apiGet.mockResolvedValueOnce({
+            consumer_principal: "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+            offers: [],
+            balances: [],
+        });
+        const { getCreditPackInventory } = await import("../passes.js");
+        const result = await getCreditPackInventory("agent-1", "solana");
+        expect(result?.consumer_principal).toContain("did:pkh:solana:");
+        expect(state.apiGet).toHaveBeenCalledWith("/agents/agent-1/credit-packs", {
+            ensureConsumerPrincipal: true,
+            principalMethod: "solana",
+        });
+    });
+});

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

@@ -1,20 +1,26 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+const TEST_KEY = "1111111111111111111111111111111111111111111111111111111111111111";
 let currentCard = {
     consumerToken: "consumer_one",
     paymentMethodId: "pm_one",
     last4: "1111",
     brand: "visa",
 };
-const createdFetches = [vi.fn(), vi.fn(), vi.fn()];
+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 mockTempoChargeClient = 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: () => undefined,
-    getWallets: () => [],
-    resolveWalletAndChain: () => null,
+    getDefaultWallet: () => currentDefaultWallet,
+    getWallets: () => currentWallets,
+    resolveWalletAndChain: () => currentResolvedMethod,
 }));
 vi.mock("mppx/client", () => ({
     Mppx: {
@@ -22,19 +28,30 @@ vi.mock("mppx/client", () => ({
     },
     stripe: (config) => mockStripe(config),
 }));
-describe("card payment fetch cache", () => {
+vi.mock("../tempo-charge.js", () => ({
+    tempoChargeClient: (config) => mockTempoChargeClient(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[2] })
+            .mockReturnValueOnce({ fetch: createdFetches[3] });
     });
     it("rebuilds the cached card fetch when the card config changes", async () => {
         const { getPaymentFetch } = await import("../payments.js");
@@ -48,5 +65,41 @@ describe("card payment fetch cache", () => {
         const secondFetch = await getPaymentFetch("card");
         expect(firstFetch).not.toBe(secondFetch);
         expect(mockMppxCreate).toHaveBeenCalledTimes(2);
+        expect(mockMppxCreate).toHaveBeenNthCalledWith(1, expect.objectContaining({ polyfill: false }));
+        expect(mockMppxCreate).toHaveBeenNthCalledWith(2, expect.objectContaining({ polyfill: false }));
+    });
+    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(mockTempoChargeClient).not.toHaveBeenCalled();
+        expect(mockMppxCreate).toHaveBeenCalledWith(expect.objectContaining({ methods: ["base_method"], polyfill: false }));
+    });
+    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(mockTempoChargeClient).toHaveBeenCalledTimes(1);
+        expect(mockBaseChargeClient).not.toHaveBeenCalled();
+        expect(mockMppxCreate).toHaveBeenCalledWith(expect.objectContaining({ methods: ["tempo_method"], polyfill: false }));
     });
 });

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

@@ -13,13 +13,24 @@ vi.mock("../config.js", () => ({
     },
     getDefaultWallet: () => state.wallets[0],
     getWallets: () => state.wallets,
+    resolveWalletAndChain: (method) => {
+        for (const wallet of state.wallets) {
+            if (wallet.id === method) {
+                return { wallet, chain: wallet.defaultChain ?? wallet.chains[0] };
+            }
+            if (wallet.chains.includes(method)) {
+                return { wallet, chain: method };
+            }
+        }
+        return null;
+    },
 }));
 vi.mock("../payments.js", () => ({
-    getWalletAddress: async (walletId) => {
-        if (walletId in state.addresses) {
-            return state.addresses[walletId] ?? null;
+    getWalletAddress: async (method) => {
+        if (method && method in state.addresses) {
+            return state.addresses[method] ?? null;
         }
-        const wallet = state.wallets.find((entry) => entry.id === walletId);
+        const wallet = state.wallets.find((entry) => entry.id === method);
         if (wallet?.key) {
             const { privateKeyToAccount } = await import("viem/accounts");
             return privateKeyToAccount(wallet.key).address;
@@ -64,4 +75,30 @@ describe("consumer principal helpers", () => {
         expect(state.addedWallets).toHaveLength(1);
         expect(state.addedWallets[0]?.chains).toEqual(["tempo", "base"]);
     });
+    it("derives a Solana principal when the selected payment method is solana", async () => {
+        state.wallets = [
+            { id: "aw-main", keyType: "ows", owsWalletId: "ows-main", chains: ["tempo", "base", "solana"], defaultChain: "tempo" },
+        ];
+        state.addresses = {
+            solana: "42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+            tempo: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+            base: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+        };
+        const { getConsumerPrincipalForMethod } = await import("../principal.js");
+        const principal = await getConsumerPrincipalForMethod("solana");
+        expect(principal).toBe("did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF");
+    });
+    it("returns the Base rebate principal when an EVM wallet is available", async () => {
+        state.wallets = [
+            { id: "aw-main", keyType: "ows", owsWalletId: "ows-main", chains: ["tempo", "base", "solana"], defaultChain: "tempo" },
+        ];
+        state.addresses = {
+            solana: "42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+            tempo: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+            base: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+        };
+        const { getBaseRebatePrincipal } = await import("../principal.js");
+        const principal = await getBaseRebatePrincipal();
+        expect(principal).toBe("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    });
 });

package/dist/core/__tests__/solana-charge.test.d.ts

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

package/dist/core/__tests__/solana-charge.test.js

@@ -0,0 +1,50 @@
+import { PublicKey } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { describe, expect, it, vi } from "vitest";
+import { SOLANA_USDC_MINT } from "../solana-charge.js";
+describe("resolveRecipientTokenAccount", () => {
+    it("uses the recipient directly when Stripe gives us a token account", async () => {
+        const { resolveRecipientTokenAccount } = await import("../solana-charge.js");
+        const connection = {
+            getParsedAccountInfo: vi.fn().mockResolvedValue({
+                value: { owner: TOKEN_PROGRAM_ID },
+            }),
+        };
+        const mint = new PublicKey(SOLANA_USDC_MINT);
+        const recipient = new PublicKey("42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF");
+        const resolved = await resolveRecipientTokenAccount(connection, mint, recipient);
+        expect(resolved.tokenAccount.toBase58()).toBe(recipient.toBase58());
+        expect(resolved.needsCreateAssociatedAccount).toBe(false);
+        expect(connection.getParsedAccountInfo).toHaveBeenCalledTimes(1);
+    });
+    it("reuses the associated token account when it already exists", async () => {
+        const { resolveRecipientTokenAccount } = await import("../solana-charge.js");
+        const connection = {
+            getParsedAccountInfo: vi.fn()
+                .mockResolvedValueOnce({ value: null })
+                .mockResolvedValueOnce({ value: { owner: TOKEN_PROGRAM_ID } }),
+        };
+        const mint = new PublicKey(SOLANA_USDC_MINT);
+        const recipient = new PublicKey("G7kW6ZPMAK9v11AaVkK9FHed2Gd4WYwvCbanXUmK9WtS");
+        const expectedAta = getAssociatedTokenAddressSync(mint, recipient, false, TOKEN_PROGRAM_ID);
+        const resolved = await resolveRecipientTokenAccount(connection, mint, recipient);
+        expect(resolved.tokenAccount.toBase58()).toBe(expectedAta.toBase58());
+        expect(resolved.needsCreateAssociatedAccount).toBe(false);
+        expect(connection.getParsedAccountInfo).toHaveBeenCalledTimes(2);
+    });
+    it("marks the associated token account for creation when neither account exists", async () => {
+        const { resolveRecipientTokenAccount } = await import("../solana-charge.js");
+        const connection = {
+            getParsedAccountInfo: vi.fn()
+                .mockResolvedValueOnce({ value: null })
+                .mockResolvedValueOnce({ value: null }),
+        };
+        const mint = new PublicKey(SOLANA_USDC_MINT);
+        const recipient = new PublicKey("G7kW6ZPMAK9v11AaVkK9FHed2Gd4WYwvCbanXUmK9WtS");
+        const expectedAta = getAssociatedTokenAddressSync(mint, recipient, false, TOKEN_PROGRAM_ID);
+        const resolved = await resolveRecipientTokenAccount(connection, mint, recipient);
+        expect(resolved.tokenAccount.toBase58()).toBe(expectedAta.toBase58());
+        expect(resolved.needsCreateAssociatedAccount).toBe(true);
+        expect(connection.getParsedAccountInfo).toHaveBeenCalledTimes(2);
+    });
+});

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

@@ -5,6 +5,7 @@ export declare class ApiError extends Error {
 }
 interface RequestOptions {
     ensureConsumerPrincipal?: boolean;
+    principalMethod?: string;
     extraHeaders?: Record<string, string>;
 }
 export declare function apiGet<T>(path: string, options?: RequestOptions): Promise<T>;

package/dist/core/api-client.js

@@ -1,6 +1,6 @@
 import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
-import { ensureConsumerPrincipal, getConsumerPrincipal } from "./principal.js";
+import { getBaseRebatePrincipal, ensureConsumerPrincipalForMethod, getConsumerPrincipalForMethod, } from "./principal.js";
 // ── Error class ────────────────────────────────────────────────────
 export class ApiError extends Error {
     status;
@@ -22,11 +22,15 @@ async function buildHeaders(options) {
         headers["Authorization"] = `Bearer ${apiKey}`;
     }
     const principal = options?.ensureConsumerPrincipal
-        ? await ensureConsumerPrincipal()
-        : await getConsumerPrincipal();
+        ? await ensureConsumerPrincipalForMethod(options?.principalMethod)
+        : await getConsumerPrincipalForMethod(options?.principalMethod);
     if (principal) {
         headers["X-AW-Consumer-Principal"] = principal;
     }
+    const rebatePrincipal = await getBaseRebatePrincipal();
+    if (rebatePrincipal) {
+        headers["X-AW-Rebate-Principal"] = rebatePrincipal;
+    }
     if (options?.extraHeaders) {
         Object.assign(headers, options.extraHeaders);
     }
@@ -109,6 +113,7 @@ export async function apiPostWithPayment(path, body, payWith, options) {
         method: "POST",
         headers: await buildHeaders({
             ensureConsumerPrincipal: true,
+            principalMethod: payWith,
             ...options,
         }),
         body: JSON.stringify(body),

package/dist/core/balances.d.ts

@@ -0,0 +1 @@
+export declare function fetchUsdcBalance(chain: "tempo" | "base" | "solana", address: string): Promise<string | null>;

package/dist/core/balances.js

@@ -0,0 +1,56 @@
+import { getSettings } from "./settings.js";
+const ERC20_BALANCE_ABI = [
+    {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+];
+async function fetchEvmUsdcBalance(chain, address) {
+    try {
+        const { createPublicClient, http, formatUnits } = await import("viem");
+        const client = createPublicClient({ transport: http(chain.rpcUrl) });
+        const raw = await client.readContract({
+            address: chain.usdc,
+            abi: ERC20_BALANCE_ABI,
+            functionName: "balanceOf",
+            args: [address],
+        });
+        return formatUnits(raw, 6);
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchSolanaUsdcBalance(chain, address) {
+    try {
+        const { Connection, PublicKey } = await import("@solana/web3.js");
+        const connection = new Connection(chain.rpcUrl, "confirmed");
+        const owner = new PublicKey(address);
+        const mint = new PublicKey(chain.usdc);
+        const accounts = await connection.getParsedTokenAccountsByOwner(owner, { mint });
+        let total = 0;
+        for (const { account } of accounts.value) {
+            const amount = account.data?.parsed?.info?.tokenAmount?.uiAmount;
+            if (typeof amount === "number")
+                total += amount;
+        }
+        return total.toString();
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchUsdcBalance(chain, address) {
+    const settings = await getSettings();
+    if (!settings)
+        return null;
+    const chainConfig = settings.chains[chain];
+    if (!chainConfig)
+        return null;
+    if (chain === "solana")
+        return fetchSolanaUsdcBalance(chainConfig, address);
+    return fetchEvmUsdcBalance(chainConfig, address);
+}

package/dist/core/base-charge.js

@@ -5,9 +5,12 @@
  * 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_SEPOLIA_USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
 const BASE_CHAIN_ID = 8453;
+const BASE_SEPOLIA_CHAIN_ID = 84532;
 // Standard ERC-20 transfer function ABI
 const ERC20_ABI = [
     {
@@ -50,20 +53,25 @@ 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);
+            const chainId = request.chainId ?? BASE_CHAIN_ID;
+            const currency = (request.currency
+                ?? (chainId === BASE_SEPOLIA_CHAIN_ID ? BASE_SEPOLIA_USDC : BASE_USDC));
             // Dynamic imports to keep the module lightweight
-            const { createWalletClient, createPublicClient, http, encodeFunctionData } = await import("viem");
-            const { base } = await import("viem/chains");
-            const rpcUrl = config.rpcUrl ?? "https://mainnet.base.org";
+            const { createWalletClient, createPublicClient, http } = await import("viem");
+            const { base, baseSepolia } = await import("viem/chains");
+            const chain = chainId === BASE_SEPOLIA_CHAIN_ID ? baseSepolia : base;
+            const rpcUrl = config.rpcUrl ?? (chainId === BASE_SEPOLIA_CHAIN_ID
+                ? "https://sepolia.base.org"
+                : "https://mainnet.base.org");
             const walletClient = createWalletClient({
                 account: config.account,
-                chain: base,
+                chain,
                 transport: http(rpcUrl),
             });
             const publicClient = createPublicClient({
-                chain: base,
+                chain,
                 transport: http(rpcUrl),
             });
             // Send ERC-20 transfer
@@ -78,7 +86,7 @@ export function baseChargeClient(config) {
             return Credential.serialize({
                 challenge,
                 payload: { hash, type: "hash" },
-                source: `did:pkh:eip155:${BASE_CHAIN_ID}:${config.account.address}`,
+                source: `did:pkh:eip155:${chainId}:${config.account.address}`,
             });
         },
     });

package/dist/core/config.d.ts

@@ -13,6 +13,17 @@ export interface CardConfig {
     last4: string;
     brand: string;
 }
+export interface SpendPolicy {
+    maxPerTxUsd?: number;
+    maxPerDayUsd?: number;
+    requireConfirmationAboveUsd?: number;
+}
+export interface SpendLedgerEntry {
+    method: string;
+    amountUsd: number;
+    day: string;
+    timestamp: string;
+}
 export interface Config {
     apiUrl: string;
     apiKey: string | null;
@@ -27,6 +38,10 @@ export interface Config {
     confirmBeforeSpend: boolean;
     /** Auto-tip amount in USD for successful runs. Default: 0 (no auto-tip). */
     defaultTipAmount: number;
+    /** Optional per-method spend policies enforced client-side by MCP tools. */
+    spendPolicies?: Record<string, SpendPolicy>;
+    /** Daily spend ledger used to enforce max-per-day limits. */
+    spendLedger?: SpendLedgerEntry[];
 }
 /** All supported chain identifiers. */
 export declare const SUPPORTED_CHAINS: readonly ["tempo", "base", "solana"];
@@ -43,6 +58,10 @@ export declare function getApiKey(): string | null;
 export declare function isAuthenticated(): boolean;
 export declare function requiresSpendConfirmation(): boolean;
 export declare function getDefaultTipAmount(): number;
+export declare function getSpendPolicy(method: string): SpendPolicy | null;
+export declare function setSpendPolicy(method: string, policy: SpendPolicy): void;
+export declare function getSpendLedger(): SpendLedgerEntry[];
+export declare function saveSpendLedger(entries: SpendLedgerEntry[]): void;
 /**
  * Get all wallets from config + env var synthetic wallets.
  */

package/dist/core/config.js

@@ -40,6 +40,8 @@ function migrateIfNeeded(raw) {
             favorites: r.favorites ?? [],
             confirmBeforeSpend: r.confirmBeforeSpend !== false,
             defaultTipAmount: typeof r.defaultTipAmount === "number" ? r.defaultTipAmount : 0,
+            spendPolicies: r.spendPolicies,
+            spendLedger: r.spendLedger,
         };
     }
     // Build wallets from legacy flat fields
@@ -111,6 +113,8 @@ function migrateIfNeeded(raw) {
         favorites: [],
         confirmBeforeSpend: true,
         defaultTipAmount: 0,
+        spendPolicies: {},
+        spendLedger: [],
     };
     // Write migrated config (only if there was something to migrate)
     if (raw.tempoPrivateKey || raw.evmPrivateKey || raw.stripeConsumerToken) {
@@ -132,6 +136,8 @@ export function getConfig() {
         favorites: [],
         confirmBeforeSpend: true,
         defaultTipAmount: 0,
+        spendPolicies: {},
+        spendLedger: [],
     };
     if (!existsSync(CONFIG_FILE)) {
         return defaults;
@@ -172,6 +178,22 @@ export function requiresSpendConfirmation() {
 export function getDefaultTipAmount() {
     return getConfig().defaultTipAmount;
 }
+export function getSpendPolicy(method) {
+    const policies = getConfig().spendPolicies ?? {};
+    return policies[method] ?? null;
+}
+export function setSpendPolicy(method, policy) {
+    const config = getConfig();
+    const policies = config.spendPolicies ?? {};
+    policies[method] = policy;
+    saveConfig({ spendPolicies: policies });
+}
+export function getSpendLedger() {
+    return getConfig().spendLedger ?? [];
+}
+export function saveSpendLedger(entries) {
+    saveConfig({ spendLedger: entries });
+}
 // ── Wallet helpers ─────────────────────────────────────────────────
 /**
  * Get all wallets from config + env var synthetic wallets.