@moonpay/cli 0.6.13 → 0.6.15

package/dist/{chunk-AFUYZK7C.js → chunk-7KJP7F5Q.js}

@@ -236,7 +236,8 @@ async function callTool(baseUrl, toolName, params) {
     }
   }
   if (res.status === 429) {
-    throw new Error("Rate limit exceeded. Please wait a moment and try again.");
+    const hint = token ? "" : " Log in with `mp login` for higher limits.";
+    throw new Error(`Rate limit exceeded. Please wait a moment and try again.${hint}`);
   }
   if (res.status === 401) {
     throw new Error("This command requires a MoonPay CLI account. Run `moonpay login` first.");
@@ -611,9 +612,68 @@ var schemas_default = [
       $schema: "http://json-schema.org/draft-07/schema#"
     }
   },
+  {
+    name: "feedback_create",
+    description: "Submit feedback, a bug report, or a feature request. Requires authentication.",
+    inputSchema: {
+      $ref: "#/definitions/feedback_create_input",
+      definitions: {
+        feedback_create_input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: [
+                "bug",
+                "feature",
+                "general"
+              ],
+              description: "Type of feedback: bug report, feature request, or general"
+            },
+            message: {
+              type: "string",
+              minLength: 1,
+              maxLength: 280,
+              description: "Your feedback message"
+            }
+          },
+          required: [
+            "type",
+            "message"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    outputSchema: {
+      $ref: "#/definitions/feedback_create_output",
+      definitions: {
+        feedback_create_output: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Feedback ID"
+            },
+            message: {
+              type: "string",
+              description: "Confirmation message"
+            }
+          },
+          required: [
+            "id",
+            "message"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
   {
     name: "login",
-    description: "Send a verification code to the provided email to sign in or create an account.",
+    description: "Send a verification code to the provided email to sign in or create an account. Requires an hCaptcha token.",
     inputSchema: {
       $ref: "#/definitions/login_input",
       definitions: {
@@ -624,10 +684,15 @@ var schemas_default = [
               type: "string",
               format: "email",
               description: "The email of the user to login"
+            },
+            captchaToken: {
+              type: "string",
+              description: "hCaptcha response token"
             }
           },
           required: [
-            "email"
+            "email",
+            "captchaToken"
           ],
           additionalProperties: false
         }
@@ -6547,6 +6612,7 @@ var walletCreate = createTool(walletCreateSchema, async (params) => {
 });
 
 // src/tools/wallet/import/tool.ts
+import { createInterface } from "readline";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist as english2 } from "@scure/bip39/wordlists/english";
 import { Keypair } from "@solana/web3.js";
@@ -6572,12 +6638,64 @@ var walletImportSchema = defineToolSchema({
 });
 
 // src/tools/wallet/import/tool.ts
+function readSecret(prompt) {
+  return new Promise((resolve, reject) => {
+    if (!process.stdin.isTTY) {
+      reject(new Error("Interactive import requires a terminal. Pass --mnemonic or --key instead."));
+      return;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    process.stderr.write(prompt);
+    process.stdin.setRawMode(true);
+    let input = "";
+    const onData = (ch) => {
+      const c = ch.toString();
+      if (c === "\n" || c === "\r") {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener("data", onData);
+        process.stderr.write("\n");
+        rl.close();
+        resolve(input.trim());
+      } else if (c === "") {
+        process.stdin.setRawMode(false);
+        rl.close();
+        process.exit(0);
+      } else if (c === "\x7F" || c === "\b") {
+        input = input.slice(0, -1);
+      } else {
+        input += c;
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function detectSecretType(secret) {
+  const words = secret.split(/\s+/);
+  if (words.length >= 12 && words.length <= 24 && validateMnemonic(secret, english2)) {
+    return "mnemonic";
+  }
+  return "key";
+}
 var walletImport = createTool(walletImportSchema, async (params) => {
   if (params.mnemonic && params.key) {
     throw new Error("Provide either --mnemonic or --key, not both.");
   }
-  if (params.mnemonic) {
-    const trimmed = params.mnemonic.trim().toLowerCase();
+  let mnemonic = params.mnemonic;
+  let key = params.key;
+  if (!mnemonic && !key) {
+    const secret = await readSecret("Paste your mnemonic or private key (hidden): ");
+    if (!secret) {
+      throw new Error("No input provided.");
+    }
+    const type = detectSecretType(secret);
+    if (type === "mnemonic") {
+      mnemonic = secret;
+    } else {
+      key = secret;
+    }
+  }
+  if (mnemonic) {
+    const trimmed = mnemonic.trim().toLowerCase();
     if (!validateMnemonic(trimmed, english2)) {
       throw new Error("Invalid BIP39 mnemonic.");
     }
@@ -6592,20 +6710,20 @@ var walletImport = createTool(walletImportSchema, async (params) => {
     return { name: params.name, type: "hd", addresses };
   }
   const chain = params.chain ? KEY_CHAIN_MAP[params.chain] : "solana";
-  const key = params.key ?? "";
+  const keyValue = key ?? "";
   let address;
   let cleanKey;
   if (chain === "solana") {
     try {
-      const secretKeyBytes = bs58.decode(key);
+      const secretKeyBytes = bs58.decode(keyValue);
       const keypair = Keypair.fromSecretKey(secretKeyBytes);
       address = keypair.publicKey.toBase58();
-      cleanKey = key;
+      cleanKey = keyValue;
     } catch {
       throw new Error("Invalid Solana private key. Expected base58-encoded secret key.");
     }
   } else if (chain === "ethereum") {
-    cleanKey = key.startsWith("0x") ? key.slice(2) : key;
+    cleanKey = keyValue.startsWith("0x") ? keyValue.slice(2) : keyValue;
     if (!/^[0-9a-fA-F]{64}$/.test(cleanKey)) {
       throw new Error("Invalid EVM private key. Expected 64-character hex string.");
     }
@@ -6685,7 +6803,7 @@ var walletDeleteSchema = defineToolSchema({
 var walletDelete = createTool(walletDeleteSchema, async (params) => {
   if (!params.confirm) {
     throw new Error(
-      "Deletion not confirmed. Pass --confirm to permanently delete this wallet."
+      "Back up your wallet before deleting! Run `mp wallet export " + params.wallet + "` to save your recovery phrase, then re-run with --confirm to permanently delete."
     );
   }
   const wallet = findWalletOrThrow(params.wallet);
@@ -7170,32 +7288,11 @@ var skillInstall = createTool(skillInstallSchema, async (params) => {
   return installSkills(params.force, params.dir ?? void 0);
 });
 
-// src/tools/token/swap/tool.ts
+// src/tools/token/bridge/tool.ts
 import { encodeFunctionData } from "viem";
 
-// src/tools/token/swap/schema.ts
+// src/tools/token/bridge/schema.ts
 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: z15.object({
-    wallet: z15.string().describe("Local wallet name to sign with"),
-    chain: chainSchema.describe("Chain to swap on"),
-    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: 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
-});
 var tokenBridgeSchema = defineToolSchema({
   name: "token_bridge",
   description: "Bridge tokens across chains. Builds, signs locally, broadcasts, and registers.",
@@ -7213,10 +7310,13 @@ var tokenBridgeSchema = defineToolSchema({
       amount: z15.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
     })
   }),
-  output: swapOutputSchema
+  output: z15.object({
+    signature: z15.string().describe("Transaction hash/signature"),
+    message: z15.string().describe("Human-readable bridge description")
+  })
 });
 
-// src/tools/token/swap/tool.ts
+// src/tools/token/bridge/tool.ts
 var ERC20_APPROVE_ABI = [
   {
     name: "approve",
@@ -7281,7 +7381,19 @@ var tokenBridge = createTool(tokenBridgeSchema, async (params) => {
     if (!approvalResult.signature) {
       throw new Error(`Approval failed: ${approvalResult.message}`);
     }
-    buildResult = await callRemoteTool(baseUrl, "swaps_transaction_build", buildParams);
+    process.stderr.write("Waiting for approval confirmation...\n");
+    for (let i = 0; i < 30; i++) {
+      await new Promise((r) => setTimeout(r, 2e3));
+      try {
+        const rebuilt = await callRemoteTool(baseUrl, "swaps_transaction_build", buildParams);
+        if (!rebuilt.requiresApproval) {
+          buildResult = rebuilt;
+          break;
+        }
+      } catch {
+      }
+      if (i === 29) throw new Error("Approval not confirmed after 60 seconds.");
+    }
   }
   const txPayload = "base64" in buildResult.transaction ? buildResult.transaction.base64 : JSON.stringify(buildResult.transaction);
   const { transaction: signedTransaction } = await transactionSign.handler({
@@ -7297,17 +7409,41 @@ var tokenBridge = createTool(tokenBridgeSchema, async (params) => {
   if (!sendResult.signature) {
     throw new Error(`Transaction send failed: ${sendResult.message}`);
   }
-  const signature = sendResult.signature;
   try {
     await callRemoteTool(baseUrl, "transaction_register", {
       transactionId: buildResult.transactionId,
-      transactionHash: signature,
+      transactionHash: sendResult.signature,
       chain: params.from.chain
     });
   } catch {
   }
-  return { signature, message: buildResult.message };
+  return { signature: sendResult.signature, message: buildResult.message };
 });
+
+// src/tools/token/swap/schema.ts
+import { z as z16 } from "zod";
+var tokenSwapSchema = defineToolSchema({
+  name: "token_swap",
+  description: "Swap tokens on the same chain. Builds, signs locally, broadcasts, and registers.",
+  input: z16.object({
+    wallet: z16.string().describe("Local wallet name to sign with"),
+    chain: chainSchema.describe("Chain to swap on"),
+    from: z16.object({
+      token: z16.string().describe("Input token address (selling)"),
+      amount: z16.coerce.number().nullable().describe("Amount to sell (exact-in). Null for exact-out.")
+    }),
+    to: z16.object({
+      token: z16.string().describe("Output token address (buying)"),
+      amount: z16.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
+    })
+  }),
+  output: z16.object({
+    signature: z16.string().describe("Transaction hash/signature"),
+    message: z16.string().describe("Human-readable swap description")
+  })
+});
+
+// src/tools/token/swap/tool.ts
 var tokenSwap = createTool(tokenSwapSchema, async (params) => {
   return tokenBridge.handler({
     from: { wallet: params.wallet, chain: params.chain, token: params.from.token, amount: params.from.amount },
@@ -7316,20 +7452,20 @@ var tokenSwap = createTool(tokenSwapSchema, async (params) => {
 });
 
 // src/tools/token/transfer/schema.ts
-import { z as z16 } from "zod";
+import { z as z17 } 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"),
+  input: z17.object({
+    wallet: z17.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")
+    token: z17.string().describe("Token address to transfer"),
+    amount: z17.coerce.number().describe("Amount to transfer"),
+    to: z17.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")
+  output: z17.object({
+    signature: z17.string().describe("Transaction hash/signature"),
+    message: z17.string().describe("Human-readable transfer description")
   })
 });
 
@@ -7384,13 +7520,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 z17 } from "zod";
+import { z as z18 } 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: 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(
+  input: z18.object({
+    method: z18.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method"),
+    url: z18.string().url().refine((u) => u.startsWith("https://"), { message: "URL must use HTTPS" }).refine(
       (u) => {
         try {
           const host = new URL(u).hostname;
@@ -7403,15 +7539,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: 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.")
+    body: z18.record(z18.any()).nullable().describe("Request body (for POST, PUT, PATCH)"),
+    params: z18.record(z18.any()).nullable().describe("Query parameters"),
+    wallet: z18.string().describe("Wallet name or address to pay with"),
+    chain: z18.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: z17.object({
-    status: z17.number().describe("HTTP status code"),
-    data: z17.any().describe("Response data"),
-    headers: z17.record(z17.any()).describe("Response headers")
+  output: z18.object({
+    status: z18.number().describe("HTTP status code"),
+    data: z18.any().describe("Response data"),
+    headers: z18.record(z18.any()).describe("Response headers")
   })
 });
 
@@ -7503,18 +7639,18 @@ var x402Request = createTool(
 );
 
 // src/tools/virtual-account/wallet/register/schema.ts
-import { z as z18 } from "zod";
+import { z as z19 } 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: z18.object({
-    wallet: z18.string().describe("Local wallet name"),
+  input: z19.object({
+    wallet: z19.string().describe("Local wallet name"),
     chain: chainSchema.describe("Chain to register (solana, ethereum, etc.)")
   }),
-  output: z18.object({
-    success: z18.literal(true),
-    address: z18.string().describe("Registered wallet address"),
-    chain: z18.string().describe("Chain registered on")
+  output: z19.object({
+    success: z19.literal(true),
+    address: z19.string().describe("Registered wallet address"),
+    chain: z19.string().describe("Chain registered on")
   })
 });
 
@@ -7556,14 +7692,14 @@ import * as os3 from "os";
 import * as path3 from "path";
 
 // src/tools/consent/accept/schema.ts
-import { z as z19 } from "zod";
+import { z as z20 } 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()
+  input: z20.object({}),
+  output: z20.object({
+    tosVersion: z20.string(),
+    acceptedAt: z20.string()
   })
 });
 
@@ -7587,41 +7723,45 @@ var consentAccept = createTool(consentAcceptSchema, async () => {
 });
 
 // src/tools/login/schema.ts
-import { z as z20 } from "zod";
+import { z as z21 } 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")
+  input: z21.object({
+    email: z21.string().describe("Email address")
   }),
-  output: z20.object({
-    email: z20.string(),
-    message: z20.string()
+  output: z21.object({
+    email: z21.string(),
+    message: z21.string()
   })
 });
 
 // src/tools/login/tool.ts
 var login = createTool(loginSchema, async (params) => {
   const { baseUrl } = getConfigOrDefault();
-  await callPublicTool(baseUrl, "login", { email: params.email });
+  const url = `${baseUrl}/login?email=${encodeURIComponent(params.email)}`;
   return {
     email: params.email,
-    message: `Verification code sent to ${params.email}. Run: mp verify --email ${params.email} --code <code>`
+    message: `Open this link to verify:
+
+  ${url}
+
+Then run: mp verify --email ${params.email} --code <code>`
   };
 });
 
 // src/tools/verify/schema.ts
-import { z as z21 } from "zod";
+import { z as z22 } 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")
+  input: z22.object({
+    email: z22.string().describe("Email address"),
+    code: z22.string().describe("Verification code")
   }),
-  output: z21.object({
-    email: z21.string(),
-    message: z21.string()
+  output: z22.object({
+    email: z22.string(),
+    message: z22.string()
   })
 });
 
@@ -7643,14 +7783,14 @@ var verify = createTool(verifySchema, async (params) => {
 });
 
 // src/tools/logout/schema.ts
-import { z as z22 } from "zod";
+import { z as z23 } 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()
+  input: z23.object({}),
+  output: z23.object({
+    success: z23.literal(true),
+    message: z23.string()
   })
 });
 
@@ -7664,15 +7804,15 @@ var logout = createTool(logoutSchema, async () => {
 import { createRequire } from "module";
 
 // src/tools/qr/schema.ts
-import { z as z23 } from "zod";
+import { z as z24 } 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")
+  input: z24.object({
+    value: z24.string().describe("Text to encode as a QR code")
   }),
-  output: z23.object({
-    value: z23.string()
+  output: z24.object({
+    value: z24.string()
   })
 });
 
@@ -7723,4 +7863,4 @@ export {
   consentCheck,
   LOCAL_TOOLS
 };
-//# sourceMappingURL=chunk-AFUYZK7C.js.map
+//# sourceMappingURL=chunk-7KJP7F5Q.js.map