@agentwonderland/mcp 0.1.45 → 0.1.47

package/dist/tools/solve.js

@@ -126,7 +126,7 @@ export function registerSolveTools(server) {
             .trim()
             .min(1)
             .optional()
-            .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+            .describe("Payment method — wallet ID, chain name (tempo, base, solana), 'link', or 'card'. Auto-detected if omitted."),
         confirmed: z
             .boolean()
             .optional()

package/dist/tools/wallet.js

@@ -1,24 +1,66 @@
 import { z } from "zod";
-import { getWallets, getCardConfig, setCardConfig, addWallet, getPendingCardSetupToken, getSpendPolicy, setSpendPolicy, } from "../core/config.js";
+import { getWallets, getCardConfig, getLinkConfig, getPendingLinkSetup, setPendingLinkSetup, setLinkConfig, setCardConfig, addWallet, getPendingCardSetupToken, getSpendPolicy, setDefaultPaymentMethod, setSpendPolicy, } from "../core/config.js";
 import { getWalletAddress, isCardPaymentEnabled } from "../core/payments.js";
 import { fetchUsdcBalance } from "../core/balances.js";
 import { getSettings } from "../core/settings.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks, getCardCapabilities, pollCardSetup, } from "../core/card-setup.js";
+import { getLinkCliAuthStatus, listLinkPaymentMethods, openLinkPaymentMethodAdd, startLinkCliLogin, } from "../core/link-cli.js";
 import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, listOwsWalletsByChain, installOws, platformSupportsOws, } from "../core/ows-adapter.js";
 import { ensureConsumerPrincipal, getConsumerPrincipal } from "../core/principal.js";
 import { MCP_PACKAGE_VERSION } from "../core/version.js";
 function text(t) {
     return { content: [{ type: "text", text: t }] };
 }
