@moonpay/cli 0.5.0 → 0.5.1

package/dist/{chunk-AH5VMN63.js → chunk-PBRXVTTG.js}

@@ -430,226 +430,6 @@ var schemas_default = [
       $schema: "http://json-schema.org/draft-07/schema#"
     }
   },
-  {
-    name: "solana_balance_check",
-    description: "Check if a wallet has enough SOL. Returns success: true if the wallet has sufficient SOL balance, false otherwise.",
-    inputSchema: {
-      $ref: "#/definitions/solana_balance_check_input",
-      definitions: {
-        solana_balance_check_input: {
-          type: "object",
-          properties: {
-            wallet: {
-              type: "string",
-              description: "Wallet address to check the SOL balance for"
-            },
-            amount: {
-              type: "number",
-              description: "Required amount of SOL to check against"
-            }
-          },
-          required: [
-            "wallet",
-            "amount"
-          ],
-          additionalProperties: false
-        }
-      },
-      $schema: "http://json-schema.org/draft-07/schema#"
-    },
-    outputSchema: {
-      $ref: "#/definitions/solana_balance_check_output",
-      definitions: {
-        solana_balance_check_output: {
-          type: "object",
-          properties: {
-            success: {
-              type: "boolean",
-              description: "Whether the check passed"
-            },
-            message: {
-              type: "string",
-              description: "A message describing the result"
-            }
-          },
-          required: [
-            "success",
-            "message"
-          ],
-          additionalProperties: false
-        }
-      },
-      $schema: "http://json-schema.org/draft-07/schema#"
-    }
-  },
-  {
-    name: "solana_balance_retrieve",
-    description: "Get the balance of SOL in a wallet",
-    inputSchema: {
-      $ref: "#/definitions/solana_balance_retrieve_input",
-      definitions: {
-        solana_balance_retrieve_input: {
-          type: "object",
-          properties: {
-            wallet: {
-              type: "string",
-              description: "Wallet address to get the SOL balance of"
-            }
-          },
-          required: [
-            "wallet"
-          ],
-          additionalProperties: false
-        }
-      },
-      $schema: "http://json-schema.org/draft-07/schema#"
-    },
-    outputSchema: {
-      $ref: "#/definitions/solana_balance_retrieve_output",
-      definitions: {
-        solana_balance_retrieve_output: {
-          type: "object",
-          properties: {
-            address: {
-              type: "string",
-              description: "Address of the token"
-            },
-            name: {
-              type: "string",
-              description: "Name of the token"
-            },
-            symbol: {
-              type: "string",
-              description: "Symbol of the token"
-            },
-            image: {
-              type: [
-                "string",
-                "null"
-              ],
-              description: "Image of the token"
-            },
-            description: {
-              type: [
-                "string",
-                "null"
-              ],
-              description: "Description of the token"
-            },
-            chain: {
-              type: "string",
-              enum: [
-                "solana",
-                "ethereum",
-                "base",
-                "polygon",
-                "arbitrum",
-                "optimism",
-                "bnb",
-                "avalanche",
-                "tron",
-                "bitcoin"
-              ],
-              description: "Chain of the token"
-            },
-            decimals: {
-              type: "number",
-              description: "Number of decimals of the token"
-            },
-            externalLinks: {
-              anyOf: [
-                {
-                  type: "object",
-                  properties: {
-                    website: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "Official website URL"
-                    },
-                    twitter: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "Twitter/X profile URL"
-                    },
-                    telegram: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "Telegram group URL"
-                    },
-                    discord: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "Discord server URL"
-                    },
-                    github: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "GitHub repository URL"
-                    },
-                    coingeckoId: {
-                      type: [
-                        "string",
-                        "null"
-                      ],
-                      description: "CoinGecko token ID"
-                    }
-                  },
-                  additionalProperties: false
-                },
-                {
-                  type: "null"
-                }
-              ],
-              description: "External links and social media"
-            },
-            balance: {
-              type: "object",
-              properties: {
-                amount: {
-                  type: "number",
-                  description: "Number of tokens owned"
-                },
-                value: {
-                  type: "number",
-                  description: "Total value of the token in USD"
-                },
-                price: {
-                  type: "number",
-                  description: "Current price of the token"
-                }
-              },
-              required: [
-                "amount",
-                "value",
-                "price"
-              ],
-              additionalProperties: false
-            }
-          },
-          required: [
-            "address",
-            "name",
-            "symbol",
-            "chain",
-            "decimals",
-            "balance"
-          ],
-          additionalProperties: false
-        }
-      },
-      $schema: "http://json-schema.org/draft-07/schema#"
-    }
-  },
   {
     name: "swaps_transaction_build",
     description: "Build a swap or bridge transaction. Returns an unsigned transaction with a human-readable message, amounts, exchange rate, and estimated time. Supports same-chain swaps and cross-chain bridges. Accepts UI amounts (e.g. 0.1 SOL) \u2014 decimal conversion is handled automatically.",
@@ -3267,6 +3047,135 @@ var schemas_default = [
       $schema: "http://json-schema.org/draft-07/schema#"
     }
   },
