@joai/warps-adapter-solana 1.0.0-beta.23

package/dist/index.mjs

@@ -0,0 +1,2305 @@
+// src/chains/solana.ts
+import { WarpChainName as WarpChainName5 } from "@joai/warps";
+
+// src/WarpSolanaDataLoader.ts
+import {
+  CacheTtl,
+  getProviderConfig,
+  getWarpChainAssetLogoUrl,
+  WarpCache,
+  WarpCacheKey
+} from "@joai/warps";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getMint } from "@solana/spl-token";
+
+// src/constants.ts
+var WarpSolanaConstants = {
+  ComputeUnitLimit: {
+    Default: 2e5,
+    Transfer: 5e3,
+    TokenTransfer: 1e4,
+    ContractCall: 2e5
+  },
+  PriorityFee: {
+    Default: 1e3
+  },
+  Validation: {
+    MinComputeUnits: 1e3,
+    MaxComputeUnits: 14e5
+  },
+  Programs: {
+    TokenProgram: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+    SystemProgram: "11111111111111111111111111111111"
+  },
+  NativeToken: {
+    Identifier: "SOL",
+    Decimals: 9
+  }
+};
+var SolanaExplorers = /* @__PURE__ */ ((SolanaExplorers2) => {
+  SolanaExplorers2["Solscan"] = "solscan";
+  SolanaExplorers2["SolscanMainnet"] = "solscan_mainnet";
+  SolanaExplorers2["SolscanDevnet"] = "solscan_devnet";
+  SolanaExplorers2["SolanaExplorer"] = "solana_explorer";
+  SolanaExplorers2["SolanaExplorerMainnet"] = "solana_explorer_mainnet";
+  SolanaExplorers2["SolanaExplorerDevnet"] = "solana_explorer_devnet";
+  return SolanaExplorers2;
+})(SolanaExplorers || {});
+var SolanaExplorerMap = {
+  solana: {
+    mainnet: ["solscan_mainnet" /* SolscanMainnet */, "solana_explorer_mainnet" /* SolanaExplorerMainnet */],
+    testnet: ["solscan" /* Solscan */, "solana_explorer" /* SolanaExplorer */],
+    devnet: ["solscan_devnet" /* SolscanDevnet */, "solana_explorer_devnet" /* SolanaExplorerDevnet */]
+  }
+};
+var ExplorerUrls = {
+  ["solscan" /* Solscan */]: "https://solscan.io",
+  ["solscan_mainnet" /* SolscanMainnet */]: "https://solscan.io",
+  ["solscan_devnet" /* SolscanDevnet */]: "https://solscan.io",
+  ["solana_explorer" /* SolanaExplorer */]: "https://explorer.solana.com",
+  ["solana_explorer_mainnet" /* SolanaExplorerMainnet */]: "https://explorer.solana.com",
+  ["solana_explorer_devnet" /* SolanaExplorerDevnet */]: "https://explorer.solana.com"
+};
+var SolanaExplorerNames = {
+  mainnet: ["solscan_mainnet" /* SolscanMainnet */, "solana_explorer_mainnet" /* SolanaExplorerMainnet */],
+  testnet: ["solscan" /* Solscan */, "solana_explorer" /* SolanaExplorer */],
+  devnet: ["solscan_devnet" /* SolscanDevnet */, "solana_explorer_devnet" /* SolanaExplorerDevnet */]
+};
+var SolanaExplorerUrls = ExplorerUrls;
+var X402SolanaNetworkIdentifiers = {
+  Mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  Devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+};
+var SupportedX402SolanaNetworks = [X402SolanaNetworkIdentifiers.Mainnet, X402SolanaNetworkIdentifiers.Devnet];
+
+// src/tokens.ts
+import { WarpChainName as WarpChainName4 } from "@joai/warps";
+
+// src/tokens/solana-mainnet.ts
+import { WarpChainName } from "@joai/warps";
+var SolanaChain = WarpChainName.Solana;
+var SolanaMainnetTokens = [
+  {
+    chain: SolanaChain,
+    identifier: "SOL",
+    name: "SOL",
+    symbol: "SOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "So11111111111111111111111111111111111111112",
+    name: "Wrapped SOL",
+    symbol: "WSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh",
+    name: "Wrapped Bitcoin",
+    symbol: "WBTC",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs",
+    name: "Ethereum (Wormhole)",
+    symbol: "ETH",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj",
+    name: "Orca",
+    symbol: "ORCA",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/17547/small/orca.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So",
+    name: "Marinade SOL",
+    symbol: "mSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/17752/small/mSOL.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn",
+    name: "JitoSOL",
+    symbol: "JitoSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/30168/small/jitosol.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "bSo13r4TkiE4KumL71LsHTPpL2suBYJxqsd4P6Bwv11",
+    name: "bSOL",
+    symbol: "bSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/30167/small/bsol.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "7kbnvuGBxxj8AG9qp8Scn56muWGaRaFqxg1FsRp3PaFT",
+    name: "UXD Stablecoin",
+    symbol: "UXD",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/25342/small/uxd.png"
+  },
+  {
+    chain: SolanaChain,
+    identifier: "A9mUU4qviSctJVPJdBJWkb28deg915LYJKrzQ19ji3FM",
+    name: "USD Coin (Wormhole)",
+    symbol: "USDCet",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  }
+];
+
+// src/tokens/solana-devnet.ts
+import { WarpChainName as WarpChainName2 } from "@joai/warps";
+var SolanaChain2 = WarpChainName2.Solana;
+var SolanaDevnetTokens = [
+  {
+    chain: SolanaChain2,
+    identifier: "SOL",
+    name: "SOL",
+    symbol: "SOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  },
+  {
+    chain: SolanaChain2,
+    identifier: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: SolanaChain2,
+    identifier: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: SolanaChain2,
+    identifier: "So11111111111111111111111111111111111111112",
+    name: "Wrapped SOL",
+    symbol: "WSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  }
+];
+
+// src/tokens/solana-testnet.ts
+import { WarpChainName as WarpChainName3 } from "@joai/warps";
+var SolanaChain3 = WarpChainName3.Solana;
+var SolanaTestnetTokens = [
+  {
+    chain: SolanaChain3,
+    identifier: "SOL",
+    name: "SOL",
+    symbol: "SOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  },
+  {
+    chain: SolanaChain3,
+    identifier: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: SolanaChain3,
+    identifier: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: SolanaChain3,
+    identifier: "So11111111111111111111111111111111111111112",
+    name: "Wrapped SOL",
+    symbol: "WSOL",
+    decimals: 9,
+    logoUrl: "https://assets.coingecko.com/coins/images/4128/small/solana.png"
+  }
+];
+
+// src/tokens.ts
+var KnownTokens = {
+  [WarpChainName4.Solana]: {
+    mainnet: SolanaMainnetTokens,
+    testnet: SolanaTestnetTokens,
+    devnet: SolanaDevnetTokens
+  }
+};
+var findKnownTokenById = (chain, env, id) => {
+  const chainTokens = KnownTokens[chain]?.[env] || [];
+  return chainTokens.find((token) => token.identifier === id) || null;
+};
+var getKnownTokensForChain = (chainName, env) => {
+  return KnownTokens[chainName]?.[env] || [];
+};
+
+// src/WarpSolanaDataLoader.ts
+var WarpSolanaDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const providerConfig = getProviderConfig(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new Connection(providerConfig.url, "confirmed");
+    this.cache = new WarpCache(config.env, config.cache);
+  }
+  async getAccount(address) {
+    try {
+      const publicKey = new PublicKey(address);
+      const balance = await this.connection.getBalance(publicKey);
+      return {
+        chain: this.chain.name,
+        address,
+        balance: BigInt(balance)
+      };
+    } catch (error) {
+      throw new Error(`Failed to get account: ${error}`);
+    }
+  }
+  async getAccountAssets(address) {
+    try {
+      const account = await this.getAccount(address);
+      const tokenBalances = await this.getTokenBalances(address);
+      let assets = account.balance > 0n ? [{ ...this.chain.nativeToken, amount: account.balance }] : [];
+      for (const tokenBalance of tokenBalances) {
+        if (tokenBalance.balance > 0n) {
+          assets.push({
+            chain: this.chain.name,
+            identifier: tokenBalance.tokenAddress,
+            name: tokenBalance.metadata.name,
+            symbol: tokenBalance.metadata.symbol,
+            amount: tokenBalance.balance,
+            decimals: tokenBalance.metadata.decimals,
+            logoUrl: tokenBalance.metadata.logoUrl || ""
+          });
+        }
+      }
+      return assets;
+    } catch (error) {
+      return [];
+    }
+  }
+  async getAsset(identifier) {
+    try {
+      if (identifier === this.chain.nativeToken.identifier || identifier === "SOL") {
+        return this.chain.nativeToken;
+      }
+      const cacheKey = WarpCacheKey.Asset(this.config.env, this.chain.name, identifier);
+      const cachedAsset = this.cache.get(cacheKey);
+      if (cachedAsset) {
+        return cachedAsset;
+      }
+      const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
+      const knownToken = findKnownTokenById(this.chain.name, env, identifier);
+      if (knownToken) {
+        return {
+          chain: this.chain.name,
+          identifier,
+          name: knownToken.name,
+          symbol: knownToken.symbol,
+          amount: 0n,
+          decimals: knownToken.decimals,
+          logoUrl: knownToken.logoUrl
+        };
+      }
+      const metadata = await this.getTokenMetadata(identifier);
+      const asset = {
+        chain: this.chain.name,
+        identifier,
+        name: metadata.name,
+        symbol: metadata.symbol,
+        amount: 0n,
+        decimals: metadata.decimals,
+        logoUrl: metadata.logoUrl
+      };
+      this.cache.set(cacheKey, asset, CacheTtl.OneHour);
+      return asset;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    const signature = identifier;
+    if (awaitCompleted) {
+      const tx = await this.waitForTransaction(signature);
+      if (!tx) {
+        return this.createFailedAction(signature, "Transaction not found after waiting for completion");
+      }
+      return this.parseTransactionToAction(tx, signature);
+    }
+    try {
+      const tx = await this.connection.getTransaction(signature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) return null;
+      return this.parseTransactionToAction(tx, signature);
+    } catch {
+      return null;
+    }
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getTokenBalances(address) {
+    try {
+      const publicKey = new PublicKey(address);
+      const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(publicKey, {
+        programId: new PublicKey(WarpSolanaConstants.Programs.TokenProgram)
+      });
+      const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
+      const knownTokens = getKnownTokensForChain(this.chain.name, env);
+      const balances = await Promise.all(
+        tokenAccounts.value.map(async (tokenAccount) => {
+          const mintAddress = tokenAccount.account.data.parsed.info.mint;
+          const balance = BigInt(tokenAccount.account.data.parsed.info.tokenAmount.amount);
+          const decimals = tokenAccount.account.data.parsed.info.tokenAmount.decimals;
+          const knownToken = knownTokens.find((token) => token.identifier === mintAddress);
+          if (knownToken) {
+            return {
+              tokenAddress: mintAddress,
+              balance,
+              metadata: {
+                name: knownToken.name,
+                symbol: knownToken.symbol,
+                decimals: knownToken.decimals,
+                logoUrl: getWarpChainAssetLogoUrl(knownToken, this.config) || ""
+              }
+            };
+          }
+          const metadata = await this.getTokenMetadata(mintAddress);
+          return {
+            tokenAddress: mintAddress,
+            balance,
+            metadata: {
+              name: metadata.name,
+              symbol: metadata.symbol,
+              decimals: metadata.decimals || decimals,
+              logoUrl: metadata.logoUrl
+            }
+          };
+        })
+      );
+      return balances.filter((b) => b.balance > 0n);
+    } catch (error) {
+      return [];
+    }
+  }
+  async getTokenMetadata(tokenAddress) {
+    try {
+      const mintPublicKey = new PublicKey(tokenAddress);
+      const mintInfo = await getMint(this.connection, mintPublicKey);
+      return {
+        name: "Unknown Token",
+        symbol: "UNKNOWN",
+        decimals: mintInfo.decimals,
+        logoUrl: ""
+      };
+    } catch (error) {
+      return {
+        name: "Unknown Token",
+        symbol: "UNKNOWN",
+        decimals: WarpSolanaConstants.NativeToken.Decimals,
+        logoUrl: ""
+      };
+    }
+  }
+  async waitForTransaction(signature) {
+    const maxWaitTime = 3e5;
+    const startTime = Date.now();
+    let delay = 1e3;
+    let lastError = null;
+    let attempts = 0;
+    while (Date.now() - startTime < maxWaitTime) {
+      attempts++;
+      try {
+        const tx = await this.tryFetchTransaction(signature);
+        if (tx) return tx;
+      } catch (err) {
+        lastError = err;
+      }
+      if (Date.now() - startTime < maxWaitTime) {
+        delay = this.calculateBackoffDelay(delay, attempts, lastError);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    try {
+      return await this.connection.getTransaction(signature, { commitment: "confirmed", maxSupportedTransactionVersion: 0 });
+    } catch {
+      return null;
+    }
+  }
+  async tryFetchTransaction(signature) {
+    try {
+      const confirmation = await Promise.race([
+        this.connection.confirmTransaction(signature, "finalized"),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 6e4))
+      ]);
+      if (confirmation) {
+        const tx = await this.connection.getTransaction(signature, { commitment: "finalized", maxSupportedTransactionVersion: 0 });
+        if (tx) return tx;
+      }
+    } catch {
+    }
+    try {
+      const tx = await this.connection.getTransaction(signature, { commitment: "finalized", maxSupportedTransactionVersion: 0 });
+      if (tx) return tx;
+    } catch {
+    }
+    try {
+      return await this.connection.getTransaction(signature, { commitment: "confirmed", maxSupportedTransactionVersion: 0 });
+    } catch {
+      return null;
+    }
+  }
+  calculateBackoffDelay(currentDelay, attempts, lastError) {
+    if (lastError?.message?.includes("429") || lastError?.message?.includes("rate limit")) {
+      return Math.min(currentDelay * 2, 3e4);
+    }
+    if (attempts % 10 === 0) {
+      return 2e3;
+    }
+    return Math.min(currentDelay * 1.1, 15e3);
+  }
+  createFailedAction(signature, error) {
+    return {
+      chain: this.chain.name,
+      id: signature,
+      receiver: "",
+      sender: "",
+      value: 0n,
+      function: "",
+      status: "failed",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error,
+      tx: {
+        signature,
+        slot: 0,
+        blockTime: null,
+        err: { message: error }
+      }
+    };
+  }
+  parseTransactionToAction(tx, signature) {
+    const slot = tx.slot;
+    const blockTime = tx.blockTime ? new Date(tx.blockTime * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+    const accountKeys = this.extractAccountKeys(tx.transaction.message);
+    const sender = accountKeys[0]?.toBase58() || "";
+    const receiver = accountKeys.length > 1 ? accountKeys[1]?.toBase58() || "" : "";
+    const value = this.calculateTransactionValue(tx.meta);
+    const status = tx.meta?.err ? "failed" : "success";
+    const functionName = this.determineFunctionName(tx.transaction.message);
+    return {
+      chain: this.chain.name,
+      id: signature,
+      receiver,
+      sender,
+      value,
+      function: functionName,
+      status,
+      createdAt: blockTime,
+      error: tx.meta?.err ? JSON.stringify(tx.meta.err) : null,
+      tx: {
+        signature,
+        slot,
+        blockTime,
+        err: tx.meta?.err || null
+      }
+    };
+  }
+  extractAccountKeys(message) {
+    if ("staticAccountKeys" in message) {
+      return message.staticAccountKeys || [];
+    }
+    try {
+      const allKeys = message.getAccountKeys?.();
+      if (allKeys) {
+        return allKeys.keySegments().flat() || [];
+      }
+    } catch {
+    }
+    return [];
+  }
+  calculateTransactionValue(meta) {
+    const preBalances = meta?.preBalances || [];
+    const postBalances = meta?.postBalances || [];
+    if (preBalances.length === 0 || postBalances.length === 0) return 0n;
+    return BigInt(Math.abs(postBalances[0] - preBalances[0]));
+  }
+  determineFunctionName(message) {
+    let compiledInstructions = [];
+    if ("compiledInstructions" in message && Array.isArray(message.compiledInstructions)) {
+      compiledInstructions = message.compiledInstructions;
+    }
+    if (compiledInstructions.length === 0) return "transfer";
+    return compiledInstructions[0]?.programIdIndex !== void 0 ? "contract_call" : "transfer";
+  }
+};
+
+// src/WarpSolanaExecutor.ts
+import { createAssociatedTokenAccountInstruction, createTransferInstruction, getAssociatedTokenAddress } from "@solana/spl-token";
+import { ComputeBudgetProgram, Connection as Connection3, MessageV0, PublicKey as PublicKey3, SystemProgram, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import {
+  applyOutputToMessages,
+  extractResolvedInputValues as extractResolvedInputValues2,
+  getNextInfo,
+  getProviderConfig as getProviderConfig3,
+  getWarpActionByIndex,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2
+} from "@joai/warps";
+
+// src/WarpSolanaOutput.ts
+import {
+  evaluateOutputCommon,
+  extractResolvedInputValues,
+  getProviderConfig as getProviderConfig2,
+  getWarpWalletAddressFromConfig,
+  parseOutputOutIndex,
+  WarpConstants as WarpConstants2,
+  WarpCache as WarpCache2,
+  WarpCacheKey as WarpCacheKey2
+} from "@joai/warps";
+import { Connection as Connection2 } from "@solana/web3.js";
+
+// src/WarpSolanaSerializer.ts
+import {
+  WarpConstants,
+  WarpSerializer
+} from "@joai/warps";
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import bs58 from "bs58";
+var WarpSolanaSerializer = class {
+  constructor() {
+    this.coreSerializer = new WarpSerializer();
+  }
+  typedToString(value) {
+    if (value && typeof value === "object" && "toBase58" in value && typeof value.toBase58 === "function") {
+      return `address:${value.toBase58()}`;
+    }
+    if (typeof value === "string") {
+      if (value.length >= 32 && value.length <= 44) {
+        try {
+          const pubkey = new PublicKey2(value);
+          if (pubkey.toBase58() === value && /^[1-9A-HJ-NP-Za-km-z]+$/.test(value)) {
+            return `address:${value}`;
+          }
+        } catch {
+        }
+      }
+      if (value.startsWith("0x") || /^[0-9a-fA-F]+$/.test(value)) {
+        return `hex:${value}`;
+      }
+      return `string:${value}`;
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        if (value >= 0 && value <= 255) return `uint8:${value}`;
+        if (value >= 0 && value <= 65535) return `uint16:${value}`;
+        if (value >= 0 && value <= 4294967295) return `uint32:${value}`;
+        return `uint64:${value}`;
+      }
+      return `string:${value}`;
+    }
+    if (typeof value === "bigint") {
+      return `biguint:${value.toString()}`;
+    }
+    if (typeof value === "boolean") {
+      return `boolean:${value}`;
+    }
+    if (value instanceof PublicKey2) {
+      return `address:${value.toBase58()}`;
+    }
+    if (value instanceof Uint8Array) {
+      return `hex:${bs58.encode(value)}`;
+    }
+    if (typeof value === "object" && value !== null && "identifier" in value && "amount" in value) {
+      const asset = value;
+      if (asset.decimals !== void 0) {
+        return `asset:${asset.identifier}${WarpConstants.ArgCompositeSeparator}${asset.amount.toString()}${WarpConstants.ArgCompositeSeparator}${asset.decimals}`;
+      }
+      return `asset:${asset.identifier}${WarpConstants.ArgCompositeSeparator}${asset.amount.toString()}`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) return `list:string:`;
+      const types = value.map((item) => this.typedToString(item).split(WarpConstants.ArgParamsSeparator)[0]);
+      const type = types[0];
+      const values = value.map((item) => this.typedToString(item).split(WarpConstants.ArgParamsSeparator)[1]);
+      return `list:${type}:${values.join(",")}`;
+    }
+    if (value === null || value === void 0) {
+      return `string:null`;
+    }
+    return `string:${String(value)}`;
+  }
+  typedToNative(value) {
+    const stringValue = this.typedToString(value);
+    const [type, ...valueParts] = stringValue.split(WarpConstants.ArgParamsSeparator);
+    const nativeValue = valueParts.join(WarpConstants.ArgParamsSeparator);
+    return [type, this.parseNativeValue(type, nativeValue)];
+  }
+  nativeToTyped(type, value) {
+    switch (type) {
+      case "string":
+        return String(value);
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+        return BigInt(value);
+      case "biguint":
+        return BigInt(value);
+      case "boolean":
+        return Boolean(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
+      case "asset":
+        if (typeof value === "object" && value !== null && "identifier" in value && "amount" in value) {
+          return value;
+        }
+        return value;
+      default:
+        if (type.startsWith("list:")) {
+          const [, itemType, itemsStr] = type.split(":");
+          if (!itemsStr) return [];
+          const items = itemsStr.split(",");
+          return items.map((item) => this.nativeToTyped(itemType, item));
+        }
+        return String(value);
+    }
+  }
+  nativeToType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        return "bigint";
+      case "boolean":
+        return "boolean";
+      case "address":
+        return "string";
+      case "hex":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  stringToTyped(value) {
+    const parts = value.split(WarpConstants.ArgParamsSeparator, 2);
+    if (parts.length < 2) {
+      return value;
+    }
+    const [type, stringValue] = parts;
+    switch (type) {
+      case "string":
+        return stringValue;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+        return BigInt(stringValue);
+      case "biguint":
+        return BigInt(stringValue);
+      case "boolean":
+        return stringValue === "true";
+      case "address":
+        return stringValue;
+      case "hex":
+        return stringValue;
+      case "asset":
+        const assetParts = stringValue.split(WarpConstants.ArgCompositeSeparator);
+        const identifier = assetParts[0] || "";
+        const amount = assetParts[1] ? BigInt(assetParts[1]) : 0n;
+        const decimals = assetParts[2] ? parseInt(assetParts[2], 10) : void 0;
+        return { identifier, amount, decimals };
+      default:
+        if (type.startsWith("list:")) {
+          const [, itemType, itemsStr] = type.split(":");
+          if (!itemsStr) return [];
+          const items = itemsStr.split(",");
+          return items.map((item) => this.stringToTyped(`${itemType}:${item}`));
+        }
+        return stringValue;
+    }
+  }
+  parseNativeValue(type, value) {
+    switch (type) {
+      case "string":
+        return value;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        return BigInt(value);
+      case "boolean":
+        return value === "true";
+      case "address":
+        return value;
+      case "hex":
+        return value;
+      default:
+        return value;
+    }
+  }
+};
+
+// src/WarpSolanaOutput.ts
+var WarpSolanaOutput = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpSolanaSerializer();
+    const providerConfig = getProviderConfig2(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new Connection2(providerConfig.url, "confirmed");
+    this.cache = new WarpCache2(config.env, config.cache);
+  }
+  async getActionExecution(warp, actionIndex, tx) {
+    const inputs = this.cache.get(WarpCacheKey2.WarpExecutable(this.config.env, warp.meta?.hash || "", actionIndex)) ?? [];
+    const resolvedInputs = extractResolvedInputValues(inputs);
+    if (!tx) {
+      return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+    }
+    if ("status" in tx && typeof tx.status === "string") {
+      return this.handleWarpChainAction(warp, actionIndex, tx, resolvedInputs);
+    }
+    if (typeof tx === "string") {
+      return this.handleTransactionSignature(warp, actionIndex, tx, resolvedInputs);
+    }
+    return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+  }
+  createFailedExecution(warp, actionIndex, resolvedInputs = []) {
+    return {
+      status: "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig(this.config, this.chain.name),
+      txHash: "",
+      tx: null,
+      next: null,
+      values: { string: [], native: [], mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  async handleWarpChainAction(warp, actionIndex, tx, resolvedInputs = []) {
+    const isPending = tx.status === "pending";
+    const success = tx.status === "success";
+    const transactionHash = tx.id || tx.tx?.signature || "";
+    if (isPending) {
+      throw new Error(`Transaction ${transactionHash} is still pending. Execution should only proceed after finalization.`);
+    }
+    const slot = tx.tx?.slot || 0;
+    const blockTime = tx.tx?.blockTime || 0;
+    const rawValues = [transactionHash, slot.toString(), blockTime.toString()];
+    const stringValues = rawValues.map(String);
+    return {
+      status: success ? "success" : "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: { string: stringValues, native: rawValues, mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  async handleTransactionSignature(warp, actionIndex, signature, resolvedInputs = []) {
+    try {
+      const tx = await this.connection.getTransaction(signature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) {
+        return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+      }
+      const success = !tx.meta?.err;
+      const slot = tx.slot;
+      const blockTime = tx.blockTime || 0;
+      const fee = tx.meta?.fee || 0;
+      const rawValues = [signature, slot.toString(), blockTime.toString(), fee.toString()];
+      const stringValues = rawValues.map(String);
+      return {
+        status: success ? "success" : "error",
+        warp,
+        action: actionIndex,
+        user: getWarpWalletAddressFromConfig(this.config, this.chain.name),
+        txHash: signature,
+        tx: {
+          signature,
+          slot,
+          blockTime,
+          fee,
+          err: tx.meta?.err || null
+        },
+        next: null,
+        values: { string: stringValues, native: rawValues, mapped: {} },
+        output: {},
+        messages: {},
+        destination: null,
+        resolvedInputs
+      };
+    } catch (error) {
+      return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+    }
+  }
+  async extractQueryOutput(warp, typedValues, actionIndex, inputs) {
+    const stringValues = typedValues.map((t) => this.serializer.typedToString(t));
+    const nativeValues = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    const values = { string: stringValues, native: nativeValues, mapped: {} };
+    let output = {};
+    if (!warp.output) return { values, output };
+    const getNestedValue = (path) => {
+      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
+      if (indices.length === 0) return void 0;
+      let value = nativeValues[indices[0]];
+      for (let i = 1; i < indices.length; i++) {
+        if (value === void 0 || value === null) return void 0;
+        value = value[indices[i]];
+      }
+      return value;
+    };
+    for (const [key, path] of Object.entries(warp.output)) {
+      if (path.startsWith(WarpConstants2.Transform.Prefix)) continue;
+      const currentActionIndex = parseOutputOutIndex(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        output[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        output[key] = getNestedValue(path) || null;
+      } else {
+        output[key] = path;
+      }
+    }
+    return { values, output: await evaluateOutputCommon(warp, output, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
+  }
+  async getTransactionStatus(txHash) {
+    try {
+      const tx = await this.connection.getTransaction(txHash, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) {
+        return { status: "pending" };
+      }
+      return {
+        status: tx.meta?.err ? "failed" : "confirmed",
+        blockNumber: tx.slot,
+        gasUsed: BigInt(tx.meta?.fee || 0)
+      };
+    } catch (error) {
+      throw new Error(`Failed to get transaction status: ${error}`);
+    }
+  }
+  async getTransactionReceipt(txHash) {
+    try {
+      const tx = await this.connection.getTransaction(txHash, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) {
+        return null;
+      }
+      return {
+        signature: txHash,
+        slot: tx.slot,
+        blockTime: tx.blockTime,
+        fee: tx.meta?.fee || 0,
+        err: tx.meta?.err || null
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+};
+
+// src/WarpSolanaExecutor.ts
+var WarpSolanaExecutor = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpSolanaSerializer();
+    const providerConfig = getProviderConfig3(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new Connection3(providerConfig.url, "confirmed");
+    this.output = new WarpSolanaOutput(config, this.chain);
+  }
+  async createTransaction(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    let tx = null;
+    if (action.type === "transfer") {
+      tx = await this.createTransferTransaction(executable);
+    } else if (action.type === "contract") {
+      tx = await this.createContractCallTransaction(executable);
+    } else if (action.type === "query") {
+      throw new Error("WarpSolanaExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    } else if (action.type === "collect") {
+      throw new Error("WarpSolanaExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    }
+    if (!tx) throw new Error(`WarpSolanaExecutor: Invalid action type (${action.type})`);
+    return tx;
+  }
+  async createTransferTransaction(executable) {
+    const userWallet = getWarpWalletAddressFromConfig2(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpSolanaExecutor: createTransfer - user address not set");
+    if (!executable.destination) throw new Error("WarpSolanaExecutor: Destination address is required");
+    const destinationPubkey = this.toPublicKey(executable.destination, "Invalid destination address");
+    const fromPubkey = this.toPublicKey(userWallet, "Invalid user wallet address");
+    if (executable.transfers && executable.transfers.length > 0) {
+      return this.createTokenTransferTransaction(executable, userWallet, destinationPubkey);
+    }
+    const instructions = [];
+    if (executable.value > 0n) {
+      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
+    }
+    if (executable.data) {
+      const data = this.serializer.stringToTyped(executable.data);
+      if (data && typeof data === "string") {
+        const dataBuffer = Buffer.from(data, "base64");
+        instructions.push(
+          new TransactionInstruction({
+            keys: [
+              { pubkey: fromPubkey, isSigner: true, isWritable: true },
+              { pubkey: destinationPubkey, isSigner: false, isWritable: true }
+            ],
+            programId: destinationPubkey,
+            data: dataBuffer
+          })
+        );
+      }
+    }
+    return this.setTransactionDefaults(instructions, fromPubkey);
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = getWarpWalletAddressFromConfig2(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpSolanaExecutor: createContractCall - user address not set");
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) throw new Error("WarpSolanaExecutor: Contract action must have a function name");
+    if (!executable.destination) throw new Error("WarpSolanaExecutor: Contract address is required");
+    const programId = this.toPublicKey(executable.destination, "Invalid contract address");
+    const fromPubkey = this.toPublicKey(userWallet, "Invalid user wallet address");
+    const instructions = [];
+    const argsToUse = this.extractContractArgs(executable);
+    const nativeArgs = argsToUse.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+    const instructionData = this.buildInstructionData(action, nativeArgs);
+    const accounts = await this.buildInstructionAccounts(action, executable, fromPubkey, programId);
+    await this.ensureATAs(action, accounts, fromPubkey, instructions);
+    instructions.push(new TransactionInstruction({ keys: accounts, programId, data: instructionData }));
+    if (executable.value > 0n) {
+      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
+    }
+    return this.setTransactionDefaults(instructions, fromPubkey);
+  }
+  async ensureATAs(action, accounts, fromPubkey, instructions) {
+    if (!action.accounts || !Array.isArray(action.accounts)) return;
+    const createdATAs = /* @__PURE__ */ new Set();
+    for (let idx = 0; idx < action.accounts.length; idx++) {
+      const accountDef = action.accounts[idx];
+      const accountStr = typeof accountDef === "string" ? accountDef : JSON.stringify(accountDef);
+      if (accountStr.includes("{{USER_ATA:")) {
+        const match = accountStr.match(/USER_ATA[:\s]*([^"}\s]+)/);
+        if (match) {
+          const mintAddress = match[1];
+          try {
+            const mintPubkey = new PublicKey3(mintAddress);
+            const expectedAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
+            const ataKey = expectedAta.toBase58();
+            if (!createdATAs.has(ataKey)) {
+              createdATAs.add(ataKey);
+              const ataInfo = await this.connection.getAccountInfo(expectedAta);
+              if (!ataInfo) {
+                instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, expectedAta, fromPubkey, mintPubkey));
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (accountStr.includes("{{RECEIVER_ATA:")) {
+        const match = accountStr.match(/RECEIVER_ATA[:\s]*([^"}\s:]+)[:\s]*([^"}\s]+)/);
+        if (match) {
+          const mintAddress = match[1];
+          const receiverAddress = match[2];
+          try {
+            const mintPubkey = new PublicKey3(mintAddress);
+            const receiverPubkey = new PublicKey3(receiverAddress);
+            const expectedAta = await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
+            const ataKey = expectedAta.toBase58();
+            if (!createdATAs.has(ataKey)) {
+              createdATAs.add(ataKey);
+              const ataInfo = await this.connection.getAccountInfo(expectedAta);
+              if (!ataInfo) {
+                instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, expectedAta, receiverPubkey, mintPubkey));
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+    }
+  }
+  encodeInstructionData(instructionDef, args, funcName) {
+    try {
+      let discriminatorBuffer;
+      if (instructionDef.discriminator) {
+        if (Buffer.isBuffer(instructionDef.discriminator)) {
+          discriminatorBuffer = instructionDef.discriminator;
+        } else if (Array.isArray(instructionDef.discriminator)) {
+          discriminatorBuffer = Buffer.from(instructionDef.discriminator);
+        } else {
+          discriminatorBuffer = Buffer.from(funcName).slice(0, 8);
+        }
+      } else {
+        discriminatorBuffer = Buffer.from(funcName).slice(0, 8);
+      }
+      if (args.length > 0 && instructionDef.args && instructionDef.args.length > 0) {
+        const encodedArgs = this.encodeArgs(args, instructionDef.args);
+        return Buffer.concat([discriminatorBuffer, encodedArgs]);
+      }
+      return discriminatorBuffer;
+    } catch {
+      return this.encodeBasicInstructionData(args, funcName);
+    }
+  }
+  encodeBasicInstructionData(args, funcName) {
+    const funcHash = Buffer.from(funcName).slice(0, 8);
+    const data = Buffer.alloc(8);
+    data.set(funcHash, 0);
+    if (args.length > 0) {
+      const encodedArgs = args.map((arg) => {
+        if (typeof arg === "string") {
+          return Buffer.from(arg, "utf8");
+        } else if (typeof arg === "number" || typeof arg === "bigint") {
+          const num = typeof arg === "bigint" ? Number(arg) : arg;
+          const buf = Buffer.alloc(8);
+          buf.writeBigUInt64LE(BigInt(num), 0);
+          return buf;
+        } else if (Buffer.isBuffer(arg)) {
+          return arg;
+        } else if (arg instanceof Uint8Array) {
+          return Buffer.from(arg);
+        }
+        return Buffer.from(String(arg), "utf8");
+      });
+      return Buffer.concat([data, ...encodedArgs]);
+    }
+    return data;
+  }
+  encodeArgs(args, argDefs) {
+    const buffers = [];
+    for (let i = 0; i < Math.min(args.length, argDefs.length); i++) {
+      const arg = args[i];
+      const def = argDefs[i];
+      if (def.type === "u64" || def.type === "u128") {
+        const num = typeof arg === "bigint" ? arg : BigInt(arg);
+        const size = def.type === "u128" ? 16 : 8;
+        const buf = Buffer.alloc(size);
+        if (size === 16) {
+          buf.writeBigUInt64LE(num & 0xffffffffffffffffn, 0);
+          buf.writeBigUInt64LE(num >> 64n, 8);
+        } else {
+          buf.writeBigUInt64LE(num, 0);
+        }
+        buffers.push(buf);
+      } else if (def.type === "string") {
+        buffers.push(Buffer.from(String(arg), "utf8"));
+      } else if (def.type === "publicKey" || def.type === "pubkey") {
+        try {
+          const pubkey = new PublicKey3(arg);
+          buffers.push(Buffer.from(pubkey.toBuffer()));
+        } catch {
+          buffers.push(Buffer.from(String(arg), "utf8"));
+        }
+      } else {
+        buffers.push(Buffer.from(String(arg), "utf8"));
+      }
+    }
+    return Buffer.concat(buffers);
+  }
+  async buildInstructionAccounts(action, executable, fromPubkey, programId) {
+    const accounts = [];
+    const accountInputs = this.extractAccountInputs(action, executable);
+    if (accountInputs.length > 0) {
+      for (const accountInput of accountInputs) {
+        while (accounts.length < accountInput.index) {
+          accounts.push({ pubkey: fromPubkey, isSigner: true, isWritable: true });
+        }
+        const address = await this.resolveAccountFromInput(accountInput, executable, fromPubkey);
+        const { isSigner, isWritable } = this.determineAccountFlags(accountInput.input, address, fromPubkey);
+        accounts.push({ pubkey: address, isSigner, isWritable });
+      }
+      return accounts;
+    }
+    if (!action.accounts || !Array.isArray(action.accounts)) return accounts;
+    for (let idx = 0; idx < action.accounts.length; idx++) {
+      const accountDef = action.accounts[idx];
+      let address = this.extractAccountAddress(accountDef);
+      if (address === "[object Object]" || typeof accountDef === "string" && accountDef === "[object Object]") {
+        address = fromPubkey.toBase58();
+      } else if (!address || address.length === 0) {
+        throw new Error(`Invalid account definition at index ${idx}: ${JSON.stringify(accountDef)}`);
+      }
+      if (address === "{{USER_WALLET}}" || typeof address === "string" && address.includes("{{USER_WALLET}}")) {
+        address = fromPubkey.toBase58();
+      } else if (typeof address === "string" && address.includes("{{")) {
+        const originalAddress = address;
+        let maxIterations = 10;
+        while (address.includes("{{") && maxIterations-- > 0) {
+          const beforeInterpolation = address;
+          address = this.interpolateAccountAddress(address, executable.resolvedInputs);
+          if (address === beforeInterpolation) break;
+        }
+        if (!address || address.includes("{{") && !address.startsWith("{{USER_ATA:") && !address.startsWith("{{RECEIVER_ATA:")) {
+          throw new Error(`Failed to interpolate account address at index ${idx}: ${originalAddress} -> ${address}. ResolvedInputs: ${JSON.stringify(executable.resolvedInputs.map((r) => ({ as: r.input?.as, value: r.value })))}`);
+        }
+      }
+      const pubkey = await this.resolveAccountPubkey(address, fromPubkey);
+      const { isSigner, isWritable } = this.determineAccountFlags(accountDef, pubkey, fromPubkey);
+      accounts.push({ pubkey, isSigner, isWritable });
+    }
+    return accounts;
+  }
+  extractAccountInputs(action, executable) {
+    if (!action.inputs || !Array.isArray(action.inputs)) return [];
+    const accountInputs = [];
+    for (const input of action.inputs) {
+      if (input.position && typeof input.position === "string" && input.position.startsWith("account:")) {
+        const index = parseInt(input.position.split(":")[1] || "0", 10);
+        accountInputs.push({ input, index });
+      }
+    }
+    return accountInputs.sort((a, b) => a.index - b.index);
+  }
+  async resolveAccountFromInput(accountInput, executable, fromPubkey) {
+    const resolved = executable.resolvedInputs.find((r) => r.input === accountInput.input || r.input?.as === accountInput.input.as);
+    if (!resolved) {
+      throw new Error(`Account input at index ${accountInput.index} not resolved: ${accountInput.input.as || accountInput.input.name}`);
+    }
+    let address = resolved.value;
+    if (typeof address === "string" && address.includes(":")) {
+      address = address.split(":")[1];
+    }
+    if (!address || typeof address !== "string") {
+      throw new Error(`Invalid address for account input at index ${accountInput.index}: ${accountInput.input.as || accountInput.input.name}`);
+    }
+    if (accountInput.input.as === "USER_WALLET") {
+      return fromPubkey;
+    }
+    if (accountInput.input.as?.startsWith("USER_ATA:") || accountInput.input.as?.startsWith("RECEIVER_ATA:")) {
+      return await this.resolveAccountPubkey(`{{${accountInput.input.as}}}`, fromPubkey);
+    }
+    return new PublicKey3(address);
+  }
+  interpolateAccountAddress(address, resolvedInputs) {
+    if (!address.includes("{{")) return address;
+    for (const resolved of resolvedInputs) {
+      if (!resolved.input?.as) continue;
+      const placeholder = `{{${resolved.input.as.toUpperCase()}}}`;
+      if (address === placeholder || address.includes(placeholder)) {
+        let value = resolved.value;
+        if (typeof value === "string" && value.includes(":")) {
+          value = value.split(":")[1];
+        }
+        if (value) {
+          return address.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), String(value));
+        }
+      }
+    }
+    for (const resolved of resolvedInputs) {
+      if (!resolved.input?.name) continue;
+      const placeholder = `{{${resolved.input.name.toUpperCase().replace(/\s+/g, "_")}}}`;
+      if (address === placeholder || address.includes(placeholder)) {
+        let value = resolved.value;
+        if (typeof value === "string" && value.includes(":")) {
+          value = value.split(":")[1];
+        }
+        if (value) {
+          return address.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), String(value));
+        }
+      }
+    }
+    return address;
+  }
+  async createTokenTransferTransaction(executable, userWallet, destinationPubkey) {
+    if (executable.transfers.length === 0) throw new Error("WarpSolanaExecutor: No transfers provided");
+    if (!this.chain.nativeToken?.identifier) throw new Error("WarpSolanaExecutor: No native token defined for this chain");
+    const nativeId = this.chain.nativeToken.identifier;
+    const nativeTokenTransfers = executable.transfers.filter((t) => t.identifier === nativeId || t.identifier === WarpSolanaConstants.NativeToken.Identifier);
+    const splTokenTransfers = executable.transfers.filter((t) => t.identifier !== nativeId && t.identifier !== WarpSolanaConstants.NativeToken.Identifier);
+    if (nativeTokenTransfers.length === 1 && splTokenTransfers.length === 0) {
+      const transfer = nativeTokenTransfers[0];
+      if (transfer.amount <= 0n) throw new Error("WarpSolanaExecutor: Native token transfer amount must be positive");
+      const fromPubkey = new PublicKey3(userWallet);
+      return this.setTransactionDefaults([SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
+    }
+    if (nativeTokenTransfers.length === 0 && splTokenTransfers.length === 1) {
+      return this.createSingleTokenTransfer(executable, splTokenTransfers[0], userWallet, destinationPubkey);
+    }
+    if (executable.transfers.length > 1) throw new Error("WarpSolanaExecutor: Multiple token transfers not yet supported");
+    throw new Error("WarpSolanaExecutor: Invalid transfer configuration");
+  }
+  async createSingleTokenTransfer(executable, transfer, userWallet, destinationPubkey) {
+    const mintAddress = new PublicKey3(transfer.identifier);
+    const fromPubkey = new PublicKey3(userWallet);
+    const sourceTokenAccount = await getAssociatedTokenAddress(mintAddress, fromPubkey);
+    const destinationTokenAccount = await getAssociatedTokenAddress(mintAddress, destinationPubkey);
+    if (!await this.connection.getAccountInfo(sourceTokenAccount)) {
+      throw new Error("WarpSolanaExecutor: Source token account does not exist");
+    }
+    const instructions = [];
+    if (!await this.connection.getAccountInfo(destinationTokenAccount)) {
+      instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, destinationTokenAccount, destinationPubkey, mintAddress));
+    }
+    instructions.push(createTransferInstruction(sourceTokenAccount, destinationTokenAccount, fromPubkey, Number(transfer.amount)));
+    return this.setTransactionDefaults(instructions, fromPubkey);
+  }
+  async executeQuery(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type !== "query") throw new Error(`WarpSolanaExecutor: Invalid action type for executeQuery: ${action.type}`);
+    if (!action.func) throw new Error("WarpSolanaExecutor: Query action must have a function name");
+    if (!executable.destination) throw new Error("WarpSolanaExecutor: Query address is required");
+    const queryAddress = new PublicKey3(executable.destination);
+    const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+    let decodedResult = [];
+    let isSuccess = true;
+    if (action.func === "getAccount" || action.func === "getAccountInfo") {
+      const accountInfo = await this.connection.getAccountInfo(queryAddress);
+      if (!accountInfo) {
+        throw new Error("Account not found");
+      }
+      decodedResult = [
+        accountInfo.lamports,
+        accountInfo.owner.toBase58(),
+        accountInfo.executable,
+        accountInfo.rentEpoch,
+        accountInfo.data.toString("base64")
+      ];
+    } else if (action.func === "getBalance") {
+      const balance = await this.connection.getBalance(queryAddress);
+      decodedResult = [balance.toString()];
+    } else if (action.func === "getProgramAccounts") {
+      const accounts = await this.connection.getProgramAccounts(queryAddress);
+      decodedResult = accounts.map((acc) => ({
+        pubkey: acc.pubkey.toBase58(),
+        account: {
+          lamports: acc.account.lamports,
+          owner: acc.account.owner.toBase58(),
+          data: acc.account.data.toString("base64")
+        }
+      }));
+    } else {
+      const accountInfo = await this.connection.getAccountInfo(queryAddress);
+      if (!accountInfo) {
+        throw new Error("Account not found");
+      }
+      decodedResult = [accountInfo.data.toString("base64")];
+    }
+    const { values, output } = await this.output.extractQueryOutput(executable.warp, decodedResult, executable.action, executable.resolvedInputs);
+    const next = getNextInfo(this.config, [], executable.warp, executable.action, output);
+    const destinationInput = executable.resolvedInputs.find((i) => i.input.position === "receiver" || i.input.position === "destination");
+    const destination = destinationInput?.value || executable.destination;
+    const resolvedInputs = extractResolvedInputValues2(executable.resolvedInputs);
+    return {
+      status: isSuccess ? "success" : "error",
+      warp: executable.warp,
+      action: executable.action,
+      user: getWarpWalletAddressFromConfig2(this.config, executable.chain.name),
+      txHash: null,
+      tx: null,
+      next,
+      values,
+      output: { ...output, _DATA: decodedResult },
+      messages: applyOutputToMessages(executable.warp, output, this.config),
+      destination,
+      resolvedInputs
+    };
+  }
+  async verifyMessage(message, signature) {
+    try {
+      const messageBytes = new TextEncoder().encode(message);
+      const signatureBytes = Buffer.from(signature, "base64");
+      return "";
+    } catch (error) {
+      throw new Error(`Failed to verify message: ${error}`);
+    }
+  }
+  async setTransactionDefaults(instructions, fromPubkey) {
+    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+    const allInstructions = this.addComputeBudgetInstructions(instructions);
+    const accountMetaMap = this.buildAccountMetaMap(allInstructions, fromPubkey);
+    const { signedAccounts, unsignedAccounts } = this.sortAccounts(accountMetaMap);
+    const { staticAccountKeys, accountIndexMap } = this.buildAccountIndexMap(signedAccounts, unsignedAccounts);
+    const compiledInstructions = this.compileInstructions(allInstructions, accountIndexMap);
+    const messageV0 = this.buildMessageV0(blockhash, signedAccounts, unsignedAccounts, accountMetaMap, staticAccountKeys, compiledInstructions);
+    const versionedTx = new VersionedTransaction(messageV0);
+    if (versionedTx.version !== 0) {
+      throw new Error(`Expected VersionedTransaction v0, got version: ${versionedTx.version}`);
+    }
+    return versionedTx;
+  }
+  toPublicKey(address, errorMsg) {
+    try {
+      return new PublicKey3(address);
+    } catch {
+      throw new Error(`WarpSolanaExecutor: ${errorMsg}`);
+    }
+  }
+  extractContractArgs(executable) {
+    if (executable.args.length > 0) return executable.args;
+    if (executable.resolvedInputs.length === 0) return [];
+    const argInputs = executable.resolvedInputs.filter((ri) => ri.input.position?.toString().startsWith("arg:")).map((ri) => {
+      const index = Math.max(0, parseInt(ri.input.position.toString().split(":")[1] || "0", 10) - 1);
+      return { index, value: ri.value };
+    }).sort((a, b) => a.index - b.index);
+    const maxIndex = Math.max(...argInputs.map((a) => a.index), -1);
+    if (maxIndex < 0) return [];
+    const args = new Array(maxIndex + 1).fill(null);
+    argInputs.forEach(({ index, value }) => {
+      if (value) args[index] = value;
+    });
+    return args.filter((arg) => arg !== null && arg !== void 0);
+  }
+  buildInstructionData(action, nativeArgs) {
+    if (!action.abi || typeof action.abi !== "string") {
+      return this.encodeBasicInstructionData(nativeArgs, action.func);
+    }
+    try {
+      const abi = JSON.parse(action.abi);
+      if (abi.instructions && abi.instructions[action.func]) {
+        return this.encodeInstructionData(abi.instructions[action.func], nativeArgs, action.func);
+      }
+    } catch {
+    }
+    return this.encodeBasicInstructionData(nativeArgs, action.func);
+  }
+  extractAccountAddress(accountDef) {
+    if (typeof accountDef === "string") return accountDef;
+    if (!accountDef || typeof accountDef !== "object") return void 0;
+    const str = JSON.stringify(accountDef);
+    if (str.includes("USER_WALLET") || str.includes("{{USER_WALLET}}")) return "{{USER_WALLET}}";
+    if (str.includes("RECEIVER_ADDRESS") || str.includes("{{RECEIVER_ADDRESS}}")) return "{{RECEIVER_ADDRESS}}";
+    if (str.includes("USER_ATA")) {
+      const match = str.match(/USER_ATA[:\s]*([^"}\s]+)/);
+      if (match) return `{{USER_ATA:${match[1]}}}`;
+    }
+    const addrValue = accountDef.address || accountDef.pubkey || accountDef.value;
+    if (typeof addrValue === "string") return addrValue;
+    if (addrValue?.toBase58) return addrValue.toBase58();
+    if (addrValue?.identifier) return addrValue.identifier;
+    if (addrValue?.value) return addrValue.value;
+    const keys = Object.keys(accountDef);
+    if (keys.length === 1 && typeof accountDef[keys[0]] === "string") return accountDef[keys[0]];
+    return void 0;
+  }
+  async resolveAccountPubkey(address, fromPubkey) {
+    if (address.includes("{{USER_WALLET}}") || address === fromPubkey.toBase58()) {
+      return fromPubkey;
+    }
+    if (address.startsWith("{{USER_ATA:") && address.endsWith("}}")) {
+      const mintAddress = address.slice(11, -2);
+      if (!mintAddress || mintAddress.includes("{{")) {
+        throw new Error(`Invalid USER_ATA placeholder: ${address}. Mint address must be resolved first.`);
+      }
+      const mintPubkey = new PublicKey3(mintAddress);
+      return await getAssociatedTokenAddress(mintPubkey, fromPubkey);
+    }
+    if (address.startsWith("{{RECEIVER_ATA:") && address.endsWith("}}")) {
+      const content = address.slice(15, -2);
+      const parts = content.split(":");
+      if (parts.length === 2) {
+        let mintAddress = parts[0];
+        let receiverAddress = parts[1];
+        if (mintAddress.includes("{{") || receiverAddress.includes("{{")) {
+          throw new Error(`Invalid RECEIVER_ATA placeholder: ${address}. Mint and receiver addresses must be resolved first.`);
+        }
+        if (mintAddress.includes(":")) mintAddress = mintAddress.split(":")[1];
+        if (receiverAddress.includes(":")) receiverAddress = receiverAddress.split(":")[1];
+        const mintPubkey = new PublicKey3(mintAddress);
+        const receiverPubkey = new PublicKey3(receiverAddress);
+        return await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
+      }
+    }
+    return new PublicKey3(address);
+  }
+  determineAccountFlags(accountDef, pubkey, fromPubkey) {
+    const accountMeta = typeof accountDef === "object" ? accountDef : {};
+    if (pubkey.equals(fromPubkey)) {
+      return { isSigner: true, isWritable: true };
+    }
+    const isSigner = accountMeta.signer === true;
+    const isWritable = typeof accountDef === "object" && accountMeta.writable !== void 0 ? accountMeta.writable !== false : true;
+    return { isSigner, isWritable };
+  }
+  addComputeBudgetInstructions(instructions) {
+    const hasTokenTransfer = instructions.some((ix) => ix.programId.toBase58() === WarpSolanaConstants.Programs.TokenProgram);
+    const computeUnits = hasTokenTransfer ? WarpSolanaConstants.ComputeUnitLimit.TokenTransfer : WarpSolanaConstants.ComputeUnitLimit.Default;
+    const computeUnitLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits });
+    const computeUnitPriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: WarpSolanaConstants.PriorityFee.Default });
+    return [computeUnitLimitIx, computeUnitPriceIx, ...instructions];
+  }
+  buildAccountMetaMap(instructions, fromPubkey) {
+    const accountMetaMap = /* @__PURE__ */ new Map();
+    if (fromPubkey) {
+      accountMetaMap.set(fromPubkey.toBase58(), { pubkey: fromPubkey, isSigner: true, isWritable: true });
+    }
+    for (const ix of instructions) {
+      const programIdStr = ix.programId.toBase58();
+      if (!accountMetaMap.has(programIdStr)) {
+        accountMetaMap.set(programIdStr, { pubkey: ix.programId, isSigner: false, isWritable: false });
+      }
+      for (const key of ix.keys) {
+        const keyStr = key.pubkey.toBase58();
+        const existing = accountMetaMap.get(keyStr);
+        if (existing) {
+          accountMetaMap.set(keyStr, {
+            pubkey: key.pubkey,
+            isSigner: existing.isSigner || key.isSigner,
+            isWritable: existing.isWritable || key.isWritable
+          });
+        } else {
+          accountMetaMap.set(keyStr, {
+            pubkey: key.pubkey,
+            isSigner: key.isSigner,
+            isWritable: key.isWritable
+          });
+        }
+      }
+    }
+    return accountMetaMap;
+  }
+  sortAccounts(accountMetaMap) {
+    const signedAccounts = [];
+    const unsignedAccounts = [];
+    for (const meta of accountMetaMap.values()) {
+      ;
+      (meta.isSigner ? signedAccounts : unsignedAccounts).push(meta.pubkey);
+    }
+    const sortByWritable = (a, b) => (accountMetaMap.get(a.toBase58()).isWritable ? 0 : 1) - (accountMetaMap.get(b.toBase58()).isWritable ? 0 : 1);
+    signedAccounts.sort(sortByWritable);
+    unsignedAccounts.sort(sortByWritable);
+    return { signedAccounts, unsignedAccounts };
+  }
+  buildAccountIndexMap(signedAccounts, unsignedAccounts) {
+    const staticAccountKeys = [...signedAccounts, ...unsignedAccounts];
+    const accountIndexMap = /* @__PURE__ */ new Map();
+    staticAccountKeys.forEach((key, index) => {
+      accountIndexMap.set(key.toBase58(), index);
+    });
+    return { staticAccountKeys, accountIndexMap };
+  }
+  compileInstructions(instructions, accountIndexMap) {
+    return instructions.map((ix) => {
+      const programIdIndex = accountIndexMap.get(ix.programId.toBase58());
+      const accountKeyIndexes = ix.keys.map((key) => accountIndexMap.get(key.pubkey.toBase58()));
+      return {
+        programIdIndex,
+        accountKeyIndexes,
+        data: Uint8Array.from(ix.data)
+      };
+    });
+  }
+  buildMessageV0(blockhash, signedAccounts, unsignedAccounts, accountMetaMap, staticAccountKeys, compiledInstructions) {
+    const getWritable = (key) => accountMetaMap.get(key.toBase58()).isWritable;
+    return new MessageV0({
+      header: {
+        numRequiredSignatures: signedAccounts.length,
+        numReadonlySignedAccounts: signedAccounts.filter((k) => !getWritable(k)).length,
+        numReadonlyUnsignedAccounts: unsignedAccounts.filter((k) => !getWritable(k)).length
+      },
+      staticAccountKeys,
+      recentBlockhash: blockhash,
+      compiledInstructions,
+      addressTableLookups: []
+    });
+  }
+};
+
+// src/WarpSolanaExplorer.ts
+var WarpSolanaExplorer = class {
+  constructor(chain, config) {
+    this.chain = chain;
+    this.config = config;
+  }
+  getExplorers() {
+    const explorers = SolanaExplorerNames[this.config.env];
+    if (!explorers) {
+      return ["solscan_mainnet" /* SolscanMainnet */];
+    }
+    return explorers;
+  }
+  getPrimaryExplorer() {
+    const explorers = this.getExplorers();
+    return explorers[0];
+  }
+  getExplorerUrlByName(explorer) {
+    const userPreference = this.config.preferences?.explorers?.[this.chain.name];
+    if (userPreference && !explorer) {
+      const url2 = SolanaExplorerUrls[userPreference];
+      if (url2) return url2;
+    }
+    if (explorer) {
+      const url2 = SolanaExplorerUrls[explorer];
+      if (url2) return url2;
+    }
+    const primaryExplorer = this.getPrimaryExplorer();
+    const url = SolanaExplorerUrls[primaryExplorer];
+    return url || SolanaExplorerUrls[primaryExplorer];
+  }
+  getAccountUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    if (baseUrl.includes("?")) {
+      const cluster2 = this.config.env === "mainnet" ? "" : `&cluster=${this.config.env}`;
+      return `${baseUrl}/account/${address}${cluster2}`;
+    }
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/account/${address}${cluster}`;
+  }
+  getTransactionUrl(hash, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    if (baseUrl.includes("?")) {
+      const cluster2 = this.config.env === "mainnet" ? "" : `&cluster=${this.config.env}`;
+      return `${baseUrl}/tx/${hash}${cluster2}`;
+    }
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/tx/${hash}${cluster}`;
+  }
+  getBlockUrl(blockNumber, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    if (baseUrl.includes("?")) {
+      const cluster2 = this.config.env === "mainnet" ? "" : `&cluster=${this.config.env}`;
+      return `${baseUrl}/block/${blockNumber}${cluster2}`;
+    }
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/block/${blockNumber}${cluster}`;
+  }
+  getAssetUrl(identifier, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    if (baseUrl.includes("?")) {
+      const cluster2 = this.config.env === "mainnet" ? "" : `&cluster=${this.config.env}`;
+      return `${baseUrl}/token/${identifier}${cluster2}`;
+    }
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/token/${identifier}${cluster}`;
+  }
+  getContractUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    if (baseUrl.includes("?")) {
+      const cluster2 = this.config.env === "mainnet" ? "" : `&cluster=${this.config.env}`;
+      return `${baseUrl}/account/${address}${cluster2}`;
+    }
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/account/${address}${cluster}`;
+  }
+  getAllExplorers() {
+    return this.getExplorers();
+  }
+  getExplorerByName(name) {
+    const explorers = this.getExplorers();
+    return explorers.find((explorer) => explorer.toLowerCase() === name.toLowerCase());
+  }
+  getAccountUrls(address) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = SolanaExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/account/${address}${cluster}`;
+      }
+    });
+    return urls;
+  }
+  getTransactionUrls(hash) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = SolanaExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/tx/${hash}${cluster}`;
+      }
+    });
+    return urls;
+  }
+  getAssetUrls(identifier) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = SolanaExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/token/${identifier}${cluster}`;
+      }
+    });
+    return urls;
+  }
+  getContractUrls(address) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = SolanaExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/account/${address}${cluster}`;
+      }
+    });
+    return urls;
+  }
+  getBlockUrls(blockNumber) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = SolanaExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/block/${blockNumber}${cluster}`;
+      }
+    });
+    return urls;
+  }
+};
+
+// src/WarpSolanaWallet.ts
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { Connection as Connection4, Transaction as Transaction3, VersionedTransaction as VersionedTransaction4 } from "@solana/web3.js";
+import {
+  getProviderConfig as getProviderConfig4,
+  initializeWalletCache
+} from "@joai/warps";
+import { registerExactSvmScheme } from "@x402/svm/exact/client";
+
+// src/providers/MnemonicWalletProvider.ts
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { Keypair, Transaction, VersionedTransaction as VersionedTransaction2 } from "@solana/web3.js";
+import {
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3,
+  getWarpWalletMnemonicFromConfig,
+  getWarpWalletPrivateKeyFromConfig,
+  normalizeAndValidateMnemonic,
+  normalizeMnemonic,
+  setWarpWalletInConfig,
+  validateMnemonicLength
+} from "@joai/warps";
+import bs582 from "bs58";
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    if (address) return address;
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const keypair = this.getKeypair();
+    if (tx instanceof VersionedTransaction2) {
+      tx.sign([keypair]);
+      return tx;
+    }
+    if (tx instanceof Transaction) {
+      tx.sign(keypair);
+      return tx;
+    }
+    if (tx.transaction) {
+      if (tx.transaction instanceof Transaction) {
+        tx.transaction.sign(keypair);
+        return { ...tx, transaction: tx.transaction.serialize() };
+      }
+      if (typeof tx.transaction === "object") {
+        try {
+          const transaction = Transaction.from(tx.transaction);
+          transaction.sign(keypair);
+          return { ...tx, transaction: transaction.serialize(), signature: transaction.signature };
+        } catch {
+          throw new Error("Invalid transaction format");
+        }
+      }
+    }
+    throw new Error("Invalid transaction format");
+  }
+  async signMessage(message) {
+    const keypair = this.getKeypair();
+    const messageBytes = new TextEncoder().encode(message);
+    const nacl = await import("tweetnacl");
+    const secretKey = keypair.secretKey;
+    if (secretKey.length !== 64) {
+      throw new Error(`Invalid secret key length: expected 64, got ${secretKey.length}`);
+    }
+    const privateKeySlice = secretKey.slice(0, 32);
+    const privateKeyBytes = new Uint8Array(privateKeySlice);
+    if (privateKeyBytes.length !== 32) {
+      throw new Error(`Invalid private key length: expected 32, got ${privateKeyBytes.length}`);
+    }
+    const signature = nacl.sign.detached(messageBytes, privateKeyBytes);
+    return bs582.encode(signature);
+  }
+  getKeypairInstance() {
+    return this.getKeypair();
+  }
+  async importFromMnemonic(mnemonic) {
+    const trimmedMnemonic = normalizeAndValidateMnemonic(mnemonic);
+    const seed = bip39.mnemonicToSeedSync(trimmedMnemonic);
+    const keypair = Keypair.fromSeed(seed.slice(0, 32));
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs582.encode(keypair.secretKey),
+      mnemonic: trimmedMnemonic
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async importFromPrivateKey(privateKey) {
+    const keypair = Keypair.fromSecretKey(bs582.decode(privateKey));
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs582.encode(keypair.secretKey),
+      mnemonic: null
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const keypair = this.getKeypair();
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: privateKey || null,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const mnemonicRaw = bip39.generateMnemonic(wordlist, 256);
+    const mnemonic = normalizeMnemonic(mnemonicRaw);
+    validateMnemonicLength(mnemonic);
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const keypair = Keypair.fromSeed(seed.slice(0, 32));
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: null,
+      mnemonic
+    };
+  }
+  getKeypair() {
+    if (this.keypair) return this.keypair;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.keypair = Keypair.fromSeed(seed.slice(0, 32));
+    return this.keypair;
+  }
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/PrivateKeyWalletProvider.ts
+import { Keypair as Keypair2, Transaction as Transaction2, VersionedTransaction as VersionedTransaction3 } from "@solana/web3.js";
+import {
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig4,
+  getWarpWalletMnemonicFromConfig as getWarpWalletMnemonicFromConfig2,
+  getWarpWalletPrivateKeyFromConfig as getWarpWalletPrivateKeyFromConfig2,
+  setWarpWalletInConfig as setWarpWalletInConfig2
+} from "@joai/warps";
+import bs583 from "bs58";
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = getWarpWalletAddressFromConfig4(this.config, this.chain.name);
+    if (address) return address;
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const keypair = this.getKeypair();
+    if (tx instanceof VersionedTransaction3) {
+      tx.sign([keypair]);
+      return tx;
+    }
+    if (tx instanceof Transaction2) {
+      tx.sign(keypair);
+      return tx;
+    }
+    if (tx.transaction) {
+      if (tx.transaction instanceof Transaction2) {
+        tx.transaction.sign(keypair);
+        return { ...tx, transaction: tx.transaction.serialize() };
+      }
+      if (typeof tx.transaction === "object") {
+        try {
+          const transaction = Transaction2.from(tx.transaction);
+          transaction.sign(keypair);
+          return { ...tx, transaction: transaction.serialize(), signature: transaction.signature };
+        } catch {
+          throw new Error("Invalid transaction format");
+        }
+      }
+    }
+    throw new Error("Invalid transaction format");
+  }
+  async signMessage(message) {
+    const keypair = this.getKeypair();
+    const messageBytes = new TextEncoder().encode(message);
+    const nacl = await import("tweetnacl");
+    const secretKey = keypair.secretKey;
+    if (secretKey.length !== 64) {
+      throw new Error(`Invalid secret key length: expected 64, got ${secretKey.length}`);
+    }
+    const privateKeySlice = secretKey.slice(0, 32);
+    const privateKeyBytes = new Uint8Array(privateKeySlice);
+    if (privateKeyBytes.length !== 32) {
+      throw new Error(`Invalid private key length: expected 32, got ${privateKeyBytes.length}`);
+    }
+    const signature = nacl.sign.detached(messageBytes, privateKeyBytes);
+    return bs583.encode(signature);
+  }
+  getKeypairInstance() {
+    return this.getKeypair();
+  }
+  async importFromMnemonic(mnemonic) {
+    throw new Error("PrivateKeyWalletProvider does not support importing from mnemonics. Use MnemonicWalletProvider instead.");
+  }
+  async importFromPrivateKey(privateKey) {
+    const keypair = Keypair2.fromSecretKey(bs583.decode(privateKey));
+    const walletDetails = {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs583.encode(keypair.secretKey),
+      mnemonic: null
+    };
+    setWarpWalletInConfig2(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const keypair = this.getKeypair();
+    const privateKey = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    const mnemonic = getWarpWalletMnemonicFromConfig2(this.config, this.chain.name);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: privateKey || null,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const keypair = Keypair2.generate();
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs583.encode(keypair.secretKey),
+      mnemonic: null
+    };
+  }
+  getKeypair() {
+    if (this.keypair) return this.keypair;
+    const privateKey = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    if (!privateKey) throw new Error("No private key provided");
+    try {
+      const secretKey = bs583.decode(privateKey);
+      if (secretKey.length === 64) {
+        this.keypair = Keypair2.fromSecretKey(secretKey);
+        return this.keypair;
+      } else if (secretKey.length === 32) {
+        this.keypair = Keypair2.fromSeed(secretKey);
+        return this.keypair;
+      } else {
+        throw new Error(`Invalid private key length: expected 32 or 64 bytes, got ${secretKey.length}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Invalid private key format: ${error.message}`);
+      }
+      throw new Error("Invalid private key format");
+    }
+  }
+};
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
+
+// src/providers/ReadOnlyWalletProvider.ts
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig5 } from "@joai/warps";
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+  }
+  async getAddress() {
+    return getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+  }
+  async signTransaction(tx) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async signMessage(message) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromMnemonic(mnemonic) {
+    const address = getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromPrivateKey(privateKey) {
+    const address = getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async export() {
+    const address = getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async generate() {
+    const address = getWarpWalletAddressFromConfig5(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/WarpSolanaWallet.ts
+var WarpSolanaWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
+    this.connection = new Connection4(providerConfig.url, "confirmed");
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return this.walletProvider.signTransaction(tx);
+  }
+  async signTransactions(txs) {
+    return Promise.all(txs.map((tx) => this.signTransaction(tx)));
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    const transaction = this.resolveTransaction(tx);
+    if (!transaction.signatures || transaction.signatures.length === 0 || !transaction.signatures.some((sig) => sig.some((b) => b !== 0))) {
+      throw new Error("Transaction must be signed before sending");
+    }
+    try {
+      const shouldSkipPreflight = await this.shouldSkipPreflight(transaction);
+      return await this.sendWithRetry(transaction, shouldSkipPreflight);
+    } catch (simError) {
+      if (simError.message?.includes("MissingRequiredSignature")) {
+        return await this.sendRawTransaction(transaction, { skipPreflight: true });
+      }
+      throw new Error(`Transaction send failed: ${simError?.message || String(simError)}`);
+    }
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  async importFromMnemonic(mnemonic) {
+    const walletProvider = this.createProviderForOperation("mnemonic");
+    return await walletProvider.importFromMnemonic(mnemonic);
+  }
+  async importFromPrivateKey(privateKey) {
+    const walletProvider = this.createProviderForOperation("privateKey");
+    return await walletProvider.importFromPrivateKey(privateKey);
+  }
+  async export(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.export();
+  }
+  async generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  async registerX402Handlers(client) {
+    if (!this.walletProvider) return {};
+    const provider = this.walletProvider;
+    const getKeypair = provider.getKeypairInstance;
+    if (typeof getKeypair !== "function") return {};
+    const keypair = getKeypair();
+    if (!keypair || !keypair.secretKey) return {};
+    const signer = await createKeyPairSignerFromBytes(keypair.secretKey);
+    const handlers = {};
+    for (const network of SupportedX402SolanaNetworks) {
+      handlers[network] = () => {
+        registerExactSvmScheme(client, { signer });
+      };
+    }
+    return handlers;
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
+    }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
+  }
+  resolveTransaction(tx) {
+    if (tx instanceof VersionedTransaction4) {
+      if (tx.version === void 0 || tx.version === "legacy") {
+        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
+      }
+      return tx;
+    }
+    if (tx instanceof Transaction3) {
+      throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
+    }
+    if (tx.transaction instanceof VersionedTransaction4) {
+      if (tx.transaction.version === void 0 || tx.transaction.version === "legacy") {
+        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
+      }
+      return tx.transaction;
+    }
+    if (tx.transaction instanceof Transaction3) {
+      throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
+    }
+    if (!tx.transaction) {
+      throw new Error("Transaction must be signed before sending");
+    }
+    throw new Error("Invalid transaction format - only VersionedTransaction is supported");
+  }
+  async shouldSkipPreflight(transaction) {
+    if (!transaction.signatures || transaction.signatures.length === 0 || !transaction.signatures.some((sig) => sig.some((b) => b !== 0))) {
+      return false;
+    }
+    try {
+      const simulation = await this.connection.simulateTransaction(transaction, {
+        replaceRecentBlockhash: true,
+        sigVerify: false
+      });
+      if (simulation.value.err) {
+        const errMsg = JSON.stringify(simulation.value.err);
+        if (errMsg.includes('"Custom": 17') || errMsg.includes('"Custom":17') || errMsg.includes("0x11")) {
+          return true;
+        }
+        throw new Error(`Transaction simulation failed: ${errMsg}`);
+      }
+    } catch (error) {
+      if (error.message?.includes("Transaction simulation failed")) throw error;
+    }
+    return false;
+  }
+  async sendWithRetry(transaction, skipPreflight) {
+    if (skipPreflight) {
+      return this.sendRawTransaction(transaction, { skipPreflight: true });
+    }
+    try {
+      return await this.sendRawTransaction(transaction, { skipPreflight: false, preflightCommitment: "confirmed" });
+    } catch (error) {
+      if (this.isSimulationError(error)) {
+        return this.sendRawTransaction(transaction, { skipPreflight: true });
+      }
+      throw error;
+    }
+  }
+  async sendRawTransaction(transaction, options) {
+    const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
+      skipPreflight: options.skipPreflight,
+      maxRetries: options.maxRetries || 3,
+      preflightCommitment: options.preflightCommitment
+    });
+    if (!signature || typeof signature !== "string" || signature.length < 32) {
+      throw new Error("Invalid transaction signature received");
+    }
+    return signature;
+  }
+  isSimulationError(error) {
+    const msg = error?.message?.toLowerCase() || "";
+    return msg.includes("simulation") || msg.includes("preflight") || msg.includes("0x1") || msg.includes("custom program error");
+  }
+};
+
+// src/chains/common.ts
+var createSolanaAdapter = (chainName, chainInfos) => {
+  return (config, fallback) => {
+    if (!fallback) throw new Error(`${chainName} adapter requires a fallback adapter`);
+    return {
+      chainInfo: chainInfos[config.env],
+      builder: () => fallback.builder(),
+      executor: new WarpSolanaExecutor(config, chainInfos[config.env]),
+      output: new WarpSolanaOutput(config, chainInfos[config.env]),
+      serializer: new WarpSolanaSerializer(),
+      registry: fallback.registry,
+      explorer: new WarpSolanaExplorer(chainInfos[config.env], config),
+      abiBuilder: () => fallback.abiBuilder(),
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpSolanaDataLoader(config, chainInfos[config.env]),
+      wallet: new WarpSolanaWallet(config, chainInfos[config.env])
+    };
+  };
+};
+
+// src/chains/solana.ts
+var NativeTokenSol = {
+  chain: WarpChainName5.Solana,
+  identifier: "SOL",
+  symbol: "SOL",
+  name: "SOL",
+  decimals: 9,
+  logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/sol.svg"
+};
+var SolanaAdapter = createSolanaAdapter(WarpChainName5.Solana, {
+  mainnet: {
+    name: WarpChainName5.Solana,
+    displayName: "Solana Mainnet",
+    chainId: "101",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.mainnet-beta.solana.com",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/solana.svg",
+    nativeToken: NativeTokenSol
+  },
+  testnet: {
+    name: WarpChainName5.Solana,
+    displayName: "Solana Testnet",
+    chainId: "103",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.testnet.solana.com",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/solana.svg",
+    nativeToken: NativeTokenSol
+  },
+  devnet: {
+    name: WarpChainName5.Solana,
+    displayName: "Solana Devnet",
+    chainId: "103",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.devnet.solana.com",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/solana.svg",
+    nativeToken: NativeTokenSol
+  }
+});
+export {
+  ExplorerUrls,
+  KnownTokens,
+  NativeTokenSol,
+  SolanaAdapter,
+  SolanaExplorerMap,
+  SolanaExplorerNames,
+  SolanaExplorerUrls,
+  SolanaExplorers,
+  SupportedX402SolanaNetworks,
+  WarpSolanaConstants,
+  WarpSolanaDataLoader,
+  WarpSolanaExecutor,
+  WarpSolanaExplorer,
+  WarpSolanaOutput,
+  WarpSolanaSerializer,
+  WarpSolanaWallet,
+  X402SolanaNetworkIdentifiers,
+  findKnownTokenById,
+  getKnownTokensForChain
+};
+//# sourceMappingURL=index.mjs.map