@agentwonderland/mcp 0.1.25 → 0.1.27

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

@@ -12,7 +12,7 @@ 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 mockTempoChargeClient = vi.fn((..._args) => "tempo_method");
 const mockBaseChargeClient = vi.fn((..._args) => "base_method");
 vi.mock("../config.js", () => ({
     getApiUrl: () => "http://api.test",
@@ -27,7 +27,9 @@ vi.mock("mppx/client", () => ({
         create: (config) => mockMppxCreate(config),
     },
     stripe: (config) => mockStripe(config),
-    tempo: (config) => mockTempo(config),
+}));
+vi.mock("../tempo-charge.js", () => ({
+    tempoChargeClient: (config) => mockTempoChargeClient(config),
 }));
 vi.mock("../base-charge.js", () => ({
     baseChargeClient: (config) => mockBaseChargeClient(config),
@@ -63,6 +65,8 @@ describe("payment method initialization", () => {
         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 = {
@@ -78,8 +82,8 @@ describe("payment method initialization", () => {
         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"] }));
+        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 = {
@@ -94,8 +98,8 @@ describe("payment method initialization", () => {
         currentResolvedMethod = { wallet, chain: "tempo" };
         const { getPaymentFetch } = await import("../payments.js");
         await getPaymentFetch("tempo");
-        expect(mockTempo).toHaveBeenCalledTimes(1);
+        expect(mockTempoChargeClient).toHaveBeenCalledTimes(1);
         expect(mockBaseChargeClient).not.toHaveBeenCalled();
-        expect(mockMppxCreate).toHaveBeenCalledWith(expect.objectContaining({ methods: ["tempo_method"] }));
+        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/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

@@ -8,7 +8,9 @@ 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 = [
     {
@@ -53,18 +55,23 @@ export function baseChargeClient(config) {
             const { request } = challenge;
             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 } = await import("viem");
-            const { base } = await import("viem/chains");
-            const rpcUrl = config.rpcUrl ?? "https://mainnet.base.org";
+            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
@@ -79,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/formatters.d.ts

@@ -38,8 +38,9 @@ interface RunResultLike {
     error_code?: string;
     latency_ms?: number;
     execution_latency_ms?: number;
-    cost?: number;
-    estimated_cost?: number;
+    cost?: number | string;
+    settled_amount?: number | string;
+    estimated_cost?: number | string;
     input_tokens?: number;
     tags?: string[];
     consumption_mode?: string;

package/dist/core/formatters.js

@@ -81,6 +81,12 @@ export function agentList(agents, query) {
     const lines = agents.map((a) => `  ${agentLine(a)}`);
     return [header, "", ...lines].join("\n");
 }
+function toDisplayCost(value) {
+    if (value == null)
+        return null;
+    const numeric = typeof value === "number" ? value : Number.parseFloat(value);
+    return Number.isFinite(numeric) ? numeric : null;
+}
 export function formatRunResult(result, opts) {
     const lines = [];
     // Output
@@ -107,7 +113,7 @@ export function formatRunResult(result, opts) {
         lines.push("");
     }
     // Summary line
-    const cost = result.cost ?? result.estimated_cost;
+    const cost = toDisplayCost(result.cost ?? result.settled_amount ?? result.estimated_cost);
     const usedCreditPack = result.consumption_mode === "credit_pack";
     const status = result.status === "success" || result.status === "completed" ? "✓" : "✗";
     const agent = result.agent_name ?? result.agent_id ?? "";

package/dist/core/passes.d.ts

@@ -34,7 +34,7 @@ export interface CreditPackInventory {
     balances: CreditPackRecord[];
 }
 export declare function getCreditPackProgram(agent: AgentRecord): CreditPackProgramInfo | null;
-export declare function getCreditPackInventory(agentId: string): Promise<CreditPackInventory | null>;
+export declare function getCreditPackInventory(agentId: string, method?: string): Promise<CreditPackInventory | null>;
 export declare function getActiveCreditPack(inventory: CreditPackInventory | null): CreditPackRecord | null;
 export declare function formatCreditPackOffer(offer: CreditPackOffer): string;
 export declare function formatCreditPack(pack: CreditPackRecord): string;

package/dist/core/passes.js

@@ -4,9 +4,12 @@ export function getCreditPackProgram(agent) {
     const creditPacks = payment.credit_packs;
     return creditPacks ?? null;
 }
-export async function getCreditPackInventory(agentId) {
+export async function getCreditPackInventory(agentId, method) {
     try {
-        return await apiGet(`/agents/${agentId}/credit-packs`, { ensureConsumerPrincipal: true });
+        return await apiGet(`/agents/${agentId}/credit-packs`, {
+            ensureConsumerPrincipal: true,
+            principalMethod: method,
+        });
     }
     catch {
         return null;

package/dist/core/payments.d.ts

@@ -10,6 +10,7 @@
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
 import type { AgentRecord } from "./types.js";
+export declare function isCardPaymentEnabled(): boolean;
 /**
  * Returns a payment-aware fetch for a specific method, or the best
  * available method if none is specified.

package/dist/core/payments.js

@@ -10,6 +10,13 @@
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
 import { getConfig, getWallets, getDefaultWallet, getCardConfig, resolveWalletAndChain, getApiUrl, } from "./config.js";
+// Feature flag: disable card payment for launch. Flip to true once Stripe
+// approves the live SPT issuer. Config/card state is still persisted so this
+// can be re-enabled without reconfiguring wallets.
+const ENABLE_CARD_PAYMENT = false;
+export function isCardPaymentEnabled() {
+    return ENABLE_CARD_PAYMENT;
+}
 // Cache per wallet+chain combo to avoid re-initializing
 const fetchCache = new Map();
 const REGISTRY_METHOD_MAP = {
@@ -47,7 +54,7 @@ function clearStaleCardCache(activeKey) {
 // ── Per-protocol initializers ───────────────────────────────────
 async function initEvmMppForChain(wallet, chain) {
     try {
-        const { Mppx, tempo } = await import("mppx/client");
+        const { Mppx } = await import("mppx/client");
         let account;
         if (wallet.keyType === "ows" && wallet.owsWalletId) {
             const { owsAccountFromWalletId } = await import("./ows-adapter.js");
@@ -62,13 +69,14 @@ async function initEvmMppForChain(wallet, chain) {
         }
         const methods = [];
         if (chain === "tempo") {
-            methods.push(tempo({ account }));
+            const { tempoChargeClient } = await import("./tempo-charge.js");
+            methods.push(tempoChargeClient({ account }));
         }
         else {
             const { baseChargeClient } = await import("./base-charge.js");
             methods.push(baseChargeClient({ account }));
         }
-        const mppx = Mppx.create({ methods: methods });
+        const mppx = Mppx.create({ methods: methods, polyfill: false });
         return mppx.fetch.bind(mppx);
     }
     catch {
@@ -84,6 +92,7 @@ async function initSolanaMpp(wallet) {
         const { solanaChargeClient } = await import("./solana-charge.js");
         const mppx = Mppx.create({
             methods: [solanaChargeClient({ wallet })],
+            polyfill: false,
         });
         return mppx.fetch.bind(mppx);
     }
@@ -120,6 +129,7 @@ async function initCard() {
                         return spt;
                     },
                 })],
+            polyfill: false,
         });
         return mppx.fetch.bind(mppx);
     }
@@ -149,6 +159,9 @@ async function initForChain(wallet, chain) {
 export async function getPaymentFetch(method) {
     // Card payment
     if (method === "card") {
+        if (!ENABLE_CARD_PAYMENT) {
+            throw new Error('Card payments are temporarily unavailable. Use a crypto wallet (tempo, base, or solana).');
+        }
         const ck = cardCacheKey();
         clearStaleCardCache(ck ?? undefined);
         if (!ck) {
@@ -257,13 +270,13 @@ export function getConfiguredMethods() {
                 methods.push(c);
         }
     }
-    // Add card if configured
-    if (getCardConfig()) {
+    // Add card if configured (gated for launch)
+    if (ENABLE_CARD_PAYMENT && getCardConfig()) {
         methods.push("card");
     }
-    // Respect defaultPaymentMethod — move it to front of list
+    // Respect defaultPaymentMethod — move it to front of list (ignore card when disabled)
     const defaultMethod = getConfig().defaultPaymentMethod;
-    if (defaultMethod) {
+    if (defaultMethod && (defaultMethod !== "card" || ENABLE_CARD_PAYMENT)) {
         const idx = methods.indexOf(defaultMethod);
         if (idx > 0) {
             methods.splice(idx, 1);

package/dist/core/principal.d.ts

@@ -1,2 +1,5 @@
 export declare function getConsumerPrincipal(): Promise<string | null>;
+export declare function getBaseRebatePrincipal(): Promise<string | null>;
+export declare function getConsumerPrincipalForMethod(method?: string): Promise<string | null>;
 export declare function ensureConsumerPrincipal(): Promise<string>;
+export declare function ensureConsumerPrincipalForMethod(method?: string): Promise<string>;

package/dist/core/principal.js

@@ -1,4 +1,4 @@
-import { addWallet, getDefaultWallet, getWallets } from "./config.js";
+import { addWallet, getDefaultWallet, getWallets, resolveWalletAndChain, } from "./config.js";
 import { getWalletAddress } from "./payments.js";
 import { createOwsWallet, isOwsAvailable, listOwsWallets, } from "./ows-adapter.js";
 const BASE_CHAIN_ID = "8453";
@@ -27,6 +27,12 @@ async function walletPrincipal(wallet) {
     }
     return null;
 }
+async function principalForChain(chain) {
+    const address = await getWalletAddress(chain);
+    if (!address)
+        return null;
+    return principalFromAddress(address, chain === "solana" ? "solana" : "evm");
+}
 function preferredWallets() {
     const wallets = getWallets();
     const defaultWallet = getDefaultWallet();
@@ -96,6 +102,18 @@ export async function getConsumerPrincipal() {
     }
     return null;
 }
+export async function getBaseRebatePrincipal() {
+    return (await principalForChain("base")) ?? principalForChain("tempo");
+}
+export async function getConsumerPrincipalForMethod(method) {
+    if (!method || method === "card") {
+        return getConsumerPrincipal();
+    }
+    const resolved = resolveWalletAndChain(method);
+    if (!resolved)
+        return null;
+    return principalForChain(resolved.chain);
+}
 export async function ensureConsumerPrincipal() {
     const existing = await getConsumerPrincipal();
     if (existing)
@@ -107,3 +125,13 @@ export async function ensureConsumerPrincipal() {
     }
     return principal;
 }
+export async function ensureConsumerPrincipalForMethod(method) {
+    const existing = await getConsumerPrincipalForMethod(method);
+    if (existing)
+        return existing;
+    if (method && method !== "card") {
+        throw new Error(`Could not derive a consumer principal for payment method "${method}". ` +
+            "Check wallet_status and confirm that chain is configured for the active wallet.");
+    }
+    return ensureConsumerPrincipal();
+}

package/dist/core/settings.d.ts

@@ -0,0 +1,20 @@
+export interface ChainSettings {
+    chainId: number | string;
+    usdc: string;
+    rpcUrl: string;
+    explorer?: string;
+}
+export interface PublicSettings {
+    network: "testnet" | "mainnet";
+    stripe: {
+        mode: "test" | "live";
+    };
+    chains: {
+        tempo: ChainSettings;
+        base: ChainSettings;
+        solana: ChainSettings & {
+            cluster: "mainnet-beta" | "devnet";
+        };
+    };
+}
+export declare function getSettings(): Promise<PublicSettings | null>;