agentwallet-mcp 1.9.0 → 1.10.1

package/build/index.js

@@ -12,8 +12,14 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { assertPublicUrl, safeFetch } from './ssrf-guard.js';
 import { deriveX402Payment, isWithinCap } from './x402-payment.js';
 import { isLocalMode, getLocalAddress, localWalletRecord, localSend, localNativeBalance, localTokenBalance, localSignMessage, resolveRpcUrl, } from './local-wallet.js';
+import { isSolanaLocalMode, getSolanaAddress, solanaWalletRecord, localSolBalance, localSplBalance, localSolTransfer, localSplTransfer, resolveSolanaRpc, } from './local-solana.js';
+/** True when either chain family is running non-custodially. */
+function anyLocalMode() {
+    return isLocalMode() || isSolanaLocalMode();
+}
 // ─── Configuration ──────────────────────────────────────────────
 const API_BASE = process.env.AGENTWALLET_API_URL || 'https://hifriendbot.com/wp-json/agentwallet/v1';
 const API_USER = process.env.AGENTWALLET_USER || '';
@@ -38,21 +44,43 @@ function localChainId(body, qs) {
         return parseInt(fromEnv, 10);
     return 8453; // Base, matching the custodial default
 }
-function refuseSolanaLocally() {
-    throw new Error('Local signing mode currently supports EVM chains only. Solana keys are not signed in-process yet, ' +
-        'so this call was refused rather than silently routed through the hosted custodial API. ' +
-        'Unset AGENTWALLET_PRIVATE_KEY to use the custodial path for Solana.');
+/**
+ * Refuse rather than silently hand the operation to someone else's signer.
+ *
+ * Reached when the operator is running non-custodially for one chain family but
+ * has supplied no key for the other. Falling through to the hosted API here
+ * would move funds onto a key they do not hold, while they believe they are in
+ * self-custody. That is the single worst thing this server could do, so it
+ * stops and says exactly which variable is missing.
+ */
+function refuseMissingLocalKey(family) {
+    const wanted = family === 'solana'
+        ? 'AGENTWALLET_SOLANA_KEY (or AGENTWALLET_SOLANA_KEYFILE)'
+        : 'AGENTWALLET_PRIVATE_KEY (or AGENTWALLET_KEYFILE)';
+    throw new Error(`This is a ${family === 'solana' ? 'Solana' : 'EVM'} operation and no local ${family === 'solana' ? 'Solana' : 'EVM'} key is configured, ` +
+        `but this server is running in local signing mode. Refusing rather than routing it through the hosted ` +
+        `custodial signer while you believe you hold the keys. Set ${wanted} to sign it here, or unset the other ` +
+        `local key variables to use the hosted path for everything.`);
 }
 async function routeLocally(path, method, body) {
     const [rawPath, rawQs = ''] = path.split('?');
     const qs = new URLSearchParams(rawQs);
     // POST /wallets/{id}/send
     if (method === 'POST' && /^\/wallets\/[^/]*\/send$/.test(rawPath)) {
-        if (body?.token_mint)
-            refuseSolanaLocally();
         const chainId = localChainId(body, qs);
-        if (SOLANA_CHAIN_IDS.has(chainId))
-            refuseSolanaLocally();
+        const solanaOp = SOLANA_CHAIN_IDS.has(chainId) || Boolean(body?.token_mint);
+        if (solanaOp) {
+            if (!isSolanaLocalMode())
+                refuseMissingLocalKey('solana');
+            const to = String(body?.to || '');
+            const value = String(body?.value ?? '0');
+            if (body?.token_mint) {
+                return localSplTransfer(String(body.token_mint), to, value, Number(body.token_decimals ?? 6), chainId);
+            }
+            return localSolTransfer(to, value, chainId);
+        }
+        if (!isLocalMode())
+            refuseMissingLocalKey('evm');
         const to = String(body?.to || '');
         const value = BigInt(String(body?.value ?? '0'));
         const data = String(body?.data || '');
@@ -65,16 +93,27 @@ async function routeLocally(path, method, body) {
     // GET /wallets/{id}/balance
     if (method === 'GET' && /^\/wallets\/[^/]*\/balance$/.test(rawPath)) {
         const chainId = localChainId(body, qs);
-        if (SOLANA_CHAIN_IDS.has(chainId))
-            refuseSolanaLocally();
+        if (SOLANA_CHAIN_IDS.has(chainId)) {
+            if (!isSolanaLocalMode())
+                refuseMissingLocalKey('solana');
+            return localSolBalance(chainId);
+        }
+        if (!isLocalMode())
+            refuseMissingLocalKey('evm');
         return localNativeBalance(chainId);
     }
     // GET /wallets/{id}/token-balance
     if (method === 'GET' && /^\/wallets\/[^/]*\/token-balance$/.test(rawPath)) {
         const chainId = localChainId(body, qs);
-        if (SOLANA_CHAIN_IDS.has(chainId))
-            refuseSolanaLocally();
-        const token = qs.get('token') || qs.get('token_address') || '';
+        const token0 = qs.get('token') || qs.get('token_address') || '';
+        if (SOLANA_CHAIN_IDS.has(chainId)) {
+            if (!isSolanaLocalMode())
+                refuseMissingLocalKey('solana');
+            return localSplBalance(token0, chainId);
+        }
+        if (!isLocalMode())
+            refuseMissingLocalKey('evm');
+        const token = token0;
         if (!/^0x[a-fA-F0-9]{40}$/.test(token)) {
             throw new Error(`Local mode needs an EVM token address, got "${token}".`);
         }
@@ -88,11 +127,18 @@ async function routeLocally(path, method, body) {
         throw new Error('Local mode signs messages in-process. For transactions use send_transaction, ' +
             'which signs and broadcasts locally in one step.');
     }
-    // Wallet listing and lookup describe the one local key.
-    if (method === 'GET' && rawPath === '/wallets')
-        return { wallets: [localWalletRecord()] };
-    if (method === 'GET' && /^\/wallets\/[^/]+$/.test(rawPath))
-        return localWalletRecord();
+    // Wallet listing and lookup describe whichever local keys are configured.
+    if (method === 'GET' && rawPath === '/wallets') {
+        const wallets = [];
+        if (isLocalMode())
+            wallets.push(localWalletRecord());
+        if (isSolanaLocalMode())
+            wallets.push(solanaWalletRecord());
+        return { wallets };
+    }
+    if (method === 'GET' && /^\/wallets\/[^/]+$/.test(rawPath)) {
+        return isLocalMode() ? localWalletRecord() : solanaWalletRecord();
+    }
     if (method === 'POST' && rawPath === '/wallets') {
         throw new Error('Local signing mode uses the single key you supplied, so there is nothing to create. ' +
             'Generate another key yourself and run a second instance with a different ' +
@@ -112,7 +158,7 @@ async function api(path, method = 'GET', body, extraHeaders) {
     /* Local mode intercepts here rather than inside each tool. Routing at the
        single choke point every funds operation already passes through means no
        tool can quietly stay custodial because someone forgot to update it. */
-    if (isLocalMode()) {
+    if (anyLocalMode()) {
         const handled = await routeLocally(path, method, body);
         if (handled !== NOT_HANDLED)
             return handled;
@@ -132,7 +178,7 @@ async function api(path, method = 'GET', body, extraHeaders) {
     const res = await fetch(url, options);
     const data = await res.json();
     // Handle 402 Payment Required — auto-pay if a wallet or a local key is configured
-    if (res.status === 402 && (X402_WALLET_ID || isLocalMode()) && !extraHeaders?.['X-PAYMENT']) {
+    if (res.status === 402 && (X402_WALLET_ID || anyLocalMode()) && !extraHeaders?.['X-PAYMENT']) {
         return handleX402Payment(data, path, method, body);
     }
     if (!res.ok) {
@@ -315,82 +361,82 @@ function resolveChainId(network) {
 // ─── Server ──────────────────────────────────────────────────────
 const server = new McpServer({
     name: 'agentwallet',
-    version: '1.8.0',
+    version: '1.10.1',
 }, {
-    instructions: `AgentWallet gives AI agents their own blockchain wallets. Private keys are encrypted server-side and never exposed — agents sign and broadcast transactions without ever touching raw keys.
-
-## Getting Started
-1. Call list_wallets to see existing wallets, or create_wallet to make a new one.
-2. Fund the wallet by sending tokens to its address from an external source.
-3. Use transfer (native tokens) or transfer_token (ERC-20/SPL tokens) to send funds.
-
-## Supported Chains
-- **EVM chains:** Ethereum (1), Base (8453), Arbitrum (42161), Optimism (10), Polygon (137), Avalanche (43114), BSC (56), Zora (7777777), PulseChain (369)
-- **Solana:** Mainnet (900), Devnet (901)
-- Call get_chains for the full list with native tokens and stablecoin contract addresses.
-
-## EVM vs Solana
-- **Addresses:** EVM uses 0x-prefixed hex (42 chars). Solana uses Base58 (32-44 chars).
-- **Native tokens:** EVM = ETH/POL/BNB/etc (18 decimals, wei). Solana = SOL (9 decimals, lamports).
-- **Token standards:** EVM uses ERC-20. Solana uses SPL tokens.
-- **EVM-only tools:** approve_token, get_allowance, wrap_eth, unwrap_eth, call_contract, get_token_info. These do not work on Solana.
-- **Works on both:** create_wallet, transfer, transfer_token, send_transaction, sign_transaction, get_balance, get_token_balance.
-
-## Common Workflows
-
-### Send native tokens (ETH, SOL, etc.)
-Use the transfer tool with a human-readable amount (e.g. "0.1" ETH). It auto-converts to wei/lamports.
-
-### Send ERC-20 or SPL tokens
-Use transfer_token. You need: wallet_id, token contract address, recipient, amount, chain_id, and decimals (6 for USDC, 18 for most ERC-20s). Call get_chains to find stablecoin addresses.
-
-### Interact with DeFi (EVM only)
-1. Check allowance with get_allowance.
-2. If needed, call approve_token to let the DeFi contract spend your tokens.
-3. Use send_transaction with the contract's calldata to execute the interaction.
-
-### Wrap/unwrap native tokens (EVM only)
-Use wrap_eth to convert ETH → WETH (required by many DeFi protocols). Use unwrap_eth to convert back.
-
-### Read on-chain data (EVM only)
-Use call_contract for gas-free read-only calls (eth_call). Provide ABI-encoded calldata.
-
-## x402 Payments — Paying for Resources
-The pay_x402 tool handles the full x402 payment flow automatically:
-1. Fetches the URL.
-2. If the server returns HTTP 402, parses the payment requirements.
-3. Pays on-chain using your wallet.
-4. Retries the request with proof of payment.
-Always set max_payment to prevent overspending (e.g. "1.00" for max 1 USDC).
-
-## x402 Paywalls — Accepting Payments
-Create paywalls to charge other agents for accessing your resources:
-1. create_paywall — set price, token, chain, and the resource URL to protect.
-2. Share the access URL. Clients that pay on-chain get the resource; others get HTTP 402.
-3. list_paywalls and get_paywall_payments to track revenue.
-4. get_x402_revenue for aggregate stats across all paywalls.
-
-## Wallet Security
-- Use pause_wallet to immediately freeze a wallet if compromised. No transactions can be signed while paused.
-- Use unpause_wallet to resume operations.
-- Use delete_wallet to permanently disable a wallet.
-- Wallets have server-enforced spending limits.
-
-## Tool Selection Guide
-| Goal | Tool |
-|------|------|
-| Send ETH/SOL/native tokens | transfer |
-| Send USDC/ERC-20/SPL tokens | transfer_token |
-| Check native balance | get_balance |
-| Check token balance | get_token_balance |
-| Look up token details | get_token_info (EVM only) |
-| Approve DeFi spending | approve_token (EVM only) |
-| Check approval amount | get_allowance (EVM only) |
-| Read smart contract | call_contract (EVM only) |
-| Custom transaction | send_transaction |
-| Sign without broadcasting | sign_transaction |
-| Pay for x402 resource | pay_x402 |
-| Charge for your resource | create_paywall |
+    instructions: `AgentWallet gives AI agents their own blockchain wallets. Private keys are encrypted server-side and never exposed — agents sign and broadcast transactions without ever touching raw keys.
+
+## Getting Started
+1. Call list_wallets to see existing wallets, or create_wallet to make a new one.
+2. Fund the wallet by sending tokens to its address from an external source.
+3. Use transfer (native tokens) or transfer_token (ERC-20/SPL tokens) to send funds.
+
+## Supported Chains
+- **EVM chains:** Ethereum (1), Base (8453), Arbitrum (42161), Optimism (10), Polygon (137), Avalanche (43114), BSC (56), Zora (7777777), PulseChain (369)
+- **Solana:** Mainnet (900), Devnet (901)
+- Call get_chains for the full list with native tokens and stablecoin contract addresses.
+
+## EVM vs Solana
+- **Addresses:** EVM uses 0x-prefixed hex (42 chars). Solana uses Base58 (32-44 chars).
+- **Native tokens:** EVM = ETH/POL/BNB/etc (18 decimals, wei). Solana = SOL (9 decimals, lamports).
+- **Token standards:** EVM uses ERC-20. Solana uses SPL tokens.
+- **EVM-only tools:** approve_token, get_allowance, wrap_eth, unwrap_eth, call_contract, get_token_info. These do not work on Solana.
+- **Works on both:** create_wallet, transfer, transfer_token, send_transaction, sign_transaction, get_balance, get_token_balance.
+
+## Common Workflows
+
+### Send native tokens (ETH, SOL, etc.)
+Use the transfer tool with a human-readable amount (e.g. "0.1" ETH). It auto-converts to wei/lamports.
+
+### Send ERC-20 or SPL tokens
+Use transfer_token. You need: wallet_id, token contract address, recipient, amount, chain_id, and decimals (6 for USDC, 18 for most ERC-20s). Call get_chains to find stablecoin addresses.
+
+### Interact with DeFi (EVM only)
+1. Check allowance with get_allowance.
+2. If needed, call approve_token to let the DeFi contract spend your tokens.
+3. Use send_transaction with the contract's calldata to execute the interaction.
+
+### Wrap/unwrap native tokens (EVM only)
+Use wrap_eth to convert ETH → WETH (required by many DeFi protocols). Use unwrap_eth to convert back.
+
+### Read on-chain data (EVM only)
+Use call_contract for gas-free read-only calls (eth_call). Provide ABI-encoded calldata.
+
+## x402 Payments — Paying for Resources
+The pay_x402 tool handles the full x402 payment flow automatically:
+1. Fetches the URL.
+2. If the server returns HTTP 402, parses the payment requirements.
+3. Pays on-chain using your wallet.
+4. Retries the request with proof of payment.
+Always set max_payment to prevent overspending (e.g. "1.00" for max 1 USDC).
+
+## x402 Paywalls — Accepting Payments
+Create paywalls to charge other agents for accessing your resources:
+1. create_paywall — set price, token, chain, and the resource URL to protect.
+2. Share the access URL. Clients that pay on-chain get the resource; others get HTTP 402.
+3. list_paywalls and get_paywall_payments to track revenue.
+4. get_x402_revenue for aggregate stats across all paywalls.
+
+## Wallet Security
+- Use pause_wallet to immediately freeze a wallet if compromised. No transactions can be signed while paused.
+- Use unpause_wallet to resume operations.
+- Use delete_wallet to permanently disable a wallet.
+- Wallets have server-enforced spending limits.
+
+## Tool Selection Guide
+| Goal | Tool |
+|------|------|
+| Send ETH/SOL/native tokens | transfer |
+| Send USDC/ERC-20/SPL tokens | transfer_token |
+| Check native balance | get_balance |
+| Check token balance | get_token_balance |
+| Look up token details | get_token_info (EVM only) |
+| Approve DeFi spending | approve_token (EVM only) |
+| Check approval amount | get_allowance (EVM only) |
+| Read smart contract | call_contract (EVM only) |
+| Custom transaction | send_transaction |
+| Sign without broadcasting | sign_transaction |
+| Pay for x402 resource | pay_x402 |
+| Charge for your resource | create_paywall |
 | Check usage/billing | get_usage |`,
 });
 // ─── Tool: create_wallet ─────────────────────────────────────────
@@ -855,19 +901,10 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
             throw new Error('Invalid headers JSON. Must be a JSON object (e.g. {"Authorization": "Bearer ..."}).');
         }
     }
-    // Validate URL — block private IPs and cloud metadata endpoints
-    const urlObj = new URL(url);
-    const hostname = urlObj.hostname.toLowerCase();
-    const blockedHosts = ['localhost', '127.0.0.1', '0.0.0.0', '[::1]', '169.254.169.254', 'metadata.google.internal'];
-    const blockedPrefixes = ['10.', '172.16.', '172.17.', '172.18.', '172.19.', '172.20.', '172.21.',
-        '172.22.', '172.23.', '172.24.', '172.25.', '172.26.', '172.27.', '172.28.', '172.29.',
-        '172.30.', '172.31.', '192.168.'];
-    if (blockedHosts.includes(hostname) || blockedPrefixes.some(p => hostname.startsWith(p))) {
-        throw new Error('URL points to a private/internal address. Only public URLs are allowed.');
-    }
-    if (urlObj.protocol !== 'https:') {
-        throw new Error('Only HTTPS URLs are supported for x402 payments.');
-    }
+    // Validate URL: canonicalizes IP literals (including IPv4-mapped IPv6) and
+    // resolves DNS names, rejecting any private/internal destination. Redirect
+    // hops are re-validated by safeFetch below.
+    await assertPublicUrl(url);
     // Step 1: Make initial request
     const reqOptions = {
         method,
@@ -879,7 +916,7 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
         if (!reqHeaders['Content-Type'])
             reqHeaders['Content-Type'] = 'application/json';
     }
-    const initialRes = await fetch(url, reqOptions);
+    const initialRes = await safeFetch(url, reqOptions);
     // If not 402, return the response as-is (no payment needed)
     if (initialRes.status !== 402) {
         const text = await initialRes.text();
@@ -1013,7 +1050,7 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
     if (reqBody && method !== 'GET') {
         retryOptions.body = reqBody;
     }
-    const retryRes = await fetch(url, retryOptions);
+    const retryRes = await safeFetch(url, retryOptions);
     const retryText = await retryRes.text();
     let retryParsed;
     try {
@@ -1193,31 +1230,53 @@ server.tool('get_x402_revenue', 'Get aggregate x402 revenue statistics across al
 // ─── Tool: wallet_mode ──────────────────────────────────────────
 server.tool('wallet_mode', 'Report whether this server is signing locally (self-custody, the private key never leaves this machine) ' +
     'or through the hosted AgentWallet API (custodial). Use this to verify custody before moving funds.', {}, async () => {
-    if (!isLocalMode()) {
+    if (!anyLocalMode()) {
         return jsonResponse({
             mode: 'custodial',
             custody: 'agentwallet',
             signing: 'AgentWallet servers hold an encrypted key and sign on your behalf.',
             api_base: API_BASE,
-            to_self_custody: 'Set AGENTWALLET_PRIVATE_KEY (or AGENTWALLET_KEYFILE) and restart. ' +
+            to_self_custody: 'Set AGENTWALLET_PRIVATE_KEY for EVM and/or AGENTWALLET_SOLANA_KEY for Solana, then restart. ' +
                 'Use export_wallet_key first if you want to carry an existing hosted wallet across.',
         });
     }
-    let rpc = 'default public endpoint';
-    try {
-        rpc = resolveRpcUrl(parseInt(process.env.AGENTWALLET_CHAIN_ID || '8453', 10));
-    }
-    catch { /* chain has no default; not worth failing the report over */ }
-    return jsonResponse({
+    const report = {
         mode: 'local',
         custody: 'self',
-        address: getLocalAddress(),
-        signing: 'Signed in this process. The private key is never sent to AgentWallet or anyone else.',
-        rpc_endpoint: rpc,
-        chains: 'EVM only in local mode. Solana calls are refused rather than routed to the custodial API.',
-        per_tx_cap_native: process.env.AGENTWALLET_MAX_TX_NATIVE || 'not set',
+        signing: 'Signed in this process. Keys are never sent to AgentWallet or anyone else.',
         max_autopay: process.env.AGENTWALLET_MAX_AUTOPAY || '1',
-    });
+    };
+    if (isLocalMode()) {
+        let rpc = 'default public endpoint';
+        try {
+            rpc = resolveRpcUrl(parseInt(process.env.AGENTWALLET_CHAIN_ID || '8453', 10));
+        }
+        catch { /* chain has no default; not worth failing the report over */ }
+        report.evm = {
+            address: getLocalAddress(),
+            rpc_endpoint: rpc,
+            per_tx_cap_native: process.env.AGENTWALLET_MAX_TX_NATIVE || 'not set',
+        };
+    }
+    else {
+        report.evm = 'no local EVM key. EVM operations are refused, not sent to the hosted signer.';
+    }
+    if (isSolanaLocalMode()) {
+        let rpc = 'default public endpoint';
+        try {
+            rpc = resolveSolanaRpc(900);
+        }
+        catch { /* fall through to the default label */ }
+        report.solana = {
+            address: getSolanaAddress(),
+            rpc_endpoint: rpc,
+            per_tx_cap_sol: process.env.AGENTWALLET_MAX_TX_SOL || 'not set',
+        };
+    }
+    else {
+        report.solana = 'no local Solana key. Solana operations are refused, not sent to the hosted signer.';
+    }
+    return jsonResponse(report);
 });
 // ─── Tool: export_wallet_key ────────────────────────────────────
 server.tool('export_wallet_key', 'Explain how to export the private key of a hosted (custodial) AgentWallet so it can be moved ' +
@@ -1225,12 +1284,12 @@ server.tool('export_wallet_key', 'Explain how to export the private key of a hos
     'performed by this tool.', {
     wallet_id: z.number().int().optional().describe('Hosted wallet ID to export'),
 }, async ({ wallet_id }) => {
-    if (isLocalMode()) {
+    if (anyLocalMode()) {
         return jsonResponse({
             exportable: true,
             mode: 'local',
-            note: 'You are already in self-custody. The key is the one you supplied via AGENTWALLET_PRIVATE_KEY ' +
-                'or AGENTWALLET_KEYFILE, and this server has no copy of it beyond this process.',
+            note: 'You are already in self-custody. The keys are the ones you supplied via AGENTWALLET_PRIVATE_KEY, ' +
+                'AGENTWALLET_SOLANA_KEY or their KEYFILE variants, and this server keeps no copy beyond this process.',
         });
     }
     return jsonResponse({
@@ -1252,12 +1311,17 @@ async function main() {
     await server.connect(transport);
     /* stderr, so it never corrupts the stdio JSON-RPC stream. Announcing custody
        at startup means an operator sees which mode they are in without asking. */
-    if (isLocalMode()) {
+    if (anyLocalMode()) {
         try {
-            console.error(`AgentWallet MCP: LOCAL signing mode. Address ${getLocalAddress()}. Key never leaves this machine.`);
+            const parts = [];
+            if (isLocalMode())
+                parts.push(`EVM ${getLocalAddress()}`);
+            if (isSolanaLocalMode())
+                parts.push(`Solana ${getSolanaAddress()}`);
+            console.error(`AgentWallet MCP: LOCAL signing mode. ${parts.join(', ')}. Keys never leave this machine.`);
         }
         catch (e) {
-            console.error(`AgentWallet MCP: local signing configured but the key could not be loaded: ${e.message}`);
+            console.error(`AgentWallet MCP: local signing configured but a key could not be loaded: ${e.message}`);
             process.exit(1);
         }
     }

package/build/local-solana.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Local (non-custodial) Solana signing.
+ *
+ * Same contract as local-wallet.ts on the EVM side: the secret key is loaded
+ * once into this process, never written anywhere, never logged, and never put
+ * in an error message. Transactions are signed here and submitted straight to
+ * an RPC endpoint. The AgentWallet API is not involved.
+ *
+ * SPL transfers are built from raw instructions rather than @solana/spl-token
+ * on purpose. That package pulls in bigint-buffer, which carries a high
+ * severity buffer overflow advisory, and a wallet has no business shipping
+ * that when the two instructions it needs are a dozen lines each.
+ */
+import { Keypair } from '@solana/web3.js';
+export declare function isSolanaLocalMode(): boolean;
+export declare function getSolanaKeypair(): Keypair;
+export declare function getSolanaAddress(): string;
+export declare function resolveSolanaRpc(chainId?: number): string;
+export declare function localSolBalance(chainId?: number): Promise<{
+    address: string;
+    chain_id: number;
+    balance_lamports: string;
+    balance: string;
+    mode: string;
+}>;
+export declare function localSplBalance(mintStr: string, chainId?: number): Promise<{
+    address: string;
+    chain_id: number;
+    mint: string;
+    token_account: string;
+    balance_raw: string;
+    balance: string;
+    decimals: number;
+    mode: string;
+}>;
+export interface LocalSolResult {
+    signature: string;
+    from: string;
+    to: string;
+    value: string;
+    chain_id: number;
+    mode: 'local';
+    signed_locally: true;
+}
+export declare function localSolTransfer(to: string, lamports: string, chainId?: number): Promise<LocalSolResult>;
+/**
+ * Transfer SPL tokens. The recipient's associated account is created if it does
+ * not exist, using the idempotent instruction so a race cannot fail the send.
+ */
+export declare function localSplTransfer(mintStr: string, to: string, rawAmount: string, decimals: number, chainId?: number): Promise<LocalSolResult>;
+export declare function solanaWalletRecord(): {
+    id: string;
+    address: string;
+    wallet_type: string;
+    mode: string;
+    custody: string;
+    note: string;
+};