+function formatLinkApprovalPrompt(pending) {
+    return [
+        "Approve Agent Wonderland in Link:",
+        "",
+        pending.verificationUrl,
+        "",
+        `Verification phrase: ${pending.phrase}`,
+        "",
+        "After approving, run wallet_setup({ action: \"add-link\" }) again and I will finish connecting the payment method.",
+    ].join("\n");
+}
+function isFreshLinkSetup(pending) {
+    const createdAt = Date.parse(pending.createdAt);
+    if (!Number.isFinite(createdAt))
+        return false;
+    return Date.now() - createdAt < 10 * 60 * 1000;
+}
+function formatPaymentSetupMenu() {
+    return [
+        "Set up a payment method:",
+        "",
+        "1. Link card/bank (recommended)",
+        "   wallet_setup({ action: \"add-link\" })",
+        "",
+        "2. Tempo USDC",
+        "   wallet_setup({ action: \"create\", chain: \"tempo\" })",
+        "",
+        "3. Base USDC",
+        "   wallet_setup({ action: \"create\", chain: \"base\" })",
+        "",
+        "4. Solana USDC",
+        "   wallet_setup({ action: \"create\", chain: \"solana\" })",
+        "",
+        "5. Import an existing wallet",
+        "   wallet_setup({ action: \"import\", chain: \"base\", key: \"<private key>\" })",
+    ].join("\n");
+}
+function setDefaultCryptoPaymentMethod(chain) {
+    setDefaultPaymentMethod(chain === "solana" ? "solana" : chain === "base" ? "base" : "tempo");
+}
 export function registerWalletTools(server) {
     // ── wallet_status (extracted from check_wallet) ─────────────────
     server.tool("wallet_status", "Check payment readiness. Shows all configured wallets, their chains, addresses, and card status.", {}, async () => {
         const wallets = getWallets();
         const card = getCardConfig();
+        const link = getLinkConfig();
         const pendingCardSetupToken = getPendingCardSetupToken();
         const consumerPrincipal = await getConsumerPrincipal();
-        if (wallets.length === 0 && !card && !pendingCardSetupToken) {
-            return text("No payment methods configured.\nUse wallet_setup to create or import a wallet.");
+        if (wallets.length === 0 && !card && !link && !pendingCardSetupToken) {
+            return text(`No payment methods configured.\n\n${formatPaymentSetupMenu()}`);
         }
         const settings = await getSettings();
         const networkLabel = settings ? ` (${settings.network})` : "";
@@ -61,6 +103,14 @@ export function registerWalletTools(server) {
                 lines.push(`  Card MPP: unknown — ${capabilities.message ?? "Could not determine card payment readiness."}`);
             }
         }
+        if (link) {
+            const auth = await getLinkCliAuthStatus();
+            const label = link.label ? ` (${link.label})` : "";
+            lines.push(`  Link${label}: ${link.paymentMethodId}`);
+            lines.push(auth.authenticated
+                ? "  Link CLI: authenticated"
+                : "  Link CLI: not authenticated — run npx @stripe/link-cli auth login");
+        }
         if (pendingCardSetupToken) {
             lines.push("  Card setup: pending confirmation");
         }
@@ -77,10 +127,10 @@ export function registerWalletTools(server) {
         return text(lines.join("\n"));
     });
     // ── wallet_setup ────────────────────────────────────────────────
-    server.tool("wallet_setup", "Set up or manage a payment wallet. 'create' makes a new crypto wallet (encrypted via OWS if available, otherwise plaintext — run 'enable-ows' to upgrade). 'import' takes an existing private key. 'enable-ows' installs the Open Wallet Standard native module for encrypted at-rest storage. Tempo/Base share one EVM key; Solana uses a separate ed25519 key. NEVER delete or rotate keys programmatically; direct users to edit ~/.agentwonderland/config.json or ~/.ows/ manually.", {
+    server.tool("wallet_setup", "Set up or manage an Agent Wonderland payment method. Use 'start' for a guided setup menu. Link card/bank is recommended for most users. 'create' makes a new crypto wallet (encrypted via OWS if available, otherwise plaintext — run 'enable-ows' to upgrade). 'import' takes an existing private key. 'enable-ows' installs the Open Wallet Standard native module for encrypted at-rest storage. Tempo/Base share one EVM key; Solana uses a separate ed25519 key. NEVER delete or rotate keys programmatically; direct users to edit ~/.agentwonderland/config.json or ~/.ows/ manually.", {
         action: z
-            .enum(["create", "import", "add-card", "remove-card", "enable-ows"])
-            .describe("'create' a wallet, 'import' an existing key, 'enable-ows' to install encrypted key storage, 'add-card'/'remove-card' for credit card (may be disabled depending on Stripe SPT availability)"),
+            .enum(["start", "create", "import", "add-card", "remove-card", "add-link", "remove-link", "enable-ows"])
+            .describe("'start' shows the guided payment setup menu, 'add-link' connects Link card/bank, 'create' makes a crypto wallet, 'import' imports an existing key, 'enable-ows' installs encrypted key storage"),
         name: z
             .string()
             .optional()
@@ -91,7 +141,138 @@ export function registerWalletTools(server) {
             .describe("Private key hex string (required for 'import', ignored for 'create')"),
         chain: z.enum(["tempo", "base", "solana"]).optional()
             .describe("Primary chain (default: tempo). Tempo/Base use a shared EVM wallet; Solana uses a separate OWS wallet."),
-    }, async ({ action, name, key, chain }) => {
+        link_payment_method_id: z.string().optional()
+            .describe("Link payment method ID from `npx @stripe/link-cli payment-methods list`; used with action 'add-link'."),
+        link_payment_method: z.string().optional()
+            .describe("Friendly Link payment method selector, such as a card/bank name or last4; used with action 'add-link'."),
+    }, async ({ action, name, key, chain, link_payment_method_id, link_payment_method }) => {
+        if (action === "start") {
+            return text(formatPaymentSetupMenu());
+        }
+        // ── Link setup flow ──────────────────────────────────────
+        if (action === "add-link") {
+            let auth = await getLinkCliAuthStatus();
+            if (!auth.authenticated) {
+                const pending = getPendingLinkSetup();
+                if (pending && isFreshLinkSetup(pending)) {
+                    return text(formatLinkApprovalPrompt(pending));
+                }
+                if (pending) {
+                    setPendingLinkSetup(null);
+                }
+                try {
+                    const login = await startLinkCliLogin();
+                    setPendingLinkSetup({
+                        verificationUrl: login.verificationUrl,
+                        phrase: login.phrase,
+                        createdAt: new Date().toISOString(),
+                    });
+                    auth = await getLinkCliAuthStatus();
+                    if (!auth.authenticated) {
+                        return text(formatLinkApprovalPrompt({
+                            verificationUrl: login.verificationUrl,
+                            phrase: login.phrase,
+                        }));
+                    }
+                }
+                catch (err) {
+                    return text([
+                        "Link authentication could not start from the MCP session.",
+                        `Reason: ${err instanceof Error ? err.message : String(err)}`,
+                        "",
+                        "Run wallet_setup({ action: \"add-link\" }) again to retry.",
+                    ].join("\n"));
+                }
+            }
+            setPendingLinkSetup(null);
+            const explicitLinkSelector = link_payment_method_id ?? link_payment_method;
+            if (explicitLinkSelector) {
+                const methods = await listLinkPaymentMethods();
+                const normalizedSelector = explicitLinkSelector.toLowerCase().trim();
+                const exact = methods.find((method) => method.id === explicitLinkSelector);
+                const matches = exact
+                    ? [exact]
+                    : methods.filter((method) => method.searchText?.includes(normalizedSelector));
+                if (matches.length === 0 && !link_payment_method_id) {
+                    return text([
+                        `No Link payment method matched "${explicitLinkSelector}".`,
+                        "",
+                        "Available methods:",
+                        ...methods.map((method) => `  ${method.label ?? method.id}${method.label ? ` (${method.id})` : ""}`),
+                    ].join("\n"));
+                }
+                if (matches.length > 1) {
+                    return text([
+                        `Multiple Link payment methods matched "${explicitLinkSelector}". Choose one:`,
+                        ...matches.map((method) => `  ${method.label ?? method.id}${method.label ? ` (${method.id})` : ""}`),
+                        "",
+                        "Then run:",
+                        "  wallet_setup({ action: \"add-link\", link_payment_method: \"<name or last4>\" })",
+                    ].join("\n"));
+                }
+                const selected = matches[0] ?? { id: link_payment_method_id, label: name };
+                setLinkConfig({
+                    paymentMethodId: selected.id,
+                    label: name ?? selected.label,
+                });
+                const principal = await ensureConsumerPrincipal();
+                return text([
+                    "Link payment method connected.",
+                    `  Payment method: ${selected.label ?? selected.id}${selected.label ? ` (${selected.id})` : ""}`,
+                    `  Consumer principal: ${principal}`,
+                    "",
+                    "Use pay_with: \"link\" for agent runs.",
+                ].join("\n"));
+            }
+            let methods = await listLinkPaymentMethods();
+            if (methods.length === 0) {
+                try {
+                    await openLinkPaymentMethodAdd();
+                    methods = await listLinkPaymentMethods();
+                }
+                catch (err) {
+                    return text([
+                        "No Link payment methods are available yet.",
+                        `Reason: ${err instanceof Error ? err.message : String(err)}`,
+                        "",
+                        "Run wallet_setup({ action: \"add-link\" }) again after adding a payment method in Link.",
+                    ].join("\n"));
+                }
+                if (methods.length === 0) {
+                    return text("Link payment-method setup was started. Run wallet_setup({ action: \"add-link\" }) again after adding a payment method in Link.");
+                }
+            }
+            if (methods.length === 1) {
+                const method = methods[0];
+                setLinkConfig({
+                    paymentMethodId: method.id,
+                    label: method.label,
+                });
+                const principal = await ensureConsumerPrincipal();
+                return text([
+                    "Link payment method connected.",
+                    `  Payment method: ${method.id}${method.label ? ` (${method.label})` : ""}`,
+                    `  Consumer principal: ${principal}`,
+                    "",
+                    "Use pay_with: \"link\" for agent runs.",
+                ].join("\n"));
+            }
+            return text([
+                "Multiple Link payment methods found. Choose one:",
+                ...methods.map((method) => `  ${method.label ?? method.id}${method.label ? ` (${method.id})` : ""}`),
+                "",
+                "Then run:",
+                "  wallet_setup({ action: \"add-link\", link_payment_method: \"<name or last4>\" })",
+            ].join("\n"));
+        }
+        if (action === "remove-link") {
+            const existing = getLinkConfig();
+            if (!existing) {
+                return text("No Link payment method is currently connected.");
+            }
+            setLinkConfig(null);
+            return text(`Removed Link payment method ${existing.paymentMethodId}.`);
+        }
         // ── Card setup flow ──────────────────────────────────────
         if (action === "add-card") {
             if (!isCardPaymentEnabled()) {
@@ -206,6 +387,7 @@ export function registerWalletTools(server) {
                             chainStatus = "Already linked to Agent Wonderland.";
                         }
                     }
+                    setDefaultCryptoPaymentMethod(defaultCh);
                     const principal = await ensureConsumerPrincipal();
                     return text([
                         "Found existing OWS wallet:",
@@ -239,6 +421,7 @@ export function registerWalletTools(server) {
                         defaultChain: "solana",
                         label: walletName,
                     });
+                    setDefaultCryptoPaymentMethod("solana");
                     const principal = await ensureConsumerPrincipal();
                     const owsNudge = platformSupportsOws()
                         ? "\n\n⚠ Key stored in plaintext at ~/.agentwonderland/config.json. Run wallet_setup({ action: \"enable-ows\" }) to install encrypted at-rest storage — takes ~30s."
@@ -266,6 +449,7 @@ export function registerWalletTools(server) {
                     defaultChain: defaultCh === "solana" ? "tempo" : defaultCh,
                     label: walletName,
                 });
+                setDefaultCryptoPaymentMethod(defaultCh);
                 const principal = await ensureConsumerPrincipal();
                 const owsNudge = platformSupportsOws()
                     ? "\n\n⚠ Key stored in plaintext at ~/.agentwonderland/config.json. Run wallet_setup({ action: \"enable-ows\" }) to install encrypted at-rest storage — takes ~30s."
@@ -293,6 +477,7 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            setDefaultCryptoPaymentMethod(defaultCh);
             const principal = await ensureConsumerPrincipal();
             return text([
                 `Wallet created [encrypted]:`,
@@ -321,6 +506,7 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            setDefaultCryptoPaymentMethod(defaultCh);
             const principal = await ensureConsumerPrincipal();
             return text([
                 `Key imported to OWS [encrypted]:`,
@@ -349,6 +535,7 @@ export function registerWalletTools(server) {
                     defaultChain: "solana",
                     label: walletName,
                 });
+                setDefaultCryptoPaymentMethod("solana");
                 const principal = await ensureConsumerPrincipal();
                 const owsNudge = platformSupportsOws()
                     ? "\n\n⚠ Key stored in plaintext at ~/.agentwonderland/config.json. Run wallet_setup({ action: \"enable-ows\" }) to install encrypted at-rest storage — takes ~30s."
@@ -382,6 +569,7 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            setDefaultCryptoPaymentMethod(defaultCh);
             const principal = await ensureConsumerPrincipal();
             const owsNudge = platformSupportsOws()
                 ? "\n\n⚠ Key stored in plaintext at ~/.agentwonderland/config.json. Run wallet_setup({ action: \"enable-ows\" }) to install encrypted at-rest storage — takes ~30s."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {

package/src/core/__tests__/payments.test.ts

@@ -8,21 +8,25 @@ let currentCard = {
   last4: "1111",
   brand: "visa",
 };
+let currentLink: { paymentMethodId: string; label?: string } | null = null;
 
 let currentDefaultWallet: any;
 let currentWallets: any[] = [];
 let currentResolvedMethod: { wallet: any; chain: string } | null = null;
+let currentDefaultPaymentMethod = "card";
 
 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");
+const mockCreateLinkSharedPaymentToken = vi.fn(async (_config: unknown) => "spt_test");
 
 vi.mock("../config.js", () => ({
   getApiUrl: () => "http://api.test",
   getCardConfig: () => currentCard,
-  getConfig: () => ({ defaultPaymentMethod: "card" }),
+  getLinkConfig: () => currentLink,
+  getConfig: () => ({ defaultPaymentMethod: currentDefaultPaymentMethod }),
   getDefaultWallet: () => currentDefaultWallet,
   getWallets: () => currentWallets,
   resolveWalletAndChain: () => currentResolvedMethod,
@@ -43,10 +47,15 @@ vi.mock("../base-charge.js", () => ({
   baseChargeClient: (config: unknown) => mockBaseChargeClient(config),
 }));
 
+vi.mock("../link-cli.js", () => ({
+  createLinkSharedPaymentToken: (config: unknown) => mockCreateLinkSharedPaymentToken(config),
+}));
+
 describe("payment method initialization", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.resetModules();
+    delete process.env.AGENTWONDERLAND_LINK_APPROVAL_LIMIT_CENTS;
     currentCard = {
       consumerToken: "consumer_one",
       paymentMethodId: "pm_one",
@@ -56,6 +65,8 @@ describe("payment method initialization", () => {
     currentDefaultWallet = undefined;
     currentWallets = [];
     currentResolvedMethod = null;
+    currentLink = null;
+    currentDefaultPaymentMethod = "card";
     mockMppxCreate
       .mockReturnValueOnce({ fetch: createdFetches[0] })
       .mockReturnValueOnce({ fetch: createdFetches[1] })
@@ -116,4 +127,70 @@ describe("payment method initialization", () => {
       expect.objectContaining({ methods: ["tempo_method"], polyfill: false }),
     );
   });
+
+  it("initializes Stripe SPT method when Link is requested", async () => {
+    currentLink = {
+      paymentMethodId: "csmrpd_link_123",
+      label: "Visa ****4242",
+    };
+    currentDefaultPaymentMethod = "link";
+
+    const { getPaymentFetch } = await import("../payments.js");
+    await getPaymentFetch("link");
+
+    expect(mockStripe).toHaveBeenCalledWith(
+      expect.objectContaining({ paymentMethod: "csmrpd_link_123" }),
+    );
+    expect(mockMppxCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        methods: [expect.objectContaining({ paymentMethod: "csmrpd_link_123" })],
+        polyfill: false,
+      }),
+    );
+
+    const stripeConfig = mockStripe.mock.calls[0]?.[0] as {
+      createToken: (params: {
+        amount: string;
+        currency: string;
+        expiresAt: number;
+        metadata?: Record<string, string>;
+        networkId: string;
+      }) => Promise<string>;
+    };
+    await stripeConfig.createToken({
+      amount: "25",
+      currency: "usd",
+      expiresAt: 1778290000,
+      networkId: "profile_test",
+    });
+
+    expect(mockCreateLinkSharedPaymentToken).toHaveBeenCalledWith(
+      expect.objectContaining({
+        amount: "10000",
+        currency: "usd",
+        networkId: "profile_test",
+        paymentMethodId: "csmrpd_link_123",
+      }),
+    );
+    const linkTokenRequest = mockCreateLinkSharedPaymentToken.mock.calls[0]?.[0] as { context: string } | undefined;
+    expect(linkTokenRequest?.context).toContain("up to USD 100.00");
+    expect(linkTokenRequest?.context).toContain("quoted at USD 0.25");
+  });
+
+  it("advertises Link as Stripe SPT compatibility", async () => {
+    currentLink = {
+      paymentMethodId: "csmrpd_link_123",
+    };
+    currentDefaultPaymentMethod = "link";
+
+    const { getAcceptedPaymentMethods, getCompatiblePaymentMethods } = await import("../payments.js");
+
+    expect(getAcceptedPaymentMethods()).toEqual(["stripe_card", "card"]);
+    expect(getCompatiblePaymentMethods({
+      payment: { accepted_payments: ["stripe_card"] },
+    } as any)).toEqual(["link"]);
+    expect(getCompatiblePaymentMethods({
+      payment: { accepted_payments: ["card"] },
+    } as any)).toEqual(["link"]);
+  });
 });

package/src/core/__tests__/principal.test.ts

@@ -114,6 +114,29 @@ describe("consumer principal helpers", () => {
     );
   });
 
+  it("uses the default consumer principal for Link payments", async () => {
+    state.wallets = [
+      { id: "aw-main", keyType: "ows", owsWalletId: "ows-main", chains: ["tempo", "base"], defaultChain: "base" },
+    ];
+    state.addresses = {
+      "aw-main": "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+      base: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+    };
+
+    const { getConsumerPrincipalForMethod } = await import("../principal.js");
+    const principal = await getConsumerPrincipalForMethod("link");
+
+    expect(principal).toBe("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+  });
+
+  it("creates a fallback identity wallet for Link payments when no wallet exists", async () => {
+    const { ensureConsumerPrincipalForMethod } = await import("../principal.js");
+    const principal = await ensureConsumerPrincipalForMethod("link");
+
+    expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
+    expect(state.addedWallets).toHaveLength(1);
+  });
+
   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" },

package/src/core/config.ts

@@ -21,6 +21,17 @@ export interface CardConfig {
   brand: string;
 }
 
+export interface LinkConfig {
+  paymentMethodId: string;
+  label?: string;
+}
+
+export interface PendingLinkSetup {
+  verificationUrl: string;
+  phrase: string;
+  createdAt: string;
+}
+
 export interface SpendPolicy {
   maxPerTxUsd?: number;
   maxPerDayUsd?: number;
@@ -42,6 +53,8 @@ export interface Config {
   defaultWallet: string | null;
   defaultPaymentMethod?: string;
   card: CardConfig | null;
+  link: LinkConfig | null;
+  pendingLinkSetup?: PendingLinkSetup | null;
   pendingCardSetupToken?: string | null;
   favorites: string[];
   /** Require user confirmation before spending. Default: true. Set false for headless/automated use. */
@@ -98,6 +111,8 @@ interface LegacyConfig {
   wallets?: WalletEntry[];
   defaultWallet?: string | null;
   card?: CardConfig | null;
+  link?: LinkConfig | null;
+  pendingLinkSetup?: PendingLinkSetup | null;
   pendingCardSetupToken?: string | null;
   spendPolicies?: Record<string, SpendPolicy>;
   spendLedger?: SpendLedgerEntry[];
@@ -119,6 +134,8 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
       defaultWallet: raw.defaultWallet ?? null,
       defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
       card: raw.card ?? null,
+      link: raw.link ?? null,
+      pendingLinkSetup: raw.link ? null : (raw.pendingLinkSetup ?? null),
       pendingCardSetupToken: (r.pendingCardSetupToken as string | null | undefined) ?? null,
       favorites: r.favorites as string[] ?? [],
       confirmBeforeSpend: r.confirmBeforeSpend !== false,
@@ -195,6 +212,8 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
     defaultWallet,
     defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
     card,
+    link: raw.link ?? null,
+    pendingLinkSetup: raw.link ? null : (raw.pendingLinkSetup ?? null),
     pendingCardSetupToken: null,
     favorites: [],
     confirmBeforeSpend: true,
@@ -222,6 +241,8 @@ export function getConfig(): Config {
     wallets: [],
     defaultWallet: null,
     card: null,
+    link: null,
+    pendingLinkSetup: null,
     pendingCardSetupToken: null,
     favorites: [],
     confirmBeforeSpend: true,
@@ -286,6 +307,10 @@ export function setSpendPolicy(method: string, policy: SpendPolicy): void {
   saveConfig({ spendPolicies: policies });
 }
 
+export function setDefaultPaymentMethod(defaultPaymentMethod: string | undefined): void {
+  saveConfig({ defaultPaymentMethod });
+}
+
 export function getSpendLedger(): SpendLedgerEntry[] {
   return getConfig().spendLedger ?? [];
 }
@@ -399,6 +424,14 @@ export function getCardConfig(): CardConfig | null {
   return getConfig().card;
 }
 
+export function getLinkConfig(): LinkConfig | null {
+  return getConfig().link;
+}
+
+export function getPendingLinkSetup(): PendingLinkSetup | null {
+  return getConfig().pendingLinkSetup ?? null;
+}
+
 /**
  * Save card configuration after setup.
  */
@@ -421,6 +454,29 @@ export function setCardConfig(card: CardConfig | null): void {
   }
 }
 
+export function setLinkConfig(link: LinkConfig | null): void {
+  const current = getConfig();
+  if (link) {
+    saveConfig({
+      link,
+      defaultPaymentMethod: "link",
+      pendingLinkSetup: null,
+    });
+  } else {
+    saveConfig({
+      link,
+      pendingLinkSetup: null,
+      defaultPaymentMethod: current.defaultPaymentMethod === "link"
+        ? undefined
+        : current.defaultPaymentMethod,
+    });
+  }
+}
+
+export function setPendingLinkSetup(pendingLinkSetup: PendingLinkSetup | null): void {
+  saveConfig({ pendingLinkSetup });
+}
+
 export function getPendingCardSetupToken(): string | null {
   return getConfig().pendingCardSetupToken ?? null;
 }