+  {
+    name: "token_transfer",
+    description: "Build an unsigned transfer transaction. Returns a transaction ready for signing. Handles both native and token transfers.",
+    inputSchema: {
+      $ref: "#/definitions/token_transfer_input",
+      definitions: {
+        token_transfer_input: {
+          type: "object",
+          properties: {
+            wallet: {
+              type: "string",
+              description: "Wallet address to transfer from"
+            },
+            token: {
+              type: "string",
+              description: "Mint address of the token to transfer"
+            },
+            to: {
+              type: "string",
+              description: "Recipient wallet address"
+            },
+            amount: {
+              type: "number",
+              description: "Amount to transfer in human-readable units (e.g. 1.5)"
+            },
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism",
+                "bnb",
+                "avalanche",
+                "tron",
+                "bitcoin"
+              ],
+              description: "Blockchain to execute the transfer on"
+            }
+          },
+          required: [
+            "wallet",
+            "token",
+            "to",
+            "amount",
+            "chain"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    outputSchema: {
+      $ref: "#/definitions/token_transfer_output",
+      definitions: {
+        token_transfer_output: {
+          type: "object",
+          properties: {
+            transaction: {
+              anyOf: [
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      type: "string",
+                      const: "solana"
+                    },
+                    base64: {
+                      type: "string",
+                      description: "Base64-encoded transaction"
+                    }
+                  },
+                  required: [
+                    "type",
+                    "base64"
+                  ],
+                  additionalProperties: false
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      type: "string",
+                      const: "evm"
+                    },
+                    to: {
+                      type: "string",
+                      description: "Recipient or contract address"
+                    },
+                    data: {
+                      type: "string",
+                      description: "Calldata (0x for native transfers)"
+                    },
+                    value: {
+                      type: "string",
+                      description: "Native token value in wei"
+                    },
+                    chainId: {
+                      type: "number",
+                      description: "EVM chain ID"
+                    }
+                  },
+                  required: [
+                    "type",
+                    "to",
+                    "data",
+                    "value",
+                    "chainId"
+                  ],
+                  additionalProperties: false
+                }
+              ]
+            },
+            message: {
+              type: "string"
+            }
+          },
+          required: [
+            "transaction",
+            "message"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
   {
     name: "token_trending_list",
     description: "Get currently trending tokens on a blockchain. Perfect for discovering what's hot right now.",
@@ -6423,26 +6332,45 @@ import { encodeFunctionData, maxUint256 } 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")
+});
 var tokenSwapSchema = defineToolSchema({
   name: "token_swap",
-  description: "Swap or bridge tokens end-to-end: builds via swaps.xyz, signs locally, broadcasts, and registers.",
+  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"),
+    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.")
+    }),
+    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.")
+    })
+  }),
+  output: swapOutputSchema
+});
+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"),
       chain: chainSchema.describe("Source chain"),
-      token: z9.string().describe("Input token address (selling)"),
-      amount: z9.number().describe("Amount of the input token")
+      token: z9.string().describe("Source token address"),
+      amount: z9.coerce.number().nullable().describe("Amount to send (exact-in). Null for exact-out.")
     }),
     to: z9.object({
-      wallet: z9.string().nullable().describe("Destination wallet (defaults to from wallet)"),
-      chain: chainSchema.nullable().describe("Destination chain (defaults to from chain)"),
-      token: z9.string().describe("Output token address (buying)")
+      wallet: z9.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.")
     })
   }),
-  output: z9.object({
-    signature: z9.string().describe("Transaction hash/signature"),
-    message: z9.string().describe("Human-readable swap description")
-  })
+  output: swapOutputSchema
 });
 
 // src/tools/token/swap/tool.ts
@@ -6457,29 +6385,30 @@ var ERC20_APPROVE_ABI = [
     outputs: [{ name: "", type: "bool" }]
   }
 ];
