nansen-cli 1.6.0 → 1.7.0

package/src/x402-evm.js

@@ -0,0 +1,207 @@
+/**
+ * Nansen CLI - x402 EVM Auto-Payment
+ * Implements EIP-3009 TransferWithAuthorization via EIP-712 typed data signing.
+ * Zero external dependencies — uses Node.js built-in crypto + wallet.js keccak256.
+ */
+
+import crypto from 'crypto';
+import { keccak256, signSecp256k1 } from './crypto.js';
+
+// ============= EIP-712 Type Hashing =============
+
+const DOMAIN_TYPES = [
+  { name: 'name', type: 'string' },
+  { name: 'version', type: 'string' },
+  { name: 'chainId', type: 'uint256' },
+  { name: 'verifyingContract', type: 'address' },
+];
+
+const AUTHORIZATION_TYPES = [
+  { name: 'from', type: 'address' },
+  { name: 'to', type: 'address' },
+  { name: 'value', type: 'uint256' },
+  { name: 'validAfter', type: 'uint256' },
+  { name: 'validBefore', type: 'uint256' },
+  { name: 'nonce', type: 'bytes32' },
+];
+
+/**
+ * Encode a type string for EIP-712 typeHash.
+ * e.g. "TransferWithAuthorization(address from,address to,uint256 value,...)"
+ */
+function encodeType(typeName, fields) {
+  const fieldStrs = fields.map(f => `${f.type} ${f.name}`);
+  return `${typeName}(${fieldStrs.join(',')})`;
+}
+
+/**
+ * Compute typeHash = keccak256(encodeType(...))
+ */
+function typeHash(typeName, fields) {
+  return keccak256(Buffer.from(encodeType(typeName, fields), 'utf8'));
+}
+
+/**
+ * ABI-encode a single value to 32 bytes based on its EIP-712 type.
+ */
+function encodeValue(fieldType, value) {
+  if (fieldType === 'string') {
+    // Strings are hashed
+    return keccak256(Buffer.from(value, 'utf8'));
+  }
+  if (fieldType === 'bytes') {
+    const buf = typeof value === 'string' ? Buffer.from(value.replace(/^0x/, ''), 'hex') : value;
+    return keccak256(buf);
+  }
+  if (fieldType === 'bytes32') {
+    if (typeof value === 'string') {
+      return Buffer.from(value.replace(/^0x/, ''), 'hex');
+    }
+    return value;
+  }
+  if (fieldType === 'address') {
+    // Left-pad address to 32 bytes
+    const addr = value.replace(/^0x/, '').toLowerCase();
+    return Buffer.from(addr.padStart(64, '0'), 'hex');
+  }
+  if (fieldType.startsWith('uint') || fieldType.startsWith('int')) {
+    // Encode as 32-byte big-endian
+    const hex = BigInt(value).toString(16).padStart(64, '0');
+    return Buffer.from(hex, 'hex');
+  }
+  if (fieldType === 'bool') {
+    return Buffer.from((value ? '1' : '0').padStart(64, '0'), 'hex');
+  }
+  throw new Error(`Unsupported EIP-712 field type: ${fieldType}`);
+}
+
+/**
+ * Compute struct hash = keccak256(typeHash || encodeValue(field1) || encodeValue(field2) || ...)
+ */
+function hashStruct(typeName, fields, data) {
+  const parts = [typeHash(typeName, fields)];
+  for (const field of fields) {
+    const value = data[field.name];
+    if (value === undefined || value === null) {
+      throw new Error(`Missing EIP-712 field: ${field.name}`);
+    }
+    parts.push(encodeValue(field.type, value));
+  }
+  return keccak256(Buffer.concat(parts));
+}
+
+/**
+ * Compute EIP-712 domain separator hash.
+ */
+function hashDomain(domain) {
+  return hashStruct('EIP712Domain', DOMAIN_TYPES, domain);
+}
+
+/**
+ * Compute EIP-712 final hash: keccak256("\x19\x01" || domainSeparator || structHash)
+ */
+export function hashTypedData(domain, primaryType, fields, message) {
+  const domainSeparator = hashDomain(domain);
+  const structHash = hashStruct(primaryType, fields, message);
+  return keccak256(Buffer.concat([
+    Buffer.from([0x19, 0x01]),
+    domainSeparator,
+    structHash,
+  ]));
+}
+
+// ============= x402 EVM Payment =============
+
+/**
+ * Extract chain ID from CAIP-2 network identifier.
+ * e.g. "eip155:8453" → 8453
+ */
+function getChainId(network) {
+  const match = network.match(/^eip155:(\d+)$/);
+  if (!match) throw new Error(`Invalid EVM network: ${network}`);
+  return parseInt(match[1], 10);
+}
+
+/**
+ * Create an x402 payment payload for EVM (EIP-3009 TransferWithAuthorization).
+ *
+ * @param {object} requirements - Parsed PaymentRequirements from 402 response
+ * @param {string} privateKeyHex - 32-byte EVM private key as hex
+ * @param {string} walletAddress - Signer's EVM address
+ * @param {string} resource - Original request URL
+ * @returns {string} Base64-encoded PaymentPayload for Payment-Signature header
+ */
+export function createEvmPaymentPayload(requirements, privateKeyHex, walletAddress, resource) {
+  const chainId = getChainId(requirements.network);
+  const extra = requirements.extra || {};
+
+  // Token name and version from requirements.extra (set by server/facilitator)
+  const tokenName = extra.name;
+  const tokenVersion = extra.version || '1';
+
+  if (!tokenName) {
+    throw new Error('EIP-712 domain name missing from requirements.extra');
+  }
+
+  // Generate random nonce (32 bytes)
+  const nonce = '0x' + crypto.randomBytes(32).toString('hex');
+
+  // Validity window: valid now, expires in 1 hour
+  const now = Math.floor(Date.now() / 1000);
+  const validAfter = '0';
+  const validBefore = String(now + 3600);
+
+  // EIP-712 domain
+  const domain = {
+    name: tokenName,
+    version: tokenVersion,
+    chainId,
+    verifyingContract: requirements.asset,
+  };
+
+  // EIP-3009 message
+  const message = {
+    from: walletAddress,
+    to: requirements.pay_to || requirements.payTo,
+    value: BigInt(requirements.amount),
+    validAfter: BigInt(validAfter),
+    validBefore: BigInt(validBefore),
+    nonce: nonce,
+  };
+
+  // Hash and sign
+  const msgHash = hashTypedData(domain, 'TransferWithAuthorization', AUTHORIZATION_TYPES, message);
+  const { r, s, v } = signSecp256k1(msgHash, Buffer.from(privateKeyHex, 'hex'));
+  const signature = '0x' + r.toString('hex') + s.toString('hex') + (27 + v).toString(16);
+
+  // Build payload (camelCase keys per x402 spec)
+  const payload = {
+    x402Version: 2,
+    payload: {
+      authorization: {
+        from: walletAddress,
+        to: message.to,
+        value: String(requirements.amount),
+        validAfter: validAfter,
+        validBefore: validBefore,
+        nonce: nonce,
+      },
+      signature: signature,
+    },
+    accepted: requirements,
+  };
+
+  // Add resource as object if provided
+  if (resource) {
+    payload.resource = { url: resource };
+  }
+
+  return Buffer.from(JSON.stringify(payload)).toString('base64');
+}
+
+/**
+ * Check if a network string is an EVM network.
+ */
+export function isEvmNetwork(network) {
+  return typeof network === 'string' && network.startsWith('eip155:');
+}

