@blockrun/llm 0.1.1

package/dist/chunk-TYQEUMVI.mjs

@@ -0,0 +1,206 @@
+// src/x402.ts
+import { signTypedData } from "viem/accounts";
+var BASE_CHAIN_ID = 8453;
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var USDC_SOLANA = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var SOLANA_USDC_DECIMALS = 6;
+var DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+var DEFAULT_COMPUTE_UNIT_LIMIT = 8e3;
+var USDC_DOMAIN = {
+  name: "USD Coin",
+  version: "2",
+  chainId: BASE_CHAIN_ID,
+  verifyingContract: USDC_BASE
+};
+var TRANSFER_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function createNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+async function createPaymentPayload(privateKey, fromAddress, recipient, amount, network = "eip155:8453", options = {}) {
+  const now = Math.floor(Date.now() / 1e3);
+  const validAfter = now - 600;
+  const validBefore = now + (options.maxTimeoutSeconds || 300);
+  const nonce = createNonce();
+  const domain = USDC_DOMAIN;
+  const signature = await signTypedData({
+    privateKey,
+    domain,
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: fromAddress,
+      to: recipient,
+      value: BigInt(amount),
+      validAfter: BigInt(validAfter),
+      validBefore: BigInt(validBefore),
+      nonce
+    }
+  });
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: options.resourceUrl || "https://blockrun.ai/api/v1/chat/completions",
+      description: options.resourceDescription || "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network,
+      amount,
+      asset: USDC_BASE,
+      payTo: recipient,
+      maxTimeoutSeconds: options.maxTimeoutSeconds || 300,
+      extra: { name: "USD Coin", version: "2" }
+    },
+    payload: {
+      signature,
+      authorization: {
+        from: fromAddress,
+        to: recipient,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      }
+    },
+    extensions: options.extensions || {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
+async function createSolanaPaymentPayload(secretKey, fromAddress, recipient, amount, feePayer, options = {}) {
+  const { Connection, PublicKey, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } = await import("./index.esm-FLTVMT4C.mjs");
+  const { getAssociatedTokenAddress, createTransferCheckedInstruction, getMint } = await import("./esm-3BUZROFC.mjs");
+  const { Keypair } = await import("./index.esm-FLTVMT4C.mjs");
+  const rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
+  const connection = new Connection(rpcUrl);
+  const keypair = Keypair.fromSecretKey(secretKey);
+  const feePayerPubkey = new PublicKey(feePayer);
+  const ownerPubkey = keypair.publicKey;
+  const tokenMint = new PublicKey(USDC_SOLANA);
+  const payToPubkey = new PublicKey(recipient);
+  const mintInfo = await getMint(connection, tokenMint);
+  const sourceATA = await getAssociatedTokenAddress(tokenMint, ownerPubkey, false);
+  const destinationATA = await getAssociatedTokenAddress(tokenMint, payToPubkey, false);
+  const { blockhash } = await connection.getLatestBlockhash();
+  const setComputeUnitPriceIx = ComputeBudgetProgram.setComputeUnitPrice({
+    microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
+  });
+  const setComputeUnitLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
+    units: DEFAULT_COMPUTE_UNIT_LIMIT
+  });
+  const transferIx = createTransferCheckedInstruction(
+    sourceATA,
+    tokenMint,
+    destinationATA,
+    ownerPubkey,
+    BigInt(amount),
+    mintInfo.decimals
+  );
+  const messageV0 = new TransactionMessage({
+    payerKey: feePayerPubkey,
+    recentBlockhash: blockhash,
+    instructions: [setComputeUnitLimitIx, setComputeUnitPriceIx, transferIx]
+  }).compileToV0Message();
+  const transaction = new VersionedTransaction(messageV0);
+  transaction.sign([keypair]);
+  const serializedTx = Buffer.from(transaction.serialize()).toString("base64");
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: options.resourceUrl || "https://blockrun.ai/api/v1/chat/completions",
+      description: options.resourceDescription || "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network: SOLANA_NETWORK,
+      amount,
+      asset: USDC_SOLANA,
+      payTo: recipient,
+      maxTimeoutSeconds: options.maxTimeoutSeconds || 300,
+      extra: options.extra || { feePayer }
+    },
+    payload: {
+      transaction: serializedTx
+    },
+    extensions: options.extensions || {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
+function parsePaymentRequired(headerValue) {
+  try {
+    const decoded = atob(headerValue);
+    const parsed = JSON.parse(decoded);
+    if (!parsed.accepts || !Array.isArray(parsed.accepts)) {
+      throw new Error("Invalid payment required structure: missing or invalid 'accepts' field");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("Invalid payment required structure")) {
+        throw error;
+      }
+      throw new Error("Failed to parse payment required header: invalid format");
+    }
+    throw new Error("Failed to parse payment required header");
+  }
+}
+function extractPaymentDetails(paymentRequired, preferredNetwork) {
+  const accepts = paymentRequired.accepts || [];
+  if (accepts.length === 0) {
+    throw new Error("No payment options in payment required response");
+  }
+  let option = null;
+  if (preferredNetwork) {
+    option = accepts.find((opt) => opt.network === preferredNetwork) || null;
+  }
+  if (!option) {
+    option = accepts[0];
+  }
+  const amount = option.amount || option.maxAmountRequired;
+  if (!amount) {
+    throw new Error("No amount found in payment requirements");
+  }
+  return {
+    amount,
+    recipient: option.payTo,
+    network: option.network,
+    asset: option.asset,
+    scheme: option.scheme,
+    maxTimeoutSeconds: option.maxTimeoutSeconds || 300,
+    extra: option.extra,
+    resource: paymentRequired.resource
+  };
+}
+function isSolanaNetwork(network) {
+  return network.startsWith("solana:");
+}
+function getAvailableNetworks(paymentRequired) {
+  return paymentRequired.accepts.map((opt) => opt.network).filter((network) => Boolean(network));
+}
+
+export {
+  BASE_CHAIN_ID,
+  USDC_BASE,
+  SOLANA_NETWORK,
+  USDC_SOLANA,
+  SOLANA_USDC_DECIMALS,
+  createPaymentPayload,
+  createSolanaPaymentPayload,
+  parsePaymentRequired,
+  extractPaymentDetails,
+  isSolanaNetwork,
+  getAvailableNetworks
+};