@moonpay/cli 0.6.14 → 0.6.15

package/dist/{chunk-CTYZ36RZ.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.");
@@ -7287,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.",
@@ -7330,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",
@@ -7398,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({
@@ -7414,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 },
@@ -7433,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")
   })
 });
 
@@ -7501,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;
@@ -7520,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")
   })
 });
 
@@ -7620,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")
   })
 });
 
@@ -7673,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()
   })
 });
 
@@ -7704,16 +7723,16 @@ 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()
   })
 });
 
@@ -7732,17 +7751,17 @@ 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()
   })
 });
 
@@ -7764,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()
   })
 });
 
@@ -7785,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()
   })
 });
 
@@ -7844,4 +7863,4 @@ export {
   consentCheck,
   LOCAL_TOOLS
 };
-//# sourceMappingURL=chunk-CTYZ36RZ.js.map
+//# sourceMappingURL=chunk-7KJP7F5Q.js.map