@moonpay/cli 0.6.10 → 0.6.11

package/dist/{chunk-TIV6G4KD.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";
@@ -6002,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: [
@@ -6100,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;
@@ -6117,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);
@@ -6157,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) };
 });
 
@@ -6181,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
   })
 });
@@ -6252,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
@@ -6272,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
 });
@@ -6294,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)
   })
 });
 
@@ -6321,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()
   })
 });
 
@@ -6354,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";
@@ -6364,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")
   })
 });
 
@@ -6491,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"
     )
   })
@@ -6563,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")
     })
   })
 });
@@ -6617,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) {
@@ -6642,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
@@ -6671,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
@@ -6787,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";
@@ -6800,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;
@@ -6819,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")
   })
 });
 
@@ -6919,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")
   })
 });
 
@@ -6966,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-TIV6G4KD.js.map
+//# sourceMappingURL=chunk-6TW2YUWK.js.map