@moonpay/cli 0.6.9 → 0.6.11

package/dist/{chunk-ZWMKESOK.js → chunk-6TW2YUWK.js}

@@ -12,13 +12,12 @@ import {
   expandAddresses,
   findWalletOrThrow,
   getEncryptionKey,
-  keyChainSchema,
   loadWallets,
   mutateWallets,
   removeWallet,
   resolveSigningKey,
   walletInfoSchema
-} from "./chunk-AL5WDHLT.js";
+} from "./chunk-ZYYH3VNA.js";
 
 // src/auth.ts
 import * as fs from "fs";
@@ -332,7 +331,7 @@ var schemas_default = [
   },
   {
     name: "deposit_create",
-    description: "Create a new deposit link that generates multi-chain deposit addresses. Anyone can send crypto to these addresses from Solana, Ethereum, Bitcoin, or Tron \u2014 it automatically converts to USDC and settles to the specified destination wallet and chain.",
+    description: "Create a new deposit link that generates multi-chain deposit addresses. Anyone can send crypto to these addresses from Solana, Ethereum, Bitcoin, or Tron \u2014 it automatically converts to the specified stablecoin and settles to the destination wallet and chain.",
     inputSchema: {
       $ref: "#/definitions/deposit_create_input",
       definitions: {
@@ -357,13 +356,23 @@ var schemas_default = [
                 "arbitrum",
                 "bnb"
               ],
-              description: "Blockchain of the destination wallet (determines which USDC the wallet receives)"
+              description: "Blockchain of the destination wallet"
+            },
+            token: {
+              type: "string",
+              enum: [
+                "USDC",
+                "USDC.e",
+                "USDT"
+              ],
+              description: "Token to receive. USDC.e (bridged USDC) is only available on Polygon."
             }
           },
           required: [
             "name",
             "wallet",
-            "chain"
+            "chain",
+            "token"
           ],
           additionalProperties: false
         }
@@ -382,11 +391,11 @@ var schemas_default = [
             },
             destinationWallet: {
               type: "string",
-              description: "Wallet address that will receive USDC"
+              description: "Wallet address that will receive the stablecoin"
             },
             destinationChain: {
               type: "string",
-              description: "Chain where USDC will be delivered"
+              description: "Chain where the stablecoin will be delivered"
             },
             customerToken: {
               type: "string",
@@ -5074,10 +5083,18 @@ var schemas_default = [
                 }
               ],
               description: "Filter: pending (need to accept, default) or accepted (already signed)"
+            },
+            country: {
+              type: [
+                "string",
+                "null"
+              ],
+              description: "Country code for terms (e.g. USA, GBR). Defaults to USA."
             }
           },
           required: [
-            "status"
+            "status",
+            "country"
           ],
           additionalProperties: false
         }
@@ -5984,27 +6001,20 @@ var schemas_default = [
               description: "Signature of the message, signed by the wallet's private key"
             },
             chain: {
-              anyOf: [
-                {
-                  type: "string",
-                  enum: [
-                    "solana",
-                    "ethereum",
-                    "base",
-                    "polygon",
-                    "arbitrum",
-                    "optimism",
-                    "bnb",
-                    "avalanche",
-                    "tron",
-                    "bitcoin"
-                  ]
-                },
-                {
-                  type: "null"
-                }
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism",
+                "bnb",
+                "avalanche",
+                "tron",
+                "bitcoin"
               ],
-              description: "Blockchain (defaults to solana)"
+              description: "Blockchain for wallet registration (solana, ethereum, polygon, base, arbitrum)"
             }
           },
           required: [
@@ -6082,11 +6092,10 @@ var schemas_default = [
   }
 ];
 
-// src/tools/wallet/create/tool.ts
-import { generateMnemonic } from "@scure/bip39";
-import { wordlist as english } from "@scure/bip39/wordlists/english";
-import { execSync } from "child_process";
-import { platform } from "os";
+// src/tools/consent/check/tool.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
 
 // src/tools/shared.ts
 var defineToolSchema = (config) => config;
@@ -6099,36 +6108,59 @@ var createTool = (schema, handler) => ({
   }
 });
 
-// src/tools/wallet/create/schema.ts
+// src/tools/consent/check/schema.ts
 import { z } from "zod";
