@agentwonderland/mcp 0.1.24 → 0.1.26

package/src/core/__tests__/passes-api.test.ts

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({
+  apiGet: vi.fn(),
+}));
+
+vi.mock("../api-client.js", () => ({
+  apiGet: (...args: unknown[]) => 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/src/core/__tests__/payments.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+const TEST_KEY = "1111111111111111111111111111111111111111111111111111111111111111";
+
 let currentCard = {
   consumerToken: "consumer_one",
   paymentMethodId: "pm_one",
@@ -7,17 +9,23 @@ let currentCard = {
   brand: "visa",
 };
 
-const createdFetches = [vi.fn(), vi.fn(), vi.fn()];
+let currentDefaultWallet: any;
+let currentWallets: any[] = [];
+let currentResolvedMethod: { wallet: any; chain: string } | null = null;
+
+const createdFetches = [vi.fn(), vi.fn(), vi.fn(), vi.fn()];
 const mockMppxCreate = vi.fn();
 const mockStripe = vi.fn((opts: unknown) => opts);
+const mockTempoChargeClient = vi.fn((..._args: unknown[]) => "tempo_method");
+const mockBaseChargeClient = vi.fn((..._args: unknown[]) => "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", () => ({
@@ -27,19 +35,32 @@ vi.mock("mppx/client", () => ({
   stripe: (config: unknown) => mockStripe(config),
 }));
 
-describe("card payment fetch cache", () => {
+vi.mock("../tempo-charge.js", () => ({
+  tempoChargeClient: (config: unknown) => mockTempoChargeClient(config),
+}));
+
+vi.mock("../base-charge.js", () => ({
+  baseChargeClient: (config: unknown) => 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 () => {
@@ -56,5 +77,57 @@ describe("card payment fetch cache", () => {
 
     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/src/core/__tests__/principal.test.ts

@@ -23,15 +23,26 @@ vi.mock("../config.js", () => ({
   },
   getDefaultWallet: () => state.wallets[0],
   getWallets: () => state.wallets,
+  resolveWalletAndChain: (method: string) => {
+    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: string) => {
-    if (walletId in state.addresses) {
-      return state.addresses[walletId] ?? null;
+  getWalletAddress: async (method?: string) => {
+    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 as `0x${string}`).address;
@@ -84,4 +95,38 @@ 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/src/core/__tests__/solana-charge.test.ts

@@ -0,0 +1,59 @@
+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 },
+      }),
+    } as any;
+    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 } }),
+    } as any;
+    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 }),
+    } as any;
+    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/src/core/__tests__/spend-policy.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = {
+  policies: {} as Record<string, {
+    maxPerTxUsd?: number;
+    maxPerDayUsd?: number;
+    requireConfirmationAboveUsd?: number;
+  }>,
+  ledger: [] as Array<{ method: string; amountUsd: number; day: string; timestamp: string }>,
+};
+
+vi.mock("../config.js", () => ({
+  getSpendPolicy: (method: string) => state.policies[method] ?? null,
+  getSpendLedger: () => state.ledger,
+  saveSpendLedger: (entries: Array<{ method: string; amountUsd: number; day: string; timestamp: string }>) => {
+    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/src/core/amount-utils.ts

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

package/src/core/api-client.ts

@@ -1,6 +1,12 @@
 import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
-import { ensureConsumerPrincipal, getConsumerPrincipal } from "./principal.js";
+import {
+  getBaseRebatePrincipal,
+  ensureConsumerPrincipal,
+  ensureConsumerPrincipalForMethod,
+  getConsumerPrincipal,
+  getConsumerPrincipalForMethod,
+} from "./principal.js";
 
 // ── Error class ────────────────────────────────────────────────────
 
@@ -19,6 +25,7 @@ export class ApiError extends Error {
 
 interface RequestOptions {
   ensureConsumerPrincipal?: boolean;
+  principalMethod?: string;
   extraHeaders?: Record<string, string>;
 }
 
@@ -34,12 +41,17 @@ async function buildHeaders(options?: RequestOptions): Promise<Record<string, st
   }
 
   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);
   }
@@ -141,6 +153,7 @@ export async function apiPostWithPayment<T>(
     method: "POST",
     headers: await buildHeaders({
       ensureConsumerPrincipal: true,
+      principalMethod: payWith,
       ...options,
     }),
     body: JSON.stringify(body),

package/src/core/balances.ts

@@ -0,0 +1,63 @@
+import { getSettings, type ChainSettings } from "./settings.js";
+
+const ERC20_BALANCE_ABI = [
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+  },
+] as const;
+
+async function fetchEvmUsdcBalance(
+  chain: ChainSettings,
+  address: string,
+): Promise<string | null> {
+  try {
+    const { createPublicClient, http, formatUnits } = await import("viem");
+    const client = createPublicClient({ transport: http(chain.rpcUrl) });
+    const raw = await client.readContract({
+      address: chain.usdc as `0x${string}`,
+      abi: ERC20_BALANCE_ABI,
+      functionName: "balanceOf",
+      args: [address as `0x${string}`],
+    });
+    return formatUnits(raw as bigint, 6);
+  } catch {
+    return null;
+  }
+}
+
+async function fetchSolanaUsdcBalance(
+  chain: ChainSettings,
+  address: string,
+): Promise<string | null> {
+  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 as any)?.parsed?.info?.tokenAmount?.uiAmount;
+      if (typeof amount === "number") total += amount;
+    }
+    return total.toString();
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchUsdcBalance(
+  chain: "tempo" | "base" | "solana",
+  address: string,
+): Promise<string | null> {
+  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/src/core/base-charge.ts

@@ -6,10 +6,13 @@
  */
 import { Method, Credential, z } from "mppx";
 import type { LocalAccount } from "viem/accounts";
+import { toAtomicAmount } from "./amount-utils.js";
 
 // Base USDC (Circle native)
 const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;
+const BASE_SEPOLIA_USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e" as const;
 const BASE_CHAIN_ID = 8453;
+const BASE_SEPOLIA_CHAIN_ID = 84532;
 
 // Standard ERC-20 transfer function ABI
 const ERC20_ABI = [
@@ -63,24 +66,29 @@ export function baseChargeClient(config: BaseChargeClientConfig) {
   return Method.toClient(baseChargeMethod as any, {
     async createCredential({ challenge }: any) {
       const { request } = challenge;
-      const amount = BigInt(request.amount);
+      const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
       const recipient = request.recipient as `0x${string}`;
-      const currency = (request.currency ?? BASE_USDC) as `0x${string}`;
+      const chainId = request.chainId ?? BASE_CHAIN_ID;
+      const currency = (request.currency
+        ?? (chainId === BASE_SEPOLIA_CHAIN_ID ? BASE_SEPOLIA_USDC : BASE_USDC)) as `0x${string}`;
 
       // Dynamic imports to keep the module lightweight
-      const { createWalletClient, createPublicClient, http, encodeFunctionData } = await import("viem");
-      const { base } = await import("viem/chains");
+      const { createWalletClient, createPublicClient, http } = await import("viem");
+      const { base, baseSepolia } = await import("viem/chains");
 
-      const rpcUrl = config.rpcUrl ?? "https://mainnet.base.org";
+      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),
       });
 
@@ -98,7 +106,7 @@ export function baseChargeClient(config: BaseChargeClientConfig) {
       return Credential.serialize({
         challenge,
         payload: { hash, type: "hash" as const },
-        source: `did:pkh:eip155:${BASE_CHAIN_ID}:${config.account.address}`,
+        source: `did:pkh:eip155:${chainId}:${config.account.address}`,
       });
     },
   });

package/src/core/config.ts

@@ -21,6 +21,19 @@ export interface CardConfig {
   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;
@@ -35,6 +48,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. */
@@ -82,6 +99,8 @@ interface LegacyConfig {
   defaultWallet?: string | null;
   card?: CardConfig | null;
   pendingCardSetupToken?: string | null;
+  spendPolicies?: Record<string, SpendPolicy>;
+  spendLedger?: SpendLedgerEntry[];
 }
 
 /**
@@ -104,6 +123,8 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
       favorites: r.favorites as string[] ?? [],
       confirmBeforeSpend: r.confirmBeforeSpend !== false,
       defaultTipAmount: typeof r.defaultTipAmount === "number" ? r.defaultTipAmount : 0,
+      spendPolicies: r.spendPolicies as Record<string, SpendPolicy> | undefined,
+      spendLedger: r.spendLedger as SpendLedgerEntry[] | undefined,
     };
   }
 
@@ -178,6 +199,8 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
     favorites: [],
     confirmBeforeSpend: true,
     defaultTipAmount: 0,
+    spendPolicies: {},
+    spendLedger: [],
   };
 
   // Write migrated config (only if there was something to migrate)
@@ -203,6 +226,8 @@ export function getConfig(): Config {
     favorites: [],
     confirmBeforeSpend: true,
     defaultTipAmount: 0,
+    spendPolicies: {},
+    spendLedger: [],
   };
 
   if (!existsSync(CONFIG_FILE)) {
@@ -249,6 +274,26 @@ export function getDefaultTipAmount(): number {
   return getConfig().defaultTipAmount;
 }
 
+export function getSpendPolicy(method: string): SpendPolicy | null {
+  const policies = getConfig().spendPolicies ?? {};
+  return policies[method] ?? null;
+}
+
+export function setSpendPolicy(method: string, policy: SpendPolicy): void {
+  const config = getConfig();
+  const policies = config.spendPolicies ?? {};
+  policies[method] = policy;
+  saveConfig({ spendPolicies: policies });
+}
+
+export function getSpendLedger(): SpendLedgerEntry[] {
+  return getConfig().spendLedger ?? [];
+}
+
+export function saveSpendLedger(entries: SpendLedgerEntry[]): void {
+  saveConfig({ spendLedger: entries });
+}
+
 // ── Wallet helpers ─────────────────────────────────────────────────
 
 /**