package/src/x402-svm.js

@@ -0,0 +1,474 @@
+/**
+ * Nansen CLI - x402 Solana Auto-Payment
+ * Implements SPL TransferChecked transaction building for x402 payments.
+ * Zero external dependencies — uses Node.js built-in crypto + wallet.js base58.
+ */
+
+import crypto from 'crypto';
+
+// ============= Base58 Encode (inline from wallet.js PR #26) =============
+const BASE58_ALPHABET_STR = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+export function base58Encode(buf) {
+  let num = 0n;
+  for (const byte of buf) {
+    num = num * 256n + BigInt(byte);
+  }
+  let str = '';
+  while (num > 0n) {
+    const rem = Number(num % 58n);
+    num = num / 58n;
+    str = BASE58_ALPHABET_STR[rem] + str;
+  }
+  for (const byte of buf) {
+    if (byte === 0) str = '1' + str;
+    else break;
+  }
+  return str || '1';
+}
+
+// ============= Constants =============
+
+const TOKEN_PROGRAM = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+const TOKEN_2022_PROGRAM = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+const COMPUTE_BUDGET_PROGRAM = 'ComputeBudget111111111111111111111111111111';
+const MEMO_PROGRAM = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+const ATA_PROGRAM = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+const SYSTEM_PROGRAM = '11111111111111111111111111111111';
+
+const DEFAULT_COMPUTE_UNIT_LIMIT = 20000;
+const DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+
+// ============= Base58 Decode =============
+
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE58_MAP = new Uint8Array(128);
+for (let i = 0; i < BASE58_ALPHABET.length; i++) {
+  BASE58_MAP[BASE58_ALPHABET.charCodeAt(i)] = i;
+}
+
+export function base58Decode(str) {
+  let num = 0n;
+  for (const ch of str) {
+    num = num * 58n + BigInt(BASE58_MAP[ch.charCodeAt(0)]);
+  }
+
+  // Count leading '1's → leading zero bytes
+  let leadingZeros = 0;
+  for (const ch of str) {
+    if (ch === '1') leadingZeros++;
+    else break;
+  }
+
+  if (num === 0n) return Buffer.alloc(leadingZeros || 1);
+
+  // Convert to bytes
+  const hex = num.toString(16);
+  const paddedHex = hex.length % 2 ? '0' + hex : hex;
+  const bytes = Buffer.from(paddedHex, 'hex');
+
+  return Buffer.concat([Buffer.alloc(leadingZeros), bytes]);
+}
+
+/**
+ * Decode a base58 string to exactly 32 bytes (left-pad with zeros).
+ * Use for Solana public keys and hashes.
+ */
+export function base58DecodePubkey(str) {
+  const raw = base58Decode(str);
+  if (raw.length === 32) return raw;
+  if (raw.length < 32) {
+    return Buffer.concat([Buffer.alloc(32 - raw.length), raw]);
+  }
+  return raw.subarray(raw.length - 32);
+}
+
+// ============= Compact-u16 Encoding =============
+// (Solana's variable-length integer format, from trading.js pattern)
+
+export function encodeCompactU16(value) {
+  if (value < 0x80) return Buffer.from([value]);
+  if (value < 0x4000) return Buffer.from([
+    (value & 0x7f) | 0x80,
+    (value >> 7) & 0x7f,
+  ]);
+  return Buffer.from([
+    (value & 0x7f) | 0x80,
+    ((value >> 7) & 0x7f) | 0x80,
+    (value >> 14) & 0x03,
+  ]);
+}
+
+// ============= PDA Derivation =============
+
+/**
+ * Derive Associated Token Account (ATA) address.
+ * PDA seeds: [owner, tokenProgram, mint] with ATA program.
+ */
+export function deriveATA(ownerBase58, mintBase58, tokenProgramBase58 = TOKEN_PROGRAM) {
+  const owner = base58DecodePubkey(ownerBase58);
+  const tokenProgram = base58DecodePubkey(tokenProgramBase58);
+  const mint = base58DecodePubkey(mintBase58);
+  const ataProgramKey = base58DecodePubkey(ATA_PROGRAM);
+
+  // find_program_address: try nonce 255 down to 0
+  // PDA = SHA256(seeds... || programId || "ProgramDerivedAddress")
+  // A valid PDA must NOT be on the ed25519 curve.
+  // Checking on-curve in pure JS without a full ed25519 implementation is hard.
+  // We use the mathematical approach: decode y-coordinate, compute x², check QR.
+  for (let nonce = 255; nonce >= 0; nonce--) {
+    const hash = crypto.createHash('sha256')
+      .update(Buffer.concat([owner, tokenProgram, mint, Buffer.from([nonce]), ataProgramKey, Buffer.from('ProgramDerivedAddress')]))
+      .digest();
+
+    if (!isOnCurve(hash)) {
+      return base58Encode(hash);
+    }
+  }
+  throw new Error('Could not derive ATA: no valid PDA found');
+}
+
+/**
+ * Check if a 32-byte buffer represents a valid ed25519 curve point.
+ * Ed25519 curve: -x² + y² = 1 + d*x²*y²  over GF(p) where p = 2^255 - 19
+ * 
+ * Decode y from the 32 bytes, compute x² = (y² - 1) / (d*y² + 1),
+ * then check if x² is a quadratic residue (QR) mod p.
+ */
+function isOnCurve(bytes) {
+  const p = (1n << 255n) - 19n;
+  const d = -121665n * modInverse(121666n, p) % p;
+
+  // Read y-coordinate (little-endian, clear top bit which is sign of x)
+  let y = 0n;
+  for (let i = 0; i < 32; i++) {
+    y |= BigInt(bytes[i]) << (BigInt(i) * 8n);
+  }
+  y &= (1n << 255n) - 1n; // Clear top bit
+
+  if (y >= p) return false;
+
+  // y² mod p
+  const y2 = modPow(y, 2n, p);
+  
+  // x² = (y² - 1) * inverse(d*y² + 1) mod p
+  const num = ((y2 - 1n) % p + p) % p;
+  const den = ((d * y2 + 1n) % p + p) % p;
+  const denInv = modInverse(den, p);
+  if (denInv === null) return false;
+  
+  const x2 = (num * denInv) % p;
+  
+  // Check if x² is a quadratic residue: x^((p-1)/2) == 1 mod p
+  if (x2 === 0n) return true;
+  const euler = modPow(x2, (p - 1n) / 2n, p);
+  return euler === 1n;
+}
+
+function modPow(base, exp, mod) {
+  let result = 1n;
+  base = ((base % mod) + mod) % mod;
+  while (exp > 0n) {
+    if (exp & 1n) result = (result * base) % mod;
+    exp >>= 1n;
+    base = (base * base) % mod;
+  }
+  return result;
+}
+
+function modInverse(a, mod) {
+  return modPow(((a % mod) + mod) % mod, mod - 2n, mod);
+}
+
+// ============= MessageV0 Builder =============
+
+/**
+ * Build a Solana MessageV0 from accounts and instructions.
+ * Simplified builder for x402 payment transactions.
+ */
+function buildMessageV0({ feePayer, instructions, recentBlockhash, accounts }) {
+  // All unique accounts in order: feePayer first, then signers, then rest
+  const accountMap = new Map();
+  const feePayerKey = feePayer;
+
+  // feePayer is always first, always writable + signer
+  accountMap.set(feePayerKey, { isSigner: true, isWritable: true });
+
+  // Collect all accounts from instructions
+  for (const ix of instructions) {
+    if (!accountMap.has(ix.programId)) {
+      accountMap.set(ix.programId, { isSigner: false, isWritable: false });
+    }
+    for (const acc of ix.accounts) {
+      const existing = accountMap.get(acc.pubkey);
+      if (existing) {
+        existing.isSigner = existing.isSigner || acc.isSigner;
+        existing.isWritable = existing.isWritable || acc.isWritable;
+      } else {
+        accountMap.set(acc.pubkey, { isSigner: acc.isSigner, isWritable: acc.isWritable });
+      }
+    }
+  }
+
+  // Sort: signers+writable, signers+readonly, non-signer+writable, non-signer+readonly
+  // feePayer always at index 0
+  const sortedKeys = [feePayerKey];
+  const rest = [...accountMap.entries()].filter(([k]) => k !== feePayerKey);
+
+  // Signer+writable
+  for (const [k, v] of rest) if (v.isSigner && v.isWritable) sortedKeys.push(k);
+  // Signer+readonly
+  for (const [k, v] of rest) if (v.isSigner && !v.isWritable) sortedKeys.push(k);
+  // Non-signer+writable
+  for (const [k, v] of rest) if (!v.isSigner && v.isWritable) sortedKeys.push(k);
+  // Non-signer+readonly
+  for (const [k, v] of rest) if (!v.isSigner && !v.isWritable) sortedKeys.push(k);
+
+  // Count header values
+  let numRequiredSignatures = 0;
+  let numReadonlySignedAccounts = 0;
+  let numReadonlyUnsignedAccounts = 0;
+
+  for (const key of sortedKeys) {
+    const meta = accountMap.get(key);
+    if (meta.isSigner) {
+      numRequiredSignatures++;
+      if (!meta.isWritable) numReadonlySignedAccounts++;
+    } else {
+      if (!meta.isWritable) numReadonlyUnsignedAccounts++;
+    }
+  }
+
+  // Build the account keys index
+  const keyIndex = new Map();
+  sortedKeys.forEach((k, i) => keyIndex.set(k, i));
+
+  // Compile instructions
+  const compiledInstructions = instructions.map(ix => {
+    const programIdIndex = keyIndex.get(ix.programId);
+    const accountIndices = ix.accounts.map(a => keyIndex.get(a.pubkey));
+    return { programIdIndex, accountIndices, data: ix.data };
+  });
+
+  // Serialize MessageV0
+  // Format: prefix(0x80) | header(3 bytes) | staticAccountKeys | recentBlockhash | instructions | addressTableLookups
+  const parts = [];
+
+  // Version prefix (0x80 = v0)
+  parts.push(Buffer.from([0x80]));
+
+  // Header: numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts
+  parts.push(Buffer.from([numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts]));
+
+  // Static account keys
+  parts.push(encodeCompactU16(sortedKeys.length));
+  for (const key of sortedKeys) {
+    parts.push(base58DecodePubkey(key));
+  }
+
+  // Recent blockhash (32 bytes)
+  parts.push(base58DecodePubkey(recentBlockhash));
+
+  // Instructions
+  parts.push(encodeCompactU16(compiledInstructions.length));
+  for (const ix of compiledInstructions) {
+    parts.push(Buffer.from([ix.programIdIndex]));
+    parts.push(encodeCompactU16(ix.accountIndices.length));
+    for (const idx of ix.accountIndices) {
+      parts.push(Buffer.from([idx]));
+    }
+    parts.push(encodeCompactU16(ix.data.length));
+    parts.push(ix.data);
+  }
+
+  // Address table lookups (empty for our use case)
+  parts.push(encodeCompactU16(0));
+
+  return Buffer.concat(parts);
+}
+
+// ============= Ed25519 Signing =============
+
+/**
+ * Sign a message with Ed25519 using a Solana keypair (64 bytes: seed + pubkey).
+ */
+function signEd25519(message, keypairHex) {
+  const seed = Buffer.from(keypairHex.slice(0, 64), 'hex'); // First 32 bytes
+  const keyObj = crypto.createPrivateKey({
+    key: Buffer.concat([
+      Buffer.from('302e020100300506032b657004220420', 'hex'), // PKCS8 Ed25519 prefix
+      seed,
+    ]),
+    format: 'der',
+    type: 'pkcs8',
+  });
+  return crypto.sign(null, message, keyObj);
+}
+
+// ============= x402 Solana Payment =============
+
+/**
+ * Build a Solana x402 payment transaction.
+ * 
+ * This builds an SPL TransferChecked instruction wrapped in a VersionedTransaction.
+ * The facilitator is the fee payer (index 0), client signs at index 1.
+ *
+ * NOTE: This requires a recent blockhash from Solana RPC. For the initial implementation,
+ * we fetch it inline. In production, this should be cached.
+ *
+ * @param {object} requirements - Parsed PaymentRequirements from 402 response
+ * @param {string} keypairHex - 128-char hex string (64 bytes: seed + pubkey)
+ * @param {string} walletAddress - Signer's Solana address (base58)
+ * @param {string} resource - Original request URL
+ * @param {string} recentBlockhash - Recent blockhash from Solana RPC (base58)
+ * @param {number} decimals - Token decimals (default 6 for USDC)
+ * @param {string} tokenProgram - Token program address (auto-detect if not provided)
+ * @returns {string} Base64-encoded PaymentPayload for Payment-Signature header
+ */
+export function createSvmPaymentPayload(
+  requirements,
+  keypairHex,
+  walletAddress,
+  resource,
+  recentBlockhash,
+  decimals = 6,
+  tokenProgram = TOKEN_PROGRAM,
+) {
+  const extra = requirements.extra || {};
+  const feePayerStr = extra.feePayer;
+  if (!feePayerStr) {
+    throw new Error('feePayer is required in requirements.extra for SVM transactions');
+  }
+
+  const mint = requirements.asset;
+  const amount = BigInt(requirements.amount);
+  const payTo = requirements.pay_to || requirements.payTo;
+
+  // Derive ATAs
+  const sourceATA = deriveATA(walletAddress, mint, tokenProgram);
+  const destATA = deriveATA(payTo, mint, tokenProgram);
+
+  // Build instructions
+  // 1. SetComputeUnitLimit: [2, u32 LE]
+  const cuLimitData = Buffer.alloc(5);
+  cuLimitData[0] = 2;
+  cuLimitData.writeUInt32LE(DEFAULT_COMPUTE_UNIT_LIMIT, 1);
+
+  // 2. SetComputeUnitPrice: [3, u64 LE]
+  const cuPriceData = Buffer.alloc(9);
+  cuPriceData[0] = 3;
+  cuPriceData.writeBigUInt64LE(BigInt(DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS), 1);
+
+  // 3. TransferChecked: [12, u64 amount LE, u8 decimals]
+  const transferData = Buffer.alloc(10);
+  transferData[0] = 12;
+  transferData.writeBigUInt64LE(amount, 1);
+  transferData[9] = decimals;
+
+  // 4. Memo: random 16 bytes hex for nonce
+  const memoData = Buffer.from(crypto.randomBytes(16).toString('hex'));
+
+  const instructions = [
+    {
+      programId: COMPUTE_BUDGET_PROGRAM,
+      accounts: [],
+      data: cuLimitData,
+    },
+    {
+      programId: COMPUTE_BUDGET_PROGRAM,
+      accounts: [],
+      data: cuPriceData,
+    },
+    {
+      programId: tokenProgram,
+      accounts: [
+        { pubkey: sourceATA, isSigner: false, isWritable: true },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: destATA, isSigner: false, isWritable: true },
+        { pubkey: walletAddress, isSigner: true, isWritable: false },
+      ],
+      data: transferData,
+    },
+    {
+      programId: MEMO_PROGRAM,
+      accounts: [],
+      data: memoData,
+    },
+  ];
+
+  // Build MessageV0
+  const messageBytes = buildMessageV0({
+    feePayer: feePayerStr,
+    instructions,
+    recentBlockhash,
+    accounts: null,
+  });
+
+  // Sign: client signs the full message (with 0x80 version prefix already included)
+  const clientSignature = signEd25519(messageBytes, keypairHex);
+
+  // Build transaction: compact-u16(numSignatures) + signatures + message
+  // 2 signatures: [facilitator placeholder (64 zero bytes), client signature]
+  const numSigs = encodeCompactU16(2);
+  const facilitatorPlaceholder = Buffer.alloc(64); // all zeros
+  
+  const txBytes = Buffer.concat([
+    numSigs,
+    facilitatorPlaceholder,
+    clientSignature,
+    messageBytes,
+  ]);
+
+  const txBase64 = txBytes.toString('base64');
+
+  // Build x402 payload (camelCase per x402 spec)
+  const payload = {
+    x402Version: 2,
+    payload: { transaction: txBase64 },
+    accepted: requirements,
+  };
+
+  if (resource) {
+    payload.resource = { url: resource };
+  }
+
+  return Buffer.from(JSON.stringify(payload)).toString('base64');
+}
+
+/**
+ * Fetch recent blockhash from Solana RPC.
+ */
+export async function fetchRecentBlockhash(rpcUrl = 'https://api.mainnet-beta.solana.com') {
+  const response = await fetch(rpcUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getLatestBlockhash',
+      params: [{ commitment: 'finalized' }],
+    }),
+  });
+  const data = await response.json();
+  return data.result.value.blockhash;
+}
+
+/**
+ * Get RPC URL for a Solana network identifier.
+ */
+export function getSolanaRpcUrl(network) {
+  if (network.includes('devnet') || network === 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1') {
+    return 'https://api.devnet.solana.com';
+  }
+  if (network.includes('testnet') || network === 'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z') {
+    return 'https://api.testnet.solana.com';
+  }
+  return 'https://api.mainnet-beta.solana.com';
+}
+
+/**
+ * Check if a network string is a Solana network.
+ */
+export function isSvmNetwork(network) {
+  return typeof network === 'string' && network.startsWith('solana:');
+}