@moonpay/cli 0.6.2 → 0.6.5

package/dist/{chunk-P764SORF.js → chunk-JQEHP3SV.js}

@@ -14,6 +14,7 @@ import {
   getEncryptionKey,
   keyChainSchema,
   loadWallets,
+  mutateWallets,
   removeWallet,
   resolveSigningKey,
   walletInfoSchema
@@ -329,6 +330,283 @@ var schemas_default = [
       $schema: "http://json-schema.org/draft-07/schema#"
     }
   },
+  {
+    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.",
+    inputSchema: {
+      $ref: "#/definitions/deposit_create_input",
+      definitions: {
+        deposit_create_input: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Human-readable label for this deposit link (e.g. 'Treasury Base USDC')"
+            },
+            wallet: {
+              type: "string",
+              description: "Destination wallet address where USDC will be delivered"
+            },
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "bnb"
+              ],
+              description: "Blockchain of the destination wallet (determines which USDC the wallet receives)"
+            }
+          },
+          required: [
+            "name",
+            "wallet",
+            "chain"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    outputSchema: {
+      $ref: "#/definitions/deposit_create_output",
+      definitions: {
+        deposit_create_output: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Unique deposit ID \u2014 use with deposit_transaction_list to check incoming payments"
+            },
+            destinationWallet: {
+              type: "string",
+              description: "Wallet address that will receive USDC"
+            },
+            destinationChain: {
+              type: "string",
+              description: "Chain where USDC will be delivered"
+            },
+            depositUrl: {
+              type: "string",
+              description: "Shareable URL \u2014 open in browser or share with senders to deposit funds"
+            },
+            wallets: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  address: {
+                    type: "string",
+                    description: "Address to send funds to"
+                  },
+                  chain: {
+                    type: "string",
+                    description: "Chain this address is on (solana, ethereum, bitcoin, tron)"
+                  }
+                },
+                required: [
+                  "address",
+                  "chain"
+                ],
+                additionalProperties: false
+              },
+              description: "Deposit addresses across all supported chains \u2014 send any token to any of these"
+            }
+          },
+          required: [
+            "id",
+            "destinationWallet",
+            "destinationChain",
+            "depositUrl",
+            "wallets"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "deposit_list",
+    description: "List all deposit links belonging to the current user. Each deposit link has multi-chain addresses that auto-convert incoming crypto to USDC.",
+    inputSchema: {
+      $ref: "#/definitions/deposit_list_input",
+      definitions: {
+        deposit_list_input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    outputSchema: {
+      $ref: "#/definitions/deposit_list_output",
+      definitions: {
+        deposit_list_output: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string",
+                    description: "Deposit ID \u2014 use with deposit_transaction_list to check payments"
+                  },
+                  name: {
+                    type: "string",
+                    description: "Human-readable label"
+                  },
+                  depositUrl: {
+                    type: "string",
+                    description: "Shareable deposit URL"
+                  },
+                  wallets: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        address: {
+                          type: "string",
+                          description: "Address to send funds to"
+                        },
+                        chain: {
+                          type: "string",
+                          description: "Chain this address is on"
+                        }
+                      },
+                      required: [
+                        "address",
+                        "chain"
+                      ],
+                      additionalProperties: false
+                    },
+                    description: "Multi-chain deposit addresses"
+                  },
+                  createdAt: {
+                    type: "string",
+                    description: "When this deposit link was created"
+                  }
+                },
+                required: [
+                  "id",
+                  "name",
+                  "depositUrl",
+                  "wallets",
+                  "createdAt"
+                ],
+                additionalProperties: false
+              }
+            }
+          },
+          required: [
+            "items"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "deposit_transaction_list",
+    description: "List incoming transactions for a deposit link. Shows each payment received \u2014 amount, token, sender, and whether it has settled to USDC.",
+    inputSchema: {
+      $ref: "#/definitions/deposit_transaction_list_input",
+      definitions: {
+        deposit_transaction_list_input: {
+          type: "object",
+          properties: {
+            depositId: {
+              type: "string",
+              description: "Deposit ID from deposit_create or deposit_list"
+            }
+          },
+          required: [
+            "depositId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    outputSchema: {
+      $ref: "#/definitions/deposit_transaction_list_output",
+      definitions: {
+        deposit_transaction_list_output: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string",
+                    description: "Transaction ID"
+                  },
+                  amount: {
+                    type: "number",
+                    description: "Amount received"
+                  },
+                  token: {
+                    type: "string",
+                    description: "Token symbol received (e.g. SOL, ETH, USDC)"
+                  },
+                  from: {
+                    type: "string",
+                    description: "Sender's wallet address"
+                  },
+                  status: {
+                    type: "string",
+                    description: "Transaction status (SUCCESS, PENDING, FAILED)"
+                  },
+                  settledAmount: {
+                    type: [
+                      "number",
+                      "null"
+                    ],
+                    description: "Amount settled in USDC (null if not yet settled)"
+                  },
+                  settledCurrency: {
+                    type: [
+                      "string",
+                      "null"
+                    ],
+                    description: "Settlement currency (usually USDC)"
+                  },
+                  timestamp: {
+                    type: "string",
+                    description: "When the transaction was received"
+                  }
+                },
+                required: [
+                  "id",
+                  "amount",
+                  "token",
+                  "from",
+                  "status",
+                  "settledAmount",
+                  "settledCurrency",
+                  "timestamp"
+                ],
+                additionalProperties: false
+              }
+            }
+          },
+          required: [
+            "items"
+          ],
+          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.",
@@ -6045,6 +6323,40 @@ var walletDelete = createTool(walletDeleteSchema, async (params) => {
   return { name: wallet.name, deleted: true };
 });
 
+// src/tools/wallet/rename/schema.ts
+import { z as z6 } 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")
+  }),
+  output: z6.object({
+    oldName: z6.string(),
+    newName: z6.string()
+  })
+});
+
+// src/tools/wallet/rename/tool.ts
+var walletRename = createTool(walletRenameSchema, async (params) => {
+  const wallet = findWalletOrThrow(params.wallet);
+  const oldName = wallet.name;
+  if (oldName === params.name) {
+    throw new Error(`Wallet is already named "${params.name}"`);
+  }
+  const existing = loadWallets();
+  if (existing.some((w) => w.name === params.name)) {
+    throw new Error(`Wallet "${params.name}" already exists`);
+  }
+  mutateWallets((wallets) => {
+    const w = wallets.find((w2) => w2.name === oldName);
+    if (!w) throw new Error(`Wallet "${oldName}" not found`);
+    w.name = params.name;
+  });
+  return { oldName, newName: params.name };
+});
+
 // src/tools/transaction/sign/tool.ts
 import { createHash } from "crypto";
 import { Keypair as Keypair2, VersionedTransaction } from "@solana/web3.js";