+var consentCheckSchema = defineToolSchema({
+  name: "consent_check",
+  description: "Check whether the MoonPay Terms of Service and Privacy Policy have been accepted. Throws if not accepted.",
+  input: z.object({}),
+  output: z.object({
+    accepted: z.literal(true),
+    tosVersion: z.string(),
+    acceptedAt: z.string()
+  })
+});
+
+// src/tools/consent/check/tool.ts
+var CONSENT_PATH = path2.join(os2.homedir(), ".config", "moonpay", "consent.json");
+var CURRENT_TOS_VERSION = "1.0";
+var consentCheck = createTool(consentCheckSchema, async () => {
+  let consent = null;
+  try {
+    consent = JSON.parse(fs2.readFileSync(CONSENT_PATH, "utf-8"));
+  } catch {
+  }
+  if (!consent || consent.tosVersion !== CURRENT_TOS_VERSION) {
+    throw new Error(
+      "Terms of Service not yet accepted. Run `mp consent accept` first."
+    );
+  }
+  return {
+    accepted: true,
+    tosVersion: consent.tosVersion,
+    acceptedAt: consent.acceptedAt
+  };
+});
+
+// src/tools/wallet/create/tool.ts
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist as english } from "@scure/bip39/wordlists/english";
+
+// src/tools/wallet/create/schema.ts
+import { z as z2 } from "zod";
 var walletCreateSchema = defineToolSchema({
   name: "wallet_create",
   description: "Create a new multi-chain HD wallet. Generates a BIP39 mnemonic and derives addresses for Solana, Ethereum, Bitcoin, and Tron. The mnemonic is copied to clipboard (interactive) or omitted (headless). Keys are encrypted with a random key stored in the OS keychain.",
-  input: z.object({
-    name: z.string().describe("Wallet name")
+  input: z2.object({
+    name: z2.string().describe("Wallet name")
   }),
-  output: z.object({
-    name: z.string(),
-    addresses: z.record(keyChainSchema, z.string())
+  output: z2.object({
+    name: z2.string(),
+    addresses: z2.record(chainSchema, z2.string())
   })
 });
 
 // src/tools/wallet/create/tool.ts
-function copyToClipboard(text) {
-  try {
-    const os2 = platform();
-    if (os2 === "darwin") {
-      execSync("pbcopy", { input: text, stdio: ["pipe", "ignore", "ignore"] });
-      return true;
-    }
-    if (os2 === "linux") {
-      execSync("xclip -selection clipboard", { input: text, stdio: ["pipe", "ignore", "ignore"] });
-      return true;
-    }
-  } catch {
-  }
-  return false;
-}
 var walletCreate = createTool(walletCreateSchema, async (params) => {
   const mnemonic = generateMnemonic(english, 256);
   const addresses = deriveAllAddresses(mnemonic);
@@ -6139,19 +6171,6 @@ var walletCreate = createTool(walletCreateSchema, async (params) => {
     addresses,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  if (process.stdout.isTTY) {
-    const copied = copyToClipboard(mnemonic);
-    if (copied) {
-      process.stderr.write(
-        "\nMnemonic copied to clipboard. Paste it into your password manager.\nClipboard will be cleared in 30 seconds.\n\n"
-      );
-      setTimeout(() => copyToClipboard(""), 3e4).unref();
-    } else {
-      process.stderr.write(
-        "\nCould not copy to clipboard. Run `mp wallet export` to view your mnemonic.\n\n"
-      );
-    }
-  }
   return { name: params.name, addresses: expandAddresses(addresses) };
 });
 
@@ -6163,19 +6182,19 @@ import bs58 from "bs58";
 import { privateKeyToAccount } from "viem/accounts";
 
 // src/tools/wallet/import/schema.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var walletImportSchema = defineToolSchema({
   name: "wallet_import",
   description: "Import a wallet from a BIP39 mnemonic (HD, all chains) or a single private key (one chain). Provide either --mnemonic or --key, not both.",
-  input: z2.object({
-    name: z2.string().describe("Wallet name"),
-    mnemonic: z2.string().nullable().describe("BIP39 mnemonic seed phrase (for HD wallet import)"),
-    key: z2.string().nullable().describe("Private key: base58 for Solana, hex for EVM/Bitcoin"),
+  input: z3.object({
+    name: z3.string().describe("Wallet name"),
+    mnemonic: z3.string().nullable().describe("BIP39 mnemonic seed phrase (for HD wallet import)"),
+    key: z3.string().nullable().describe("Private key: base58 for Solana, hex for EVM/Bitcoin"),
     chain: chainSchema.nullable().describe("Chain for single-key import (default solana)")
   }),
-  output: z2.object({
-    name: z2.string(),
-    type: z2.enum(["hd", "imported"]),
+  output: z3.object({
+    name: z3.string(),
+    type: z3.enum(["hd", "imported"]),
     addresses: addressesSchema
   })
 });
@@ -6234,12 +6253,12 @@ var walletImport = createTool(walletImportSchema, async (params) => {
 });
 
 // src/tools/wallet/list/schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var walletListSchema = defineToolSchema({
   name: "wallet_list",
   description: "List all local wallets",
-  input: z3.object({}),
-  output: z3.array(walletInfoSchema)
+  input: z4.object({}),
+  output: z4.array(walletInfoSchema)
 });
 
 // src/tools/wallet/list/tool.ts
@@ -6254,12 +6273,12 @@ var walletList = createTool(walletListSchema, async () => {
 });
 
 // src/tools/wallet/retrieve/schema.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var walletRetrieveSchema = defineToolSchema({
   name: "wallet_retrieve",
   description: "Get details of a specific wallet",
-  input: z4.object({
-    wallet: z4.string().describe("Wallet name or address")
+  input: z5.object({
+    wallet: z5.string().describe("Wallet name or address")
   }),
   output: walletInfoSchema
 });
@@ -6276,17 +6295,17 @@ var walletRetrieve = createTool(walletRetrieveSchema, async (params) => {
 });
 
 // src/tools/wallet/delete/schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var walletDeleteSchema = defineToolSchema({
   name: "wallet_delete",
   description: "Permanently delete a local wallet. This removes the private key file and cannot be undone.",
-  input: z5.object({
-    wallet: z5.string().describe("Name or address of the wallet to delete"),
-    confirm: z5.boolean().describe("Must be true to confirm deletion")
+  input: z6.object({
+    wallet: z6.string().describe("Name or address of the wallet to delete"),
+    confirm: z6.boolean().describe("Must be true to confirm deletion")
   }),
-  output: z5.object({
-    name: z5.string().describe("Name of the deleted wallet"),
-    deleted: z5.literal(true)
+  output: z6.object({
+    name: z6.string().describe("Name of the deleted wallet"),
+    deleted: z6.literal(true)
   })
 });
 
@@ -6303,17 +6322,17 @@ var walletDelete = createTool(walletDeleteSchema, async (params) => {
 });
 
 // src/tools/wallet/rename/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var walletRenameSchema = defineToolSchema({
   name: "wallet_rename",
   description: "Rename a local wallet.",
-  input: z6.object({
-    wallet: z6.string().describe("Current name or address of the wallet"),
-    name: z6.string().describe("New name for the wallet")
+  input: z7.object({
+    wallet: z7.string().describe("Current name or address of the wallet"),
+    name: z7.string().describe("New name for the wallet")
   }),
-  output: z6.object({
-    oldName: z6.string(),
-    newName: z6.string()
+  output: z7.object({
+    oldName: z7.string(),
+    newName: z7.string()
   })
 });
 
@@ -6336,6 +6355,48 @@ var walletRename = createTool(walletRenameSchema, async (params) => {
   return { oldName, newName: params.name };
 });
 
+// src/tools/wallet/export/schema.ts
+import { z as z8 } from "zod";
+var walletExportSchema = defineToolSchema({
+  name: "wallet_export",
+  description: "Export wallet secret (mnemonic or private key). Interactive only \u2014 cannot be run by agents or piped.",
+  input: z8.object({
+    wallet: z8.string().describe("Wallet name")
+  }),
+  output: z8.object({
+    exported: z8.literal(true)
+  })
+});
+
+// src/tools/wallet/export/tool.ts
+var walletExport = createTool(walletExportSchema, async (params) => {
+  if (!process.stdout.isTTY) {
+    throw new Error(
+      "Wallet export requires an interactive terminal.\nRun this command directly in your terminal: mp wallet export " + params.wallet
+    );
+  }
+  const wallet = findWalletOrThrow(params.wallet);
+  if (wallet.type === "hd") {
+    process.stderr.write(`
+Mnemonic for "${wallet.name}":
+
+`);
+    process.stderr.write(`  ${wallet.mnemonic}
+
+`);
+    process.stderr.write("Write this down and store it securely.\n\n");
+  } else {
+    process.stderr.write(`
+Private key for "${wallet.name}" (${wallet.chain}):
+
+`);
+    process.stderr.write(`  ${wallet.privateKey}
+
+`);
+  }
+  return { exported: true };
+});
+
 // src/tools/transaction/sign/tool.ts
 import { createHash } from "crypto";
 import { Keypair as Keypair2, VersionedTransaction } from "@solana/web3.js";
@@ -6346,19 +6407,19 @@ import * as viemChains from "viem/chains";
 import * as ecc from "tiny-secp256k1";
 
 // src/tools/transaction/sign/schema.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 var transactionSignSchema = defineToolSchema({
   name: "transaction_sign",
   description: "Sign a transaction with a local wallet. Supports Solana (VersionedTransaction), EVM (RLP-encoded), and Bitcoin (PSBT) transactions.",
-  input: z7.object({
-    wallet: z7.string().describe("Wallet name or address"),
+  input: z9.object({
+    wallet: z9.string().describe("Wallet name or address"),
     chain: chainSchema.describe(
       "Chain: solana, ethereum, base, arbitrum, or bitcoin"
     ),
-    transaction: z7.string().describe("Base64-encoded unsigned transaction")
+    transaction: z9.string().describe("Base64-encoded unsigned transaction")
   }),
-  output: z7.object({
-    transaction: z7.string().describe("Base64-encoded signed transaction")
+  output: z9.object({
+    transaction: z9.string().describe("Base64-encoded signed transaction")
   })
 });
 
@@ -6473,19 +6534,19 @@ import { keccak_256 } from "@noble/hashes/sha3";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 
 // src/tools/message/sign/schema.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var messageSignSchema = defineToolSchema({
   name: "message_sign",
   description: "Sign a message with a local wallet. Supports Solana (ed25519), EVM (EIP-191 personal sign), and Bitcoin (secp256k1 ECDSA).",
-  input: z8.object({
-    wallet: z8.string().describe("Wallet address or name to sign with"),
+  input: z10.object({
+    wallet: z10.string().describe("Wallet address or name to sign with"),
     chain: chainSchema.describe(
       "Chain: solana, ethereum, base, arbitrum, or bitcoin"
     ),
-    message: z8.string().describe("Message text to sign")
+    message: z10.string().describe("Message text to sign")
   }),
-  output: z8.object({
-    signature: z8.string().describe(
+  output: z10.object({
+    signature: z10.string().describe(
       "Signature: base58 for Solana, hex (0x-prefixed) for EVM/Bitcoin"
     )
   })
@@ -6545,26 +6606,26 @@ function signBitcoin2(privateKey, messageBytes) {
 import https from "https";
 
 // src/tools/bitcoin/balance/schema.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var bitcoinBalanceRetrieveSchema = defineToolSchema({
   name: "bitcoin_balance_retrieve",
   description: "Get the BTC balance of a Bitcoin address. Returns confirmed and unconfirmed balances in BTC and satoshis.",
-  input: z9.object({
-    wallet: z9.string().describe("Bitcoin address (bc1...) or wallet name")
+  input: z11.object({
+    wallet: z11.string().describe("Bitcoin address (bc1...) or wallet name")
   }),
-  output: z9.object({
-    address: z9.string().describe("Bitcoin address"),
-    confirmed: z9.object({
-      btc: z9.string().describe("Confirmed balance in BTC"),
-      sats: z9.number().describe("Confirmed balance in satoshis")
+  output: z11.object({
+    address: z11.string().describe("Bitcoin address"),
+    confirmed: z11.object({
+      btc: z11.string().describe("Confirmed balance in BTC"),
+      sats: z11.number().describe("Confirmed balance in satoshis")
     }),
-    unconfirmed: z9.object({
-      btc: z9.string().describe("Unconfirmed (pending) balance in BTC"),
-      sats: z9.number().describe("Unconfirmed (pending) balance in satoshis")
+    unconfirmed: z11.object({
+      btc: z11.string().describe("Unconfirmed (pending) balance in BTC"),
+      sats: z11.number().describe("Unconfirmed (pending) balance in satoshis")
     }),
-    total: z9.object({
-      btc: z9.string().describe("Total balance in BTC"),
-      sats: z9.number().describe("Total balance in satoshis")
+    total: z11.object({
+      btc: z11.string().describe("Total balance in BTC"),
+      sats: z11.number().describe("Total balance in satoshis")
     })
   })
 });
@@ -6599,7 +6660,7 @@ var bitcoinBalanceRetrieve = createTool(
   async (params) => {
     let address = params.wallet;
     if (!address.startsWith("bc1") && !address.startsWith("1") && !address.startsWith("3")) {
-      const { findWalletOrThrow: findWalletOrThrow2 } = await import("./store-QVVENVIP.js");
+      const { findWalletOrThrow: findWalletOrThrow2 } = await import("./store-6OIOBMHW.js");
       const wallet = findWalletOrThrow2(address);
       const btcAddress = wallet.addresses.bitcoin;
       if (!btcAddress) {
@@ -6624,28 +6685,141 @@ var bitcoinBalanceRetrieve = createTool(
   }
 );
 
+// src/tools/skill/server.ts
+import { readdirSync, readFileSync as readFileSync3, existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath } from "url";
+function getSkillsDir() {
+  const __filename = fileURLToPath(import.meta.url);
+  const distDir = dirname(__filename);
+  return join3(distDir, "..", "skills");
+}
+function getClaudeSkillsDir() {
+  return join3(homedir3(), ".claude", "skills");
+}
+function listBundledSkills() {
+  const dir = getSkillsDir();
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("moonpay-")).map((e) => {
+    const md = readFileSync3(join3(dir, e.name, "SKILL.md"), "utf-8");
+    const descMatch = md.match(/^description:\s*(.+)$/m);
+    return {
+      name: e.name,
+      description: descMatch?.[1]?.replace(/^["']|["']$/g, "") ?? ""
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function readSkill(name) {
+  if (/[/\\]|\.\./.test(name)) throw new Error(`Invalid skill name: "${name}"`);
+  const skillPath = join3(getSkillsDir(), name, "SKILL.md");
+  if (!existsSync2(skillPath)) {
+    throw new Error(`Skill "${name}" not found. Run \`mp skill list\` to see available skills.`);
+  }
+  return readFileSync3(skillPath, "utf-8");
+}
+function installSkills(force, dir) {
+  const srcDir = getSkillsDir();
+  const destDir = dir ?? getClaudeSkillsDir();
+  const skills = listBundledSkills();
+  mkdirSync2(destDir, { recursive: true });
+  return skills.map((s) => {
+    const dest = join3(destDir, s.name);
+    if (existsSync2(dest) && !force) {
+      return { name: s.name, installed: false };
+    }
+    cpSync(join3(srcDir, s.name), dest, { recursive: true, force: true });
+    return { name: s.name, installed: true };
+  });
+}
+
+// src/tools/skill/list/schema.ts
+import { z as z12 } from "zod";
+var skillListSchema = defineToolSchema({
+  name: "skill_list",
+  description: "List available AI skills for Claude Code and other agents",
+  input: z12.object({}),
+  output: z12.array(
+    z12.object({
+      name: z12.string(),
+      description: z12.string()
+    })
+  )
+});
+
+// src/tools/skill/list/tool.ts
+var skillList = createTool(skillListSchema, async () => {
+  return listBundledSkills();
+});
+
+// src/tools/skill/retrieve/schema.ts
+import { z as z13 } from "zod";
+var skillRetrieveSchema = defineToolSchema({
+  name: "skill_retrieve",
+  description: "Get the full instructions for a specific skill",
+  input: z13.object({
+    name: z13.string().describe("Skill name (e.g. moonpay-swap-tokens)")
+  }),
+  output: z13.object({
+    name: z13.string(),
+    content: z13.string()
+  })
+});
+
+// src/tools/skill/retrieve/tool.ts
+var skillRetrieve = createTool(skillRetrieveSchema, async (params) => {
+  return {
+    name: params.name,
+    content: readSkill(params.name)
+  };
+});
+
+// src/tools/skill/install/schema.ts
+import { z as z14 } from "zod";
+var skillInstallSchema = defineToolSchema({
+  name: "skill_install",
+  description: "Install AI skills for Claude Code. Defaults to ~/.claude/skills/, or specify --dir for a custom location (e.g. project-local, ~/.agents/skills).",
+  input: z14.object({
+    force: z14.boolean().describe("Overwrite existing skills"),
+    dir: z14.string().nullable().describe(
+      "Target directory to install skills into (default: ~/.claude/skills/)"
+    )
+  }),
+  output: z14.array(
+    z14.object({
+      name: z14.string(),
+      installed: z14.boolean()
+    })
+  )
+});
+
+// src/tools/skill/install/tool.ts
+var skillInstall = createTool(skillInstallSchema, async (params) => {
+  return installSkills(params.force, params.dir ?? void 0);
+});
+
 // src/tools/token/swap/tool.ts
 import { encodeFunctionData } from "viem";
 
 // src/tools/token/swap/schema.ts
-import { z as z10 } from "zod";
-var swapOutputSchema = z10.object({
-  signature: z10.string().describe("Transaction hash/signature"),
-  message: z10.string().describe("Human-readable swap description")
+import { z as z15 } from "zod";
+var swapOutputSchema = z15.object({
+  signature: z15.string().describe("Transaction hash/signature"),
+  message: z15.string().describe("Human-readable swap description")
 });
 var tokenSwapSchema = defineToolSchema({
   name: "token_swap",
   description: "Swap tokens on the same chain. Builds, signs locally, broadcasts, and registers.",
-  input: z10.object({
-    wallet: z10.string().describe("Local wallet name to sign with"),
+  input: z15.object({
+    wallet: z15.string().describe("Local wallet name to sign with"),
     chain: chainSchema.describe("Chain to swap on"),
-    from: z10.object({
-      token: z10.string().describe("Input token address (selling)"),
-      amount: z10.coerce.number().nullable().describe("Amount to sell (exact-in). Null for exact-out.")
+    from: z15.object({
+      token: z15.string().describe("Input token address (selling)"),
+      amount: z15.coerce.number().nullable().describe("Amount to sell (exact-in). Null for exact-out.")
     }),
-    to: z10.object({
-      token: z10.string().describe("Output token address (buying)"),
-      amount: z10.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
+    to: z15.object({
+      token: z15.string().describe("Output token address (buying)"),
+      amount: z15.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
     })
   }),
   output: swapOutputSchema
@@ -6653,18 +6827,18 @@ var tokenSwapSchema = defineToolSchema({
 var tokenBridgeSchema = defineToolSchema({
   name: "token_bridge",
   description: "Bridge tokens across chains. Builds, signs locally, broadcasts, and registers.",
-  input: z10.object({
-    from: z10.object({
-      wallet: z10.string().describe("Local wallet name to sign with"),
+  input: z15.object({
+    from: z15.object({
+      wallet: z15.string().describe("Local wallet name to sign with"),
       chain: chainSchema.describe("Source chain"),
-      token: z10.string().describe("Source token address"),
-      amount: z10.coerce.number().nullable().describe("Amount to send (exact-in). Null for exact-out.")
+      token: z15.string().describe("Source token address"),
+      amount: z15.coerce.number().nullable().describe("Amount to send (exact-in). Null for exact-out.")
     }),
-    to: z10.object({
-      wallet: z10.string().nullable().describe("Destination wallet name or address (defaults to from wallet)"),
+    to: z15.object({
+      wallet: z15.string().nullable().describe("Destination wallet name or address (defaults to from wallet)"),
       chain: chainSchema.describe("Destination chain"),
-      token: z10.string().describe("Destination token address"),
-      amount: z10.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
+      token: z15.string().describe("Destination token address"),
+      amount: z15.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
     })
   }),
   output: swapOutputSchema
@@ -6769,6 +6943,62 @@ var tokenSwap = createTool(tokenSwapSchema, async (params) => {
   });
 });
 
+// src/tools/token/transfer/schema.ts
+import { z as z16 } from "zod";
+var tokenTransferSchema = defineToolSchema({
+  name: "token_transfer",
+  description: "Transfer tokens to another wallet on the same chain. Builds, signs locally, and broadcasts.",
+  input: z16.object({
+    wallet: z16.string().describe("Local wallet name to sign with"),
+    chain: chainSchema.describe("Chain to transfer on"),
+    token: z16.string().describe("Token address to transfer"),
+    amount: z16.coerce.number().describe("Amount to transfer"),
+    to: z16.string().describe("Recipient wallet name or address")
+  }),
+  output: z16.object({
+    signature: z16.string().describe("Transaction hash/signature"),
+    message: z16.string().describe("Human-readable transfer description")
+  })
+});
+
+// src/tools/token/transfer/tool.ts
+var tokenTransfer = createTool(tokenTransferSchema, async (params) => {
+  const baseUrl = resolveBaseUrl();
+  const wallet = await walletRetrieve.handler({ wallet: params.wallet });
+  const fromAddress = wallet.addresses[KEY_CHAIN_MAP[params.chain]];
+  if (!fromAddress) {
+    throw new Error(`Wallet "${wallet.name}" has no address on ${params.chain}.`);
+  }
+  let toAddress = params.to;
+  try {
+    const toWallet = await walletRetrieve.handler({ wallet: params.to });
+    toAddress = toWallet.addresses[KEY_CHAIN_MAP[params.chain]] ?? params.to;
+  } catch {
+  }
+  const buildResult = await callRemoteTool(baseUrl, "token_transfer", {
+    wallet: fromAddress,
+    token: params.token,
+    to: toAddress,
+    amount: params.amount,
+    chain: params.chain
+  });
+  const txPayload = "base64" in buildResult.transaction ? buildResult.transaction.base64 : JSON.stringify(buildResult.transaction);
+  const { transaction: signedTransaction } = await transactionSign.handler({
+    wallet: wallet.name,
+    chain: params.chain,
+    transaction: txPayload
+  });
+  const sendResult = await callRemoteTool(baseUrl, "transaction_send", {
+    transaction: signedTransaction,
+    message: buildResult.message,
+    chain: params.chain
+  });
+  if (!sendResult.signature) {
+    throw new Error(`Transaction send failed: ${sendResult.message}`);
+  }
+  return { signature: sendResult.signature, message: buildResult.message };
+});
+
 // src/tools/x402/request/tool.ts
 import { Keypair as Keypair4, VersionedTransaction as VersionedTransaction2, VersionedMessage } from "@solana/web3.js";
 import axios from "axios";
@@ -6782,13 +7012,13 @@ import { createPublicClient as createPublicClient2, http as http2 } from "viem";
 import * as viemChains2 from "viem/chains";
 
 // src/tools/x402/request/schema.ts
-import { z as z11 } from "zod";
+import { z as z17 } from "zod";
 var x402RequestSchema = defineToolSchema({
   name: "x402_request",
   description: "Make an HTTP request to an x402-protected endpoint. Automatically handles payment when a 402 Payment Required response is received, signing the payment transaction with the local wallet.",
-  input: z11.object({
-    method: z11.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method"),
-    url: z11.string().url().refine((u) => u.startsWith("https://"), { message: "URL must use HTTPS" }).refine(
+  input: z17.object({
+    method: z17.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method"),
+    url: z17.string().url().refine((u) => u.startsWith("https://"), { message: "URL must use HTTPS" }).refine(
       (u) => {
         try {
           const host = new URL(u).hostname;
@@ -6801,15 +7031,15 @@ var x402RequestSchema = defineToolSchema({
     ).describe(
       "Full HTTPS URL of the x402-protected endpoint (e.g., 'https://agents.moonpay.com/api/x402/tools/market_digest_retrieve')"
     ),
-    body: z11.record(z11.any()).nullable().describe("Request body (for POST, PUT, PATCH)"),
-    params: z11.record(z11.any()).nullable().describe("Query parameters"),
-    wallet: z11.string().describe("Wallet name or address to pay with"),
-    chain: z11.enum(["solana", "base", "ethereum", "arbitrum", "polygon", "optimism"]).nullable().describe("Chain to pay from (default: solana). Use an EVM chain like 'base' to pay with an EVM wallet.")
+    body: z17.record(z17.any()).nullable().describe("Request body (for POST, PUT, PATCH)"),
+    params: z17.record(z17.any()).nullable().describe("Query parameters"),
+    wallet: z17.string().describe("Wallet name or address to pay with"),
+    chain: z17.enum(["solana", "base", "ethereum", "arbitrum", "polygon", "optimism"]).nullable().describe("Chain to pay from (default: solana). Use an EVM chain like 'base' to pay with an EVM wallet.")
   }),
-  output: z11.object({
-    status: z11.number().describe("HTTP status code"),
-    data: z11.any().describe("Response data"),
-    headers: z11.record(z11.any()).describe("Response headers")
+  output: z17.object({
+    status: z17.number().describe("HTTP status code"),
+    data: z17.any().describe("Response data"),
+    headers: z17.record(z17.any()).describe("Response headers")
   })
 });
 
@@ -6901,18 +7131,18 @@ var x402Request = createTool(
 );
 
 // src/tools/virtual-account/wallet/register/schema.ts
-import { z as z12 } from "zod";
+import { z as z18 } from "zod";
 var virtualAccountWalletRegisterSchema = defineToolSchema({
   name: "virtual-account_wallet_register",
   description: "Register a local wallet with your virtual account. Creates the verification message, signs it locally, and registers in one step.",
-  input: z12.object({
-    wallet: z12.string().describe("Local wallet name"),
+  input: z18.object({
+    wallet: z18.string().describe("Local wallet name"),
     chain: chainSchema.describe("Chain to register (solana, ethereum, etc.)")
   }),
-  output: z12.object({
-    success: z12.literal(true),
-    address: z12.string().describe("Registered wallet address"),
-    chain: z12.string().describe("Chain registered on")
+  output: z18.object({
+    success: z18.literal(true),
+    address: z18.string().describe("Registered wallet address"),
+    chain: z18.string().describe("Chain registered on")
   })
 });
 
@@ -6948,29 +7178,177 @@ var virtualAccountWalletRegister = createTool(
   }
 );
 
-export {
-  getConfigOrDefault,
-  saveCredentials,
-  clearCredentials,
-  resolveBaseUrl,
-  callPublicTool,
-  callTool,
-  callRemoteTool,
-  schemas_default,
-  defineToolSchema,
-  createTool,
+// src/tools/consent/accept/tool.ts
+import * as fs3 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+
+// src/tools/consent/accept/schema.ts
+import { z as z19 } from "zod";
+var consentAcceptSchema = defineToolSchema({
+  name: "consent_accept",
+  description: "Accept the MoonPay Terms of Service and Privacy Policy. Required before using any CLI command.",
+  input: z19.object({}),
+  output: z19.object({
+    tosVersion: z19.string(),
+    acceptedAt: z19.string()
+  })
+});
+
+// src/tools/consent/accept/tool.ts
+var CONFIG_DIR2 = path3.join(os3.homedir(), ".config", "moonpay");
+var CONSENT_PATH2 = path3.join(CONFIG_DIR2, "consent.json");
+var CURRENT_TOS_VERSION2 = "1.0";
+var consentAccept = createTool(consentAcceptSchema, async () => {
+  if (!fs3.existsSync(CONFIG_DIR2)) {
+    fs3.mkdirSync(CONFIG_DIR2, { recursive: true, mode: 448 });
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const consent = { tosVersion: CURRENT_TOS_VERSION2, acceptedAt: now };
+  const tmp = CONSENT_PATH2 + `.tmp.${process.pid}`;
+  fs3.writeFileSync(tmp, JSON.stringify(consent, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+  fs3.renameSync(tmp, CONSENT_PATH2);
+  return consent;
+});
+
+// src/tools/login/schema.ts
+import { z as z20 } from "zod";
+var loginSchema = defineToolSchema({
+  name: "login",
+  description: "Send a login verification code to your email.",
+  input: z20.object({
+    email: z20.string().describe("Email address")
+  }),
+  output: z20.object({
+    email: z20.string(),
+    message: z20.string()
+  })
+});
+
+// src/tools/login/tool.ts
+var login = createTool(loginSchema, async (params) => {
+  const { baseUrl } = getConfigOrDefault();
+  await callPublicTool(baseUrl, "login", { email: params.email });
+  return {
+    email: params.email,
+    message: `Verification code sent to ${params.email}. Run: mp verify --email ${params.email} --code <code>`
+  };
+});
+
+// src/tools/verify/schema.ts
+import { z as z21 } from "zod";
+var verifySchema = defineToolSchema({
+  name: "verify",
+  description: "Verify login code and store encrypted credentials.",
+  input: z21.object({
+    email: z21.string().describe("Email address"),
+    code: z21.string().describe("Verification code")
+  }),
+  output: z21.object({
+    email: z21.string(),
+    message: z21.string()
+  })
+});
+
+// src/tools/verify/tool.ts
+var verify = createTool(verifySchema, async (params) => {
+  const { baseUrl } = getConfigOrDefault();
+  const tokens = await callPublicTool(baseUrl, "verify", {
+    email: params.email,
+    code: params.code
+  });
+  const creds = {
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    expiresAt: tokens.expiresAt * 1e3,
+    baseUrl
+  };
+  saveCredentials(creds);
+  return { email: params.email, message: "Logged in successfully." };
+});
+
+// src/tools/logout/schema.ts
+import { z as z22 } from "zod";
+var logoutSchema = defineToolSchema({
+  name: "logout",
+  description: "Log out and clear stored credentials.",
+  input: z22.object({}),
+  output: z22.object({
+    success: z22.literal(true),
+    message: z22.string()
+  })
+});
+
+// src/tools/logout/tool.ts
+var logout = createTool(logoutSchema, async () => {
+  clearCredentials();
+  return { success: true, message: "Logged out." };
+});
+
+// src/tools/qr/tool.ts
+import { createRequire } from "module";
+
+// src/tools/qr/schema.ts
+import { z as z23 } from "zod";
+var qrGenerateSchema = defineToolSchema({
+  name: "qr_generate",
+  description: "Display a QR code in the terminal. Pass any text \u2014 wallet address, URL, token address, etc.",
+  input: z23.object({
+    value: z23.string().describe("Text to encode as a QR code")
+  }),
+  output: z23.object({
+    value: z23.string()
+  })
+});
+
+// src/tools/qr/tool.ts
+var require2 = createRequire(import.meta.url);
+var qrcode = require2("qrcode-terminal");
+var qrGenerate = createTool(qrGenerateSchema, async (params) => {
+  qrcode.generate(params.value, { small: true }, (code) => {
+    process.stderr.write(`
+${code}
+`);
+  });
+  return { value: params.value };
+});
+
+// src/local-tools.ts
+var LOCAL_TOOLS = [
   walletCreate,
   walletImport,
   walletList,
   walletRetrieve,
   walletDelete,
   walletRename,
+  walletExport,
   transactionSign,
   messageSign,
   bitcoinBalanceRetrieve,
-  tokenBridge,
+  skillList,
+  skillRetrieve,
+  skillInstall,
   tokenSwap,
+  tokenBridge,
+  tokenTransfer,
   x402Request,
-  virtualAccountWalletRegister
+  virtualAccountWalletRegister,
+  consentAccept,
+  consentCheck,
+  login,
+  verify,
+  logout,
+  qrGenerate
+];
+
+export {
+  resolveBaseUrl,
+  callTool,
+  schemas_default,
+  consentCheck,
+  LOCAL_TOOLS
 };
-//# sourceMappingURL=chunk-ZWMKESOK.js.map
+//# sourceMappingURL=chunk-6TW2YUWK.js.map