-var tokenSwap = createTool(tokenSwapSchema, async (params) => {
+var tokenBridge = createTool(tokenBridgeSchema, async (params) => {
+  if (!params.from.amount && !params.to.amount) {
+    throw new Error("Provide either from.amount or to.amount.");
+  }
   const baseUrl = resolveBaseUrl();
-  const fromChain = params.from.chain;
-  const toChain = params.to.chain ?? fromChain;
   const wallet = await walletRetrieve.handler({ wallet: params.from.wallet });
-  const fromAddress = wallet.addresses[KEY_CHAIN_MAP[fromChain]];
+  const fromAddress = wallet.addresses[KEY_CHAIN_MAP[params.from.chain]];
   if (!fromAddress) {
-    throw new Error(`Wallet "${wallet.name}" has no address on ${fromChain}.`);
+    throw new Error(`Wallet "${wallet.name}" has no address on ${params.from.chain}.`);
   }
   let toAddress = fromAddress;
   if (params.to.wallet) {
     try {
       const toWallet = await walletRetrieve.handler({ wallet: params.to.wallet });
-      toAddress = toWallet.addresses[KEY_CHAIN_MAP[toChain]] ?? params.to.wallet;
+      toAddress = toWallet.addresses[KEY_CHAIN_MAP[params.to.chain]] ?? params.to.wallet;
     } catch {
       toAddress = params.to.wallet;
     }
-  } else if (fromChain !== toChain) {
-    toAddress = wallet.addresses[KEY_CHAIN_MAP[toChain]] ?? fromAddress;
+  } else if (params.from.chain !== params.to.chain) {
+    toAddress = wallet.addresses[KEY_CHAIN_MAP[params.to.chain]] ?? fromAddress;
   }
   const buildParams = {
-    from: { wallet: fromAddress, chain: fromChain, token: params.from.token, amount: params.from.amount },
-    to: { wallet: toAddress, chain: toChain, token: params.to.token, amount: null }
+    from: { wallet: fromAddress, chain: params.from.chain, token: params.from.token, amount: params.from.amount },
+    to: { wallet: toAddress, chain: params.to.chain, token: params.to.token, amount: params.to.amount }
   };
   let buildResult = await callRemoteTool(baseUrl, "swaps_transaction_build", buildParams);
   const tx = buildResult.transaction;
@@ -6498,13 +6427,13 @@ var tokenSwap = createTool(tokenSwapSchema, async (params) => {
     };
     const { transaction: signedApproval } = await transactionSign.handler({
       wallet: wallet.name,
-      chain: fromChain,
+      chain: params.from.chain,
       transaction: JSON.stringify(approveTx)
     });
     const approvalResult = await callRemoteTool(baseUrl, "transaction_send", {
       transaction: signedApproval,
       message: `Approve ${buildResult.amountIn.symbol}`,
-      chain: fromChain
+      chain: params.from.chain
     });
     if (!approvalResult.signature) {
       throw new Error(`Approval failed: ${approvalResult.message}`);
@@ -6514,13 +6443,13 @@ var tokenSwap = createTool(tokenSwapSchema, async (params) => {
   const txPayload = "base64" in buildResult.transaction ? buildResult.transaction.base64 : JSON.stringify(buildResult.transaction);
   const { transaction: signedTransaction } = await transactionSign.handler({
     wallet: wallet.name,
-    chain: fromChain,
+    chain: params.from.chain,
     transaction: txPayload
   });
   const sendResult = await callRemoteTool(baseUrl, "transaction_send", {
     transaction: signedTransaction,
     message: buildResult.message,
-    chain: fromChain
+    chain: params.from.chain
   });
   if (!sendResult.signature) {
     throw new Error(`Transaction send failed: ${sendResult.message}`);
@@ -6530,26 +6459,140 @@ var tokenSwap = createTool(tokenSwapSchema, async (params) => {
     await callRemoteTool(baseUrl, "transaction_register", {
       transactionId: buildResult.transactionId,
       transactionHash: signature,
-      chain: fromChain
+      chain: params.from.chain
     });
   } catch {
   }
   return { signature, message: buildResult.message };
 });
+var tokenSwap = createTool(tokenSwapSchema, async (params) => {
+  return tokenBridge.handler({
+    from: { wallet: params.wallet, chain: params.chain, token: params.from.token, amount: params.from.amount },
+    to: { wallet: null, chain: params.chain, token: params.to.token, amount: params.to.amount }
+  });
+});
 
-// src/tools/virtual-account/wallet/register/schema.ts
+// src/tools/x402/request/tool.ts
+import { Keypair as Keypair4, VersionedTransaction as VersionedTransaction2, VersionedMessage } from "@solana/web3.js";
+import axios from "axios";
+import { wrapAxiosWithPayment } from "@x402/axios";
+import { x402Client } from "@x402/core/client";
+import { ExactSvmScheme } from "@x402/svm";
+
+// src/tools/x402/request/schema.ts
 import { z as z10 } 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(
+      (u) => {
+        try {
+          const host = new URL(u).hostname;
+          return !host.match(/^(localhost|127\.|10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|169\.254\.|0\.0\.0\.0|\[::1\])/);
+        } catch {
+          return false;
+        }
+      },
+      { message: "URL must not target private/internal addresses" }
+    ).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")
+  }),
+  output: z10.object({
+    status: z10.number().describe("HTTP status code"),
+    data: z10.any().describe("Response data"),
+    headers: z10.record(z10.string()).describe("Response headers")
+  })
+});
+
+// src/tools/x402/request/tool.ts
+var SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+function createLocalX402Client(walletAddress, secretKey) {
+  const keypair = Keypair4.fromSecretKey(secretKey);
+  const signer = {
+    address: walletAddress,
+    signTransactions: async (transactions) => {
+      return transactions.map((transaction) => {
+        const messageBytes = new Uint8Array(transaction.messageBytes);
+        const message = VersionedMessage.deserialize(messageBytes);
+        const numSigs = Object.keys(transaction.signatures).length;
+        const tx = new VersionedTransaction2(
+          message,
+          new Array(numSigs).fill(new Uint8Array(64))
+        );
+        tx.sign([keypair]);
+        const signerIndex = message.staticAccountKeys.findIndex(
+          (key) => key.toBase58() === walletAddress
+        );
+        if (signerIndex === -1) {
+          throw new Error(
+            `Wallet ${walletAddress} is not a signer for this transaction`
+          );
+        }
+        return {
+          [walletAddress]: tx.signatures[signerIndex]
+        };
+      });
+    }
+  };
+  const client = new x402Client();
+  const svmScheme = new ExactSvmScheme(signer);
+  client.register(SOLANA_NETWORK, svmScheme);
+  client.registerV1("solana", svmScheme);
+  return wrapAxiosWithPayment(axios.create(), client);
+}
+var x402Request = createTool(
+  x402RequestSchema,
+  async ({ method, url, body, params, wallet: walletNameOrAddress }) => {
+    const walletMetadata = findWalletOrThrow(walletNameOrAddress);
+    const { privateKey, address } = resolveSigningKey(walletMetadata, "solana");
+    const client = createLocalX402Client(address, privateKey);
+    let response;
+    switch (method) {
+      case "GET":
+        response = await client.get(url, { params });
+        break;
+      case "POST":
+        response = await client.post(url, body || {}, { params });
+        break;
+      case "PUT":
+        response = await client.put(url, body || {}, { params });
+        break;
+      case "PATCH":
+        response = await client.patch(url, body || {}, { params });
+        break;
+      case "DELETE":
+        response = await client.delete(url, { params });
+        break;
+      default:
+        throw new Error(`Unsupported HTTP method: ${method}`);
+    }
+    return {
+      status: response.status,
+      data: response.data,
+      headers: response.headers
+    };
+  }
+);
+
+// src/tools/virtual-account/wallet/register/schema.ts
+import { z as z11 } 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: z10.object({
-    wallet: z10.string().describe("Local wallet name"),
+  input: z11.object({
+    wallet: z11.string().describe("Local wallet name"),
     chain: chainSchema.describe("Chain to register (solana, ethereum, etc.)")
   }),
-  output: z10.object({
-    success: z10.literal(true),
-    address: z10.string().describe("Registered wallet address"),
-    chain: z10.string().describe("Chain registered on")
+  output: z11.object({
+    success: z11.literal(true),
+    address: z11.string().describe("Registered wallet address"),
+    chain: z11.string().describe("Chain registered on")
   })
 });
 
@@ -6591,6 +6634,7 @@ export {
   resolveBaseUrl,
   login,
   callTool,
+  callRemoteTool,
   schemas_default,
   defineToolSchema,
   createTool,
@@ -6602,7 +6646,9 @@ export {
   transactionSign,
   messageSign,
   bitcoinBalanceRetrieve,
+  tokenBridge,
   tokenSwap,
+  x402Request,
   virtualAccountWalletRegister
 };
-//# sourceMappingURL=chunk-AH5VMN63.js.map
+//# sourceMappingURL=chunk-PBRXVTTG.js.map