@@ -6055,19 +6367,19 @@ import * as viemChains from "viem/chains";
 import * as ecc from "tiny-secp256k1";
 
 // src/tools/transaction/sign/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } 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: z6.object({
-    wallet: z6.string().describe("Wallet name or address"),
+  input: z7.object({
+    wallet: z7.string().describe("Wallet name or address"),
     chain: chainSchema.describe(
       "Chain: solana, ethereum, base, arbitrum, or bitcoin"
     ),
-    transaction: z6.string().describe("Base64-encoded unsigned transaction")
+    transaction: z7.string().describe("Base64-encoded unsigned transaction")
   }),
-  output: z6.object({
-    transaction: z6.string().describe("Base64-encoded signed transaction")
+  output: z7.object({
+    transaction: z7.string().describe("Base64-encoded signed transaction")
   })
 });
 
@@ -6182,19 +6494,19 @@ import { keccak_256 } from "@noble/hashes/sha3";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 
 // src/tools/message/sign/schema.ts
-import { z as z7 } from "zod";
+import { z as z8 } 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: z7.object({
-    wallet: z7.string().describe("Wallet address or name to sign with"),
+  input: z8.object({
+    wallet: z8.string().describe("Wallet address or name to sign with"),
     chain: chainSchema.describe(
       "Chain: solana, ethereum, base, arbitrum, or bitcoin"
     ),
-    message: z7.string().describe("Message text to sign")
+    message: z8.string().describe("Message text to sign")
   }),
-  output: z7.object({
-    signature: z7.string().describe(
+  output: z8.object({
+    signature: z8.string().describe(
       "Signature: base58 for Solana, hex (0x-prefixed) for EVM/Bitcoin"
     )
   })
@@ -6254,26 +6566,26 @@ function signBitcoin2(privateKey, messageBytes) {
 import https from "https";
 
 // src/tools/bitcoin/balance/schema.ts
-import { z as z8 } from "zod";
+import { z as z9 } 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: z8.object({
-    wallet: z8.string().describe("Bitcoin address (bc1...) or wallet name")
+  input: z9.object({
+    wallet: z9.string().describe("Bitcoin address (bc1...) or wallet name")
   }),
-  output: z8.object({
-    address: z8.string().describe("Bitcoin address"),
-    confirmed: z8.object({
-      btc: z8.string().describe("Confirmed balance in BTC"),
-      sats: z8.number().describe("Confirmed balance in satoshis")
+  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")
     }),
-    unconfirmed: z8.object({
-      btc: z8.string().describe("Unconfirmed (pending) balance in BTC"),
-      sats: z8.number().describe("Unconfirmed (pending) balance in satoshis")
+    unconfirmed: z9.object({
+      btc: z9.string().describe("Unconfirmed (pending) balance in BTC"),
+      sats: z9.number().describe("Unconfirmed (pending) balance in satoshis")
     }),
-    total: z8.object({
-      btc: z8.string().describe("Total balance in BTC"),
-      sats: z8.number().describe("Total balance in satoshis")
+    total: z9.object({
+      btc: z9.string().describe("Total balance in BTC"),
+      sats: z9.number().describe("Total balance in satoshis")
     })
   })
 });
@@ -6337,24 +6649,24 @@ var bitcoinBalanceRetrieve = createTool(
 import { encodeFunctionData } from "viem";
 
 // src/tools/token/swap/schema.ts
-import { z as z9 } from "zod";
-var swapOutputSchema = z9.object({
-  signature: z9.string().describe("Transaction hash/signature"),
-  message: z9.string().describe("Human-readable swap description")
+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")
 });
 var tokenSwapSchema = defineToolSchema({
   name: "token_swap",
   description: "Swap tokens on the same chain. Builds, signs locally, broadcasts, and registers.",
-  input: z9.object({
-    wallet: z9.string().describe("Local wallet name to sign with"),
+  input: z10.object({
+    wallet: z10.string().describe("Local wallet name to sign with"),
     chain: chainSchema.describe("Chain to swap on"),
-    from: z9.object({
-      token: z9.string().describe("Input token address (selling)"),
-      amount: z9.coerce.number().nullable().describe("Amount to sell (exact-in). Null for exact-out.")
+    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.")
     }),
-    to: z9.object({
-      token: z9.string().describe("Output token address (buying)"),
-      amount: z9.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
+    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.")
     })
   }),
   output: swapOutputSchema
@@ -6362,18 +6674,18 @@ var tokenSwapSchema = defineToolSchema({
 var tokenBridgeSchema = defineToolSchema({
   name: "token_bridge",
   description: "Bridge tokens across chains. Builds, signs locally, broadcasts, and registers.",
-  input: z9.object({
-    from: z9.object({
-      wallet: z9.string().describe("Local wallet name to sign with"),
+  input: z10.object({
+    from: z10.object({
+      wallet: z10.string().describe("Local wallet name to sign with"),
       chain: chainSchema.describe("Source chain"),
-      token: z9.string().describe("Source token address"),
-      amount: z9.coerce.number().nullable().describe("Amount to send (exact-in). Null for exact-out.")
+      token: z10.string().describe("Source token address"),
+      amount: z10.coerce.number().nullable().describe("Amount to send (exact-in). Null for exact-out.")
     }),
-    to: z9.object({
-      wallet: z9.string().nullable().describe("Destination wallet name or address (defaults to from wallet)"),
+    to: z10.object({
+      wallet: z10.string().nullable().describe("Destination wallet name or address (defaults to from wallet)"),
       chain: chainSchema.describe("Destination chain"),
-      token: z9.string().describe("Destination token address"),
-      amount: z9.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
+      token: z10.string().describe("Destination token address"),
+      amount: z10.coerce.number().nullable().describe("Amount to receive (exact-out). Null for exact-in.")
     })
   }),
   output: swapOutputSchema
@@ -6484,15 +6796,20 @@ import axios from "axios";
 import { wrapAxiosWithPayment } from "@x402/axios";
 import { x402Client } from "@x402/core/client";
 import { ExactSvmScheme } from "@x402/svm";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { toClientEvmSigner } from "@x402/evm";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+import { createPublicClient as createPublicClient2, http as http2 } from "viem";
+import * as viemChains2 from "viem/chains";
 
 // src/tools/x402/request/schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } 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: z10.object({
-    method: z10.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method"),
-    url: z10.string().url().refine((u) => u.startsWith("https://"), { message: "URL must use HTTPS" }).refine(
+  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(
       (u) => {
         try {
           const host = new URL(u).hostname;
@@ -6505,20 +6822,28 @@ 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: z10.record(z10.any()).nullable().describe("Request body (for POST, PUT, PATCH)"),
-    params: z10.record(z10.any()).nullable().describe("Query parameters"),
-    wallet: z10.string().describe("Wallet name or address to pay with")
+    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.")
   }),
-  output: z10.object({
-    status: z10.number().describe("HTTP status code"),
-    data: z10.any().describe("Response data"),
-    headers: z10.record(z10.string()).describe("Response headers")
+  output: z11.object({
+    status: z11.number().describe("HTTP status code"),
+    data: z11.any().describe("Response data"),
+    headers: z11.record(z11.any()).describe("Response headers")
   })
 });
 
 // src/tools/x402/request/tool.ts
 var SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-function createLocalX402Client(walletAddress, secretKey) {
+var CHAIN_TO_VIEM = {
+  ethereum: viemChains2.mainnet,
+  base: viemChains2.base,
+  polygon: viemChains2.polygon,
+  arbitrum: viemChains2.arbitrum,
+  optimism: viemChains2.optimism
+};
+function createSolanaX402Client(walletAddress, secretKey) {
   const keypair = Keypair4.fromSecretKey(secretKey);
   const signer = {
     address: walletAddress,
@@ -6550,28 +6875,40 @@ function createLocalX402Client(walletAddress, secretKey) {
   client.registerV1("solana", svmScheme);
   return wrapAxiosWithPayment(axios.create(), client);
 }
+function createEvmX402Client(privateKey, chain) {
+  const account = privateKeyToAccount4(
+    `0x${Buffer.from(privateKey).toString("hex")}`
+  );
+  const viemChain = CHAIN_TO_VIEM[chain] ?? viemChains2.base;
+  const publicClient = createPublicClient2({ chain: viemChain, transport: http2() });
+  const signer = toClientEvmSigner(account, publicClient);
+  const client = new x402Client();
+  registerExactEvmScheme(client, { signer });
+  return wrapAxiosWithPayment(axios.create(), client);
+}
 var x402Request = createTool(
   x402RequestSchema,
-  async ({ method, url, body, params, wallet: walletNameOrAddress }) => {
+  async ({ method, url, body, params, wallet: walletNameOrAddress, chain }) => {
     const walletMetadata = findWalletOrThrow(walletNameOrAddress);
-    const { privateKey, address } = resolveSigningKey(walletMetadata, "solana");
-    const client = createLocalX402Client(address, privateKey);
+    const resolvedChain = chain ?? "solana";
+    const { privateKey, address } = resolveSigningKey(walletMetadata, resolvedChain);
+    const httpClient = resolvedChain === "solana" ? createSolanaX402Client(address, privateKey) : createEvmX402Client(privateKey, resolvedChain);
     let response;
     switch (method) {
       case "GET":
-        response = await client.get(url, { params });
+        response = await httpClient.get(url, { params });
         break;
       case "POST":
-        response = await client.post(url, body || {}, { params });
+        response = await httpClient.post(url, body || {}, { params });
         break;
       case "PUT":
-        response = await client.put(url, body || {}, { params });
+        response = await httpClient.put(url, body || {}, { params });
         break;
       case "PATCH":
-        response = await client.patch(url, body || {}, { params });
+        response = await httpClient.patch(url, body || {}, { params });
         break;
       case "DELETE":
-        response = await client.delete(url, { params });
+        response = await httpClient.delete(url, { params });
         break;
       default:
         throw new Error(`Unsupported HTTP method: ${method}`);
@@ -6585,18 +6922,18 @@ var x402Request = createTool(
 );
 
 // src/tools/virtual-account/wallet/register/schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } 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: z11.object({
-    wallet: z11.string().describe("Local wallet name"),
+  input: z12.object({
+    wallet: z12.string().describe("Local wallet name"),
     chain: chainSchema.describe("Chain to register (solana, ethereum, etc.)")
   }),
-  output: z11.object({
-    success: z11.literal(true),
-    address: z11.string().describe("Registered wallet address"),
-    chain: z11.string().describe("Chain registered on")
+  output: z12.object({
+    success: z12.literal(true),
+    address: z12.string().describe("Registered wallet address"),
+    chain: z12.string().describe("Chain registered on")
   })
 });
 
@@ -6648,6 +6985,7 @@ export {
   walletList,
   walletRetrieve,
   walletDelete,
+  walletRename,
   transactionSign,
   messageSign,
   bitcoinBalanceRetrieve,
@@ -6656,4 +6994,4 @@ export {
   x402Request,
   virtualAccountWalletRegister
 };
-//# sourceMappingURL=chunk-P764SORF.js.map
+//# sourceMappingURL=chunk-JQEHP3SV.js.map