@circuit-llm/wallet 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Circuit LLM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# @circuit-llm/wallet
+
+> A Solana wallet for the Circuit network: SOL + CIRC (Token-2022) balances, transfers, and Jupiter swaps — and the concrete `PaymentWallet` that powers x402.
+
+Part of the **[Circuit SDK](https://github.com/Circuit-LLM/circuit-sdk)**. [Packages →](https://github.com/Circuit-LLM/circuit-sdk/blob/main/docs/packages.md)
+
+## Install
+
+```bash
+npm install @circuit-llm/wallet
+```
+
+## Usage
+
+```ts
+import { makeWallet, keypairFromSecret } from '@circuit-llm/wallet';
+
+const wallet = makeWallet();                                  // from CIRCUIT_WALLET
+// const wallet = makeWallet({ keypair: keypairFromSecret(secret) });
+
+await wallet.solBalance();
+await wallet.circBalance();
+await wallet.sendCirc(recipient, 1_000_000n);                 // (to, amountRaw) — base units, 6 decimals
+await wallet.swap(inputMint, outputMint, amount);            // (inMint, outMint, amount) via Jupiter
+```
+
+> Swaps use Jupiter's free endpoint, which rate-limits hard (`429`). For real usage, pass a Jupiter API key — `makeWallet({ jupiterApiKey })` or the `JUPITER_API_KEY` env var — to use the keyed host.
+
+Implements `@circuit-llm/x402`'s `PaymentWallet`, so it drops straight into `Inference` / `Data`. Multi-RPC failover is built in; an underfunded send surfaces as a typed **`InsufficientFundsError`** (which token, and the shortfall) instead of an opaque chain error, and the wallet warns once if it's on the rate-limited default public RPC — pass `rpcUrl` (or set `CIRCUIT_RPC_URL`) to override. Also exports `generateKeypair`, `loadKeypairFromEnv`, `isValidAddress`, and `walletTradeExecutor` (self-custody trading for agents).

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+import { Keypair, Connection } from '@solana/web3.js';
+import { CircuitConfig } from '@circuit-llm/core';
+import { PaymentWallet } from '@circuit-llm/x402';
+
+/** Parse a secret key from base58, a JSON byte-array string, an array, or raw bytes. */
+declare function keypairFromSecret(input: string | number[] | Uint8Array): Keypair;
+/** Load the signing keypair from the CIRCUIT_WALLET env var; null if unset. */
+declare function loadKeypairFromEnv(env?: NodeJS.ProcessEnv): Keypair | null;
+declare function generateKeypair(): Keypair;
+declare const secretKeyBase58: (kp: Keypair) => string;
+declare function isValidAddress(s: string): boolean;
+
+/** The fetch shape the wallet uses — injectable for tests, defaults to the global `fetch`. */
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface WalletOptions {
+    keypair?: Keypair | null;
+    /** Read-only mode: watch this address (no signing). */
+    address?: string;
+    config?: CircuitConfig;
+    /** Inject a connection (for tests / custom RPC); else built from rpcUrl/config. */
+    connection?: Connection;
+    /** Inject a list of connections to fail over across (tests / advanced); else [primary, ...fallbacks]. */
+    connections?: Connection[];
+    rpcUrl?: string;
+    /** Jupiter API key for swaps — lifts the free tier's rate limit. Falls back to `JUPITER_API_KEY`. */
+    jupiterApiKey?: string;
+    /** Override the Jupiter swap base URL (else the keyed host when a key is set, else the free `lite-api`). */
+    jupiterBaseUrl?: string;
+    /** Inject a `fetch` implementation (tests / custom transport); else the global `fetch`. */
+    fetchImpl?: FetchLike;
+}
+declare class Wallet implements PaymentWallet {
+    readonly keypair: Keypair | null;
+    readonly connection: Connection;
+    private readonly connections;
+    readonly address: string | null;
+    readonly readOnly: boolean;
+    private readonly circMint;
+    private readonly tokenProgram;
+    private readonly decimals;
+    private readonly pubkey;
+    private readonly jupiterBase;
+    private readonly jupiterKey;
+    private readonly fetchImpl;
+    constructor(opts?: WalletOptions);
+    solBalance(): Promise<number | null>;
+    circBalance(): Promise<number>;
+    /** PaymentWallet.sendCirc — transfer CIRC (Token-2022). amountRaw = base units. */
+    sendCirc(toAddress: string, amountRaw: bigint): Promise<string>;
+    sendSol(toAddress: string, sol: number): Promise<string>;
+    /** Jupiter quote (read-only). amount = base units of inputMint. */
+    swapQuote(inputMint: string, outputMint: string, amount: bigint | number, slippageBps?: number): Promise<unknown>;
+    /** Jupiter request headers — adds `x-api-key` when a key is configured. */
+    private jupHeaders;
+    /** Execute a swap via Jupiter (sign + send the returned versioned tx). */
+    swap(inputMint: string, outputMint: string, amount: bigint | number, slippageBps?: number): Promise<{
+        sig: string;
+        quote: unknown;
+    }>;
+    private sendSigned;
+    private withRpc;
+    private classifyFundsError;
+    private circBalanceRawStrict;
+    private solLamports;
+    private requireKeypair;
+}
+/** Build a Wallet, loading the keypair from CIRCUIT_WALLET when none is given. */
+declare function makeWallet(opts?: WalletOptions): Wallet;
+
+/** The buy/sell shape LocalKeypairCustody hands the executor — a structural subset of @circuit-llm/agent's `Intent`. */
+interface TradeIntent {
+    kind: 'buy' | 'sell';
+    /** Token mint to trade. */
+    token?: string;
+    /** SOL notional for a buy (also the accounted `solValue`). */
+    sizeSol?: number;
+    /** Token base units for a live sell. */
+    amount?: number;
+    maxSlippageBps?: number;
+}
+interface WalletTradeResult {
+    signature: string;
+    solValue?: number;
+}
+interface WalletExecutor {
+    execute(intent: TradeIntent): Promise<WalletTradeResult>;
+}
+/**
+ * Build a self-custody executor from a keyed {@link Wallet}. `buy` swaps SOL → token for `sizeSol`;
+ * `sell` swaps `amount` (token base units) → SOL. It signs + sends with the wallet's own keypair, so
+ * it is only appropriate on hardware you control. Plug it in with
+ * `new LocalKeypairCustody({ executor: walletTradeExecutor(wallet), paper: false })`.
+ */
+declare function walletTradeExecutor(wallet: Wallet): WalletExecutor;
+
+/**
+ * Thrown when a transfer fails because the wallet is underfunded — instead of the opaque Solana
+ * transaction error the RPC returns. `haveRaw`/`needRaw` are base units (CIRC: 6 decimals; SOL: lamports).
+ */
+declare class InsufficientFundsError extends Error {
+    readonly token: 'CIRC' | 'SOL';
+    readonly haveRaw: bigint;
+    readonly needRaw: bigint;
+    constructor(token: 'CIRC' | 'SOL', haveRaw: bigint, needRaw: bigint);
+}
+
+export { type FetchLike, InsufficientFundsError, type TradeIntent, Wallet, type WalletExecutor, type WalletOptions, type WalletTradeResult, generateKeypair, isValidAddress, keypairFromSecret, loadKeypairFromEnv, makeWallet, secretKeyBase58, walletTradeExecutor };

package/dist/index.js

@@ -0,0 +1,328 @@
+// src/keypair.ts
+import { Keypair, PublicKey } from "@solana/web3.js";
+import bs58 from "bs58";
+function keypairFromSecret(input) {
+  if (input instanceof Uint8Array) return Keypair.fromSecretKey(input);
+  if (Array.isArray(input)) return Keypair.fromSecretKey(Uint8Array.from(input));
+  const s = String(input).trim();
+  if (s.startsWith("[")) return Keypair.fromSecretKey(Uint8Array.from(JSON.parse(s)));
+  return Keypair.fromSecretKey(bs58.decode(s));
+}
+function loadKeypairFromEnv(env = process.env) {
+  const v = env.CIRCUIT_WALLET;
+  if (!v) return null;
+  try {
+    return keypairFromSecret(v.trim());
+  } catch {
+    throw new Error("CIRCUIT_WALLET is set but is not a valid base58/array secret key");
+  }
+}
+function generateKeypair() {
+  return Keypair.generate();
+}
+var secretKeyBase58 = (kp) => bs58.encode(kp.secretKey);
+function isValidAddress(s) {
+  try {
+    new PublicKey(s);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/wallet.ts
+import {
+  Connection,
+  PublicKey as PublicKey2,
+  LAMPORTS_PER_SOL,
+  Transaction,
+  SystemProgram,
+  VersionedTransaction
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddressSync,
+  createTransferCheckedInstruction,
+  createAssociatedTokenAccountIdempotentInstruction
+} from "@solana/spl-token";
+import { DEFAULT_CONFIG as DEFAULT_CONFIG2 } from "@circuit-llm/core";
+
+// src/errors.ts
+var DECIMALS = { CIRC: 6, SOL: 9 };
+function formatAmount(raw, decimals) {
+  const negative = raw < 0n;
+  const abs = negative ? -raw : raw;
+  const base = 10n ** BigInt(decimals);
+  const whole = abs / base;
+  const frac = abs % base;
+  let out = whole.toString();
+  if (frac > 0n) out += `.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+  return negative ? `-${out}` : out;
+}
+var InsufficientFundsError = class extends Error {
+  token;
+  haveRaw;
+  needRaw;
+  constructor(token, haveRaw, needRaw) {
+    const d = DECIMALS[token];
+    super(
+      `Insufficient ${token}: have ${formatAmount(haveRaw, d)}, need ${formatAmount(needRaw, d)} ${token}. Fund the wallet and retry.`
+    );
+    this.name = "InsufficientFundsError";
+    this.token = token;
+    this.haveRaw = haveRaw;
+    this.needRaw = needRaw;
+  }
+};
+
+// src/rpc-warning.ts
+import { DEFAULT_CONFIG } from "@circuit-llm/core";
+function usesDefaultPublicRpc(opts) {
+  if (opts.connection || opts.connections || opts.rpcUrl) return false;
+  return (opts.config?.rpcUrl ?? DEFAULT_CONFIG.rpcUrl) === DEFAULT_CONFIG.rpcUrl;
+}
+var warned = false;
+function warnIfDefaultPublicRpc(opts) {
+  if (warned) return;
+  if (!usesDefaultPublicRpc(opts)) return;
+  if (process.env.CIRCUIT_SUPPRESS_RPC_WARNING === "1") return;
+  warned = true;
+  console.warn(
+    "[circuit-sdk] Using the public Solana RPC (api.mainnet-beta.solana.com), which rate-limits \u2014 calls and payments may fail under load. Set your own with makeWallet({ rpcUrl }) or the CIRCUIT_RPC_URL env var. Silence this with CIRCUIT_SUPPRESS_RPC_WARNING=1."
+  );
+}
+
+// src/wallet.ts
+var JUP_LITE = "https://lite-api.jup.ag/swap/v1";
+var JUP_PRO = "https://api.jup.ag/swap/v1";
+var FALLBACK_RPCS = ["https://api.mainnet-beta.solana.com", "https://rpc.ankr.com/solana"];
+var isRateLimited = (e) => /429|Too Many Requests|max usage|rate limit/i.test(e?.message ?? "");
+var BASE_FEE_LAMPORTS = 5000n;
+var isMissingAccount = (e) => /could not find account|account (does not exist|not found)|find account|no ata/i.test(
+  e?.message ?? ""
+);
+var Wallet = class {
+  keypair;
+  connection;
+  // the primary (back-compat); reads/sends fail over across `connections`
+  connections;
+  address;
+  readOnly;
+  circMint;
+  tokenProgram;
+  decimals;
+  pubkey;
+  jupiterBase;
+  jupiterKey;
+  fetchImpl;
+  constructor(opts = {}) {
+    const cfg = opts.config ?? DEFAULT_CONFIG2;
+    this.keypair = opts.keypair ?? null;
+    this.pubkey = this.keypair ? this.keypair.publicKey : opts.address ? new PublicKey2(opts.address) : null;
+    this.address = this.pubkey ? this.pubkey.toBase58() : null;
+    this.readOnly = !this.keypair;
+    const primary = opts.rpcUrl ?? cfg.rpcUrl;
+    const urls = [primary, ...FALLBACK_RPCS].filter((u, i, a) => !!u && a.indexOf(u) === i);
+    this.connections = opts.connections ?? (opts.connection ? [opts.connection] : urls.map((u) => new Connection(u, { commitment: "confirmed", disableRetryOnRateLimit: true })));
+    this.connection = this.connections[0];
+    this.circMint = new PublicKey2(cfg.circMint);
+    this.tokenProgram = new PublicKey2(cfg.circTokenProgram);
+    this.decimals = cfg.circDecimals;
+    this.jupiterKey = opts.jupiterApiKey ?? process.env.JUPITER_API_KEY ?? null;
+    this.jupiterBase = (opts.jupiterBaseUrl ?? (this.jupiterKey ? JUP_PRO : JUP_LITE)).replace(/\/$/, "");
+    this.fetchImpl = opts.fetchImpl ?? ((input, init) => fetch(input, init));
+    warnIfDefaultPublicRpc(opts);
+  }
+  async solBalance() {
+    if (!this.pubkey) return null;
+    const pk = this.pubkey;
+    const lamports = await this.withRpc((c) => c.getBalance(pk, "confirmed"));
+    return lamports / LAMPORTS_PER_SOL;
+  }
+  async circBalance() {
+    if (!this.pubkey) return 0;
+    const ata = getAssociatedTokenAddressSync(this.circMint, this.pubkey, false, this.tokenProgram);
+    try {
+      const r = await this.withRpc((c) => c.getTokenAccountBalance(ata, "confirmed"));
+      return Number(r.value.amount) / 10 ** this.decimals;
+    } catch {
+      return 0;
+    }
+  }
+  /** PaymentWallet.sendCirc — transfer CIRC (Token-2022). amountRaw = base units. */
+  async sendCirc(toAddress, amountRaw) {
+    const kp = this.requireKeypair();
+    const to = new PublicKey2(toAddress);
+    const fromAta = getAssociatedTokenAddressSync(this.circMint, kp.publicKey, false, this.tokenProgram);
+    const toAta = getAssociatedTokenAddressSync(this.circMint, to, false, this.tokenProgram);
+    const tx = new Transaction().add(
+      createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, toAta, to, this.circMint, this.tokenProgram),
+      createTransferCheckedInstruction(fromAta, this.circMint, toAta, kp.publicKey, amountRaw, this.decimals, [], this.tokenProgram)
+    );
+    try {
+      return await this.sendSigned(tx, kp);
+    } catch (err) {
+      throw await this.classifyFundsError({ circRaw: amountRaw }) ?? err;
+    }
+  }
+  async sendSol(toAddress, sol) {
+    const kp = this.requireKeypair();
+    const lamports = Math.round(sol * LAMPORTS_PER_SOL);
+    const tx = new Transaction().add(
+      SystemProgram.transfer({ fromPubkey: kp.publicKey, toPubkey: new PublicKey2(toAddress), lamports })
+    );
+    try {
+      return await this.sendSigned(tx, kp);
+    } catch (err) {
+      throw await this.classifyFundsError({ solLamports: BigInt(lamports) + BASE_FEE_LAMPORTS }) ?? err;
+    }
+  }
+  /** Jupiter quote (read-only). amount = base units of inputMint. */
+  async swapQuote(inputMint, outputMint, amount, slippageBps = 100) {
+    const u = `${this.jupiterBase}/quote?inputMint=${inputMint}&outputMint=${outputMint}&amount=${amount}&slippageBps=${slippageBps}&restrictIntermediateTokens=true`;
+    const resp = await this.fetchImpl(u, { headers: this.jupHeaders(), signal: AbortSignal.timeout(12e3) });
+    if (!resp.ok) throw new Error(`Jupiter quote ${resp.status}`);
+    return resp.json();
+  }
+  /** Jupiter request headers — adds `x-api-key` when a key is configured. */
+  jupHeaders(extra) {
+    return { ...this.jupiterKey ? { "x-api-key": this.jupiterKey } : {}, ...extra };
+  }
+  /** Execute a swap via Jupiter (sign + send the returned versioned tx). */
+  async swap(inputMint, outputMint, amount, slippageBps = 100) {
+    const kp = this.requireKeypair();
+    const quote = await this.swapQuote(inputMint, outputMint, amount, slippageBps);
+    const swapResp = await this.fetchImpl(`${this.jupiterBase}/swap`, {
+      method: "POST",
+      headers: this.jupHeaders({ "Content-Type": "application/json" }),
+      body: JSON.stringify({
+        quoteResponse: quote,
+        userPublicKey: this.address,
+        wrapAndUnwrapSol: true,
+        dynamicComputeUnitLimit: true
+      }),
+      signal: AbortSignal.timeout(2e4)
+    });
+    if (!swapResp.ok) throw new Error(`Jupiter swap ${swapResp.status}`);
+    const { swapTransaction } = await swapResp.json();
+    const tx = VersionedTransaction.deserialize(Buffer.from(swapTransaction, "base64"));
+    tx.sign([kp]);
+    const sig = await this.withRpc(async (c) => {
+      const s = await c.sendRawTransaction(tx.serialize(), { maxRetries: 3 });
+      await c.confirmTransaction(s, "confirmed");
+      return s;
+    });
+    return { sig, quote };
+  }
+  // Sign a legacy Transaction ONCE against a fresh blockhash, then broadcast the fixed-signature bytes.
+  // Critical for failover: because the signature is fixed, a retry on another RPC re-broadcasts the SAME
+  // transaction (Solana dedups by signature) — it can never produce a second, differently-signed tx. If
+  // we instead handed an unsigned tx to sendAndConfirmTransaction inside withRpc, each RPC would fetch a
+  // new blockhash and re-sign → two transactions could land (a double-spend).
+  async sendSigned(tx, kp) {
+    const { blockhash } = await this.withRpc((c) => c.getLatestBlockhash("confirmed"));
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = kp.publicKey;
+    tx.sign(kp);
+    const raw = tx.serialize();
+    return this.withRpc(async (c) => {
+      const sig = await c.sendRawTransaction(raw, { maxRetries: 3 });
+      await c.confirmTransaction(sig, "confirmed");
+      return sig;
+    });
+  }
+  // Try each RPC in turn; advance to the next on a rate-limit error OR a per-try timeout (a capped RPC
+  // sometimes hangs rather than throwing). A real (non-rate-limit) error propagates immediately.
+  async withRpc(fn, perTryMs = 25e3) {
+    let last;
+    for (const conn of this.connections) {
+      try {
+        return await Promise.race([
+          fn(conn),
+          new Promise((_, reject) => {
+            setTimeout(() => reject(Object.assign(new Error("rpc timeout"), { _timeout: true })), perTryMs).unref();
+          })
+        ]);
+      } catch (e) {
+        last = e;
+        if (!isRateLimited(e) && !e?._timeout) throw e;
+      }
+    }
+    throw last;
+  }
+  // After a send fails, read balances to see whether it was actually a funds problem — and if so, say so
+  // clearly. Returns an InsufficientFundsError to throw, or null to let the original send error propagate.
+  // A probe that itself fails returns null, so a real error is never masked by a misattributed message.
+  async classifyFundsError(need) {
+    try {
+      if (need.circRaw != null) {
+        const have = await this.circBalanceRawStrict();
+        if (have < need.circRaw) return new InsufficientFundsError("CIRC", have, need.circRaw);
+      }
+      const solNeed = need.solLamports ?? BASE_FEE_LAMPORTS;
+      const haveSol = await this.solLamports();
+      if (haveSol < solNeed) return new InsufficientFundsError("SOL", haveSol, solNeed);
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // Raw CIRC balance in base units. 0 for a genuinely-missing ATA; a real RPC failure is re-thrown.
+  async circBalanceRawStrict() {
+    if (!this.pubkey) return 0n;
+    const ata = getAssociatedTokenAddressSync(this.circMint, this.pubkey, false, this.tokenProgram);
+    try {
+      const r = await this.withRpc((c) => c.getTokenAccountBalance(ata, "confirmed"));
+      return BigInt(r.value.amount);
+    } catch (e) {
+      if (isMissingAccount(e)) return 0n;
+      throw e;
+    }
+  }
+  // Raw SOL balance in lamports.
+  async solLamports() {
+    if (!this.pubkey) return 0n;
+    const pk = this.pubkey;
+    return BigInt(await this.withRpc((c) => c.getBalance(pk, "confirmed")));
+  }
+  requireKeypair() {
+    if (!this.keypair) throw new Error("No wallet loaded \u2014 pass a keypair or set CIRCUIT_WALLET");
+    return this.keypair;
+  }
+};
+function makeWallet(opts = {}) {
+  return new Wallet({ ...opts, keypair: opts.keypair ?? loadKeypairFromEnv() });
+}
+
+// src/executor.ts
+import { SOL_MINT } from "@circuit-llm/core";
+var LAMPORTS_PER_SOL2 = 1e9;
+function walletTradeExecutor(wallet) {
+  return {
+    async execute(intent) {
+      if (!intent.token) throw new Error("trade intent is missing a token mint");
+      const slippageBps = intent.maxSlippageBps;
+      if (intent.kind === "buy") {
+        const sol = intent.sizeSol;
+        if (!(typeof sol === "number" && sol > 0)) throw new Error("buy intent is missing a positive sizeSol");
+        const lamports = BigInt(Math.round(sol * LAMPORTS_PER_SOL2));
+        const { sig: sig2 } = await wallet.swap(SOL_MINT, intent.token, lamports, slippageBps);
+        return { signature: sig2, solValue: sol };
+      }
+      const amount = intent.amount;
+      if (!(typeof amount === "number" && amount > 0)) throw new Error("sell intent is missing a positive amount (token base units)");
+      const { sig } = await wallet.swap(intent.token, SOL_MINT, amount, slippageBps);
+      return { signature: sig };
+    }
+  };
+}
+export {
+  InsufficientFundsError,
+  Wallet,
+  generateKeypair,
+  isValidAddress,
+  keypairFromSecret,
+  loadKeypairFromEnv,
+  makeWallet,
+  secretKeyBase58,
+  walletTradeExecutor
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@circuit-llm/wallet",
+  "version": "0.2.1",
+  "description": "Circuit SDK wallet — SOL/CIRC balances, transfers, and Jupiter swaps. Implements @circuit-llm/x402's PaymentWallet.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "test": "node --experimental-strip-types --conditions=development --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json",
+    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist",
+    "prepack": "tsup src/index.ts --format esm --dts --clean --out-dir dist"
+  },
+  "dependencies": {
+    "@circuit-llm/core": "0.2.1",
+    "@circuit-llm/x402": "0.2.1",
+    "@solana/web3.js": "^1.98.0",
+    "@solana/spl-token": "^0.4.14",
+    "bs58": "^6.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Circuit-LLM/circuit-sdk.git",
+    "directory": "packages/wallet"
+  },
+  "homepage": "https://github.com/Circuit-LLM/circuit-sdk/tree/main/packages/wallet#readme",
+  "bugs": {
+    "url": "https://github.com/Circuit-LLM/circuit-sdk/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}