@vleap/warps-adapter-solana 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,1549 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ExplorerUrls: () => ExplorerUrls,
+  KnownTokens: () => KnownTokens,
+  NativeTokenSol: () => NativeTokenSol,
+  SolanaExplorerMap: () => SolanaExplorerMap,
+  SolanaExplorerNames: () => SolanaExplorerNames,
+  SolanaExplorerUrls: () => SolanaExplorerUrls,
+  SolanaExplorers: () => SolanaExplorers,
+  WarpSolanaConstants: () => WarpSolanaConstants,
+  WarpSolanaDataLoader: () => WarpSolanaDataLoader,
+  WarpSolanaExecutor: () => WarpSolanaExecutor,
+  WarpSolanaExplorer: () => WarpSolanaExplorer,
+  WarpSolanaOutput: () => WarpSolanaOutput,
+  WarpSolanaSerializer: () => WarpSolanaSerializer,
+  WarpSolanaWallet: () => WarpSolanaWallet,
+  findKnownTokenById: () => findKnownTokenById,
+  getKnownTokensForChain: () => getKnownTokensForChain,
+  getSolanaAdapter: () => getSolanaAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/WarpSolanaDataLoader.ts
+var import_warps = require("@vleap/warps");
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@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/?cluster=devnet",
+  ["solana_explorer" /* SolanaExplorer */]: "https://explorer.solana.com",
+  ["solana_explorer_mainnet" /* SolanaExplorerMainnet */]: "https://explorer.solana.com",
+  ["solana_explorer_devnet" /* SolanaExplorerDevnet */]: "https://explorer.solana.com/?cluster=devnet"
+};
+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;
+
+// src/tokens/solana.ts
+var SolanaChain = "solana";
+var SolanaTokens = [
+  {
+    chain: SolanaChain,
+    identifier: "SOL",
+    name: "Solana",
+    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"
+  }
+];
+
+// src/tokens.ts
+var KnownTokens = {
+  solana: {
+    mainnet: SolanaTokens,
+    testnet: SolanaTokens,
+    devnet: SolanaTokens
+  }
+};
+var findKnownTokenById = (chain, env, id) => {
+  const chainTokens = KnownTokens[chain]?.[env] || [];
+  return chainTokens.find((token) => token.identifier === id) || null;
+};
+var getKnownTokensForChain = (chainName, env = "mainnet") => {
+  return KnownTokens[chainName]?.[env] || [];
+};
+
+// src/WarpSolanaDataLoader.ts
+var WarpSolanaDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const providerConfig = (0, import_warps.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new import_web3.Connection(providerConfig.url, "confirmed");
+    this.cache = new import_warps.WarpCache(config.cache?.type);
+  }
+  async getAccount(address) {
+    try {
+      const publicKey = new import_web3.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 = import_warps.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, import_warps.CacheTtl.OneHour);
+      return asset;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    try {
+      const signature = identifier;
+      const tx = await this.connection.getTransaction(signature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) return null;
+      const slot = tx.slot;
+      const blockTime = tx.blockTime ? new Date(tx.blockTime * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      const message = tx.transaction.message;
+      let accountKeys = [];
+      if ("staticAccountKeys" in message) {
+        accountKeys = message.staticAccountKeys || [];
+      } else {
+        try {
+          const allKeys = message.getAccountKeys?.();
+          if (allKeys) {
+            accountKeys = allKeys.keySegments().flat() || [];
+          }
+        } catch {
+          accountKeys = [];
+        }
+      }
+      const sender = accountKeys[0]?.toBase58() || "";
+      const receiver = accountKeys.length > 1 ? accountKeys[1]?.toBase58() || "" : "";
+      const preBalances = tx.meta?.preBalances || [];
+      const postBalances = tx.meta?.postBalances || [];
+      const value = preBalances.length > 0 && postBalances.length > 0 ? BigInt(Math.abs(postBalances[0] - preBalances[0])) : 0n;
+      const status = tx.meta?.err ? "failed" : "success";
+      let compiledInstructions = [];
+      if ("compiledInstructions" in message && Array.isArray(message.compiledInstructions)) {
+        compiledInstructions = message.compiledInstructions;
+      }
+      const hasInstructions = compiledInstructions.length > 0;
+      return {
+        chain: this.chain.name,
+        id: signature,
+        receiver,
+        sender,
+        value,
+        function: hasInstructions ? compiledInstructions[0]?.programIdIndex !== void 0 ? "contract_call" : "transfer" : "transfer",
+        status,
+        createdAt: blockTime,
+        error: tx.meta?.err ? JSON.stringify(tx.meta.err) : null,
+        tx: {
+          signature,
+          slot,
+          blockTime,
+          err: tx.meta?.err || null
+        }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getTokenBalances(address) {
+    try {
+      const publicKey = new import_web3.PublicKey(address);
+      const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(publicKey, {
+        programId: new import_web3.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: knownToken.logoUrl || ""
+              }
+            };
+          }
+          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 import_web3.PublicKey(tokenAddress);
+      const mintInfo = await (0, import_spl_token.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: ""
+      };
+    }
+  }
+};
+
+// src/WarpSolanaExecutor.ts
+var import_warps4 = require("@vleap/warps");
+var import_web34 = require("@solana/web3.js");
+var import_spl_token2 = require("@solana/spl-token");
+
+// src/WarpSolanaOutput.ts
+var import_warps3 = require("@vleap/warps");
+var import_web33 = require("@solana/web3.js");
+
+// src/WarpSolanaSerializer.ts
+var import_warps2 = require("@vleap/warps");
+var import_web32 = require("@solana/web3.js");
+var import_bs58 = __toESM(require("bs58"), 1);
+var WarpSolanaSerializer = class {
+  constructor() {
+    this.coreSerializer = new import_warps2.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 import_web32.PublicKey(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 import_web32.PublicKey) {
+      return `address:${value.toBase58()}`;
+    }
+    if (value instanceof Uint8Array) {
+      return `hex:${import_bs58.default.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}${import_warps2.WarpConstants.ArgCompositeSeparator}${asset.amount.toString()}${import_warps2.WarpConstants.ArgCompositeSeparator}${asset.decimals}`;
+      }
+      return `asset:${asset.identifier}${import_warps2.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(import_warps2.WarpConstants.ArgParamsSeparator)[0]);
+      const type = types[0];
+      const values = value.map((item) => this.typedToString(item).split(import_warps2.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(import_warps2.WarpConstants.ArgParamsSeparator);
+    const nativeValue = valueParts.join(import_warps2.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(import_warps2.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(import_warps2.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 = (0, import_warps3.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new import_web33.Connection(providerConfig.url, "confirmed");
+    this.cache = new import_warps3.WarpCache(config.cache?.type);
+  }
+  async getActionExecution(warp, actionIndex, tx) {
+    const inputs = this.cache.get(import_warps3.WarpCacheKey.WarpExecutable(this.config.env, warp.meta?.hash || "", actionIndex)) ?? [];
+    const resolvedInputs = (0, import_warps3.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: (0, import_warps3.getWarpWalletAddressFromConfig)(this.config, this.chain.name),
+      txHash: "",
+      tx: null,
+      next: null,
+      values: { string: [], native: [], mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  handleWarpChainAction(warp, actionIndex, tx, resolvedInputs = []) {
+    const success = tx.status === "success";
+    const transactionHash = tx.id || tx.tx?.signature || "";
+    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: (0, import_warps3.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: (0, import_warps3.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(import_warps3.WarpConstants.Transform.Prefix)) continue;
+      const currentActionIndex = (0, import_warps3.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 (0, import_warps3.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 = (0, import_warps4.getProviderConfig)(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.connection = new import_web34.Connection(providerConfig.url, "confirmed");
+    this.output = new WarpSolanaOutput(config, this.chain);
+  }
+  async createTransaction(executable) {
+    const action = (0, import_warps4.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 = (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpSolanaExecutor: createTransfer - user address not set");
+    let destinationPubkey;
+    try {
+      if (!executable.destination) throw new Error("WarpSolanaExecutor: Destination address is required");
+      destinationPubkey = new import_web34.PublicKey(executable.destination);
+    } catch {
+      throw new Error(`WarpSolanaExecutor: Invalid destination address: ${executable.destination}`);
+    }
+    if (executable.transfers && executable.transfers.length > 0) {
+      return this.createTokenTransferTransaction(executable, userWallet, destinationPubkey);
+    }
+    const fromPubkey = new import_web34.PublicKey(userWallet);
+    const transaction = new import_web34.Transaction();
+    if (executable.value > 0n) {
+      transaction.add(
+        import_web34.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");
+        const instruction = new import_web34.TransactionInstruction({
+          keys: [
+            { pubkey: fromPubkey, isSigner: true, isWritable: true },
+            { pubkey: destinationPubkey, isSigner: false, isWritable: true }
+          ],
+          programId: destinationPubkey,
+          data: dataBuffer
+        });
+        transaction.add(instruction);
+      }
+    }
+    return this.setTransactionDefaults(transaction, fromPubkey);
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpSolanaExecutor: createContractCall - user address not set");
+    const action = (0, import_warps4.getWarpActionByIndex)(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) throw new Error("WarpSolanaExecutor: Contract action must have a function name");
+    let programId;
+    try {
+      if (!executable.destination) throw new Error("WarpSolanaExecutor: Contract address is required");
+      programId = new import_web34.PublicKey(executable.destination);
+    } catch {
+      throw new Error(`WarpSolanaExecutor: Invalid contract address: ${executable.destination}`);
+    }
+    const fromPubkey = new import_web34.PublicKey(userWallet);
+    const transaction = new import_web34.Transaction();
+    try {
+      const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+      let instructionData = Buffer.alloc(0);
+      if (action.abi && typeof action.abi === "string") {
+        try {
+          const abi = JSON.parse(action.abi);
+          if (abi.instructions && abi.instructions[action.func]) {
+            const instructionDef = abi.instructions[action.func];
+            instructionData = this.encodeInstructionData(instructionDef, nativeArgs, action.func);
+          } else if (abi.accounts || abi.types) {
+            instructionData = this.encodeBasicInstructionData(nativeArgs, action.func);
+          }
+        } catch {
+          instructionData = this.encodeBasicInstructionData(nativeArgs, action.func);
+        }
+      } else {
+        instructionData = this.encodeBasicInstructionData(nativeArgs, action.func);
+      }
+      const accounts = this.buildInstructionAccounts(action, executable, fromPubkey, programId);
+      const instruction = new import_web34.TransactionInstruction({
+        keys: accounts,
+        programId,
+        data: instructionData
+      });
+      transaction.add(instruction);
+      if (executable.value > 0n) {
+        transaction.add(
+          import_web34.SystemProgram.transfer({
+            fromPubkey,
+            toPubkey: programId,
+            lamports: Number(executable.value)
+          })
+        );
+      }
+      return this.setTransactionDefaults(transaction, fromPubkey);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`WarpSolanaExecutor: Failed to create contract call: ${errorMessage}`);
+    }
+  }
+  encodeInstructionData(instructionDef, args, funcName) {
+    try {
+      const data = Buffer.alloc(8);
+      if (instructionDef.discriminator && Buffer.isBuffer(instructionDef.discriminator)) {
+        instructionDef.discriminator.copy(data, 0);
+      } else {
+        const hash = Buffer.from(funcName).slice(0, 8);
+        hash.copy(data, 0);
+      }
+      if (args.length > 0 && instructionDef.args) {
+        const encodedArgs = this.encodeArgs(args, instructionDef.args);
+        return Buffer.concat([data, encodedArgs]);
+      }
+      return data;
+    } catch {
+      return this.encodeBasicInstructionData(args, funcName);
+    }
+  }
+  encodeBasicInstructionData(args, funcName) {
+    const funcHash = Buffer.from(funcName).slice(0, 8);
+    const data = Buffer.alloc(8);
+    funcHash.copy(data, 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 import_web34.PublicKey(arg);
+          buffers.push(pubkey.toBuffer());
+        } catch {
+          buffers.push(Buffer.from(String(arg), "utf8"));
+        }
+      } else {
+        buffers.push(Buffer.from(String(arg), "utf8"));
+      }
+    }
+    return Buffer.concat(buffers);
+  }
+  buildInstructionAccounts(action, executable, fromPubkey, programId) {
+    const accounts = [
+      { pubkey: fromPubkey, isSigner: true, isWritable: true }
+    ];
+    if (action.accounts && Array.isArray(action.accounts)) {
+      for (const accountDef of action.accounts) {
+        try {
+          const pubkey = new import_web34.PublicKey(accountDef.address || accountDef.pubkey || executable.destination);
+          accounts.push({
+            pubkey,
+            isSigner: accountDef.signer === true,
+            isWritable: accountDef.writable !== false
+          });
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (!accounts.some((acc) => acc.pubkey.equals(programId))) {
+      accounts.push({ pubkey: programId, isSigner: false, isWritable: false });
+    }
+    return accounts;
+  }
+  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 nativeTokenTransfers = executable.transfers.filter(
+      (transfer) => transfer.identifier === this.chain.nativeToken.identifier || transfer.identifier === WarpSolanaConstants.NativeToken.Identifier
+    );
+    const splTokenTransfers = executable.transfers.filter(
+      (transfer) => transfer.identifier !== this.chain.nativeToken.identifier && transfer.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 import_web34.PublicKey(userWallet);
+      const transaction = new import_web34.Transaction();
+      transaction.add(
+        import_web34.SystemProgram.transfer({
+          fromPubkey,
+          toPubkey: destinationPubkey,
+          lamports: Number(transfer.amount)
+        })
+      );
+      return this.setTransactionDefaults(transaction, 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) {
+    let mintAddress;
+    try {
+      mintAddress = new import_web34.PublicKey(transfer.identifier);
+    } catch {
+      throw new Error(`WarpSolanaExecutor: Invalid token address: ${transfer.identifier}`);
+    }
+    const fromPubkey = new import_web34.PublicKey(userWallet);
+    const transaction = new import_web34.Transaction();
+    const sourceTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintAddress, fromPubkey);
+    const destinationTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintAddress, destinationPubkey);
+    const sourceAccountInfo = await this.connection.getAccountInfo(sourceTokenAccount);
+    if (!sourceAccountInfo) {
+      throw new Error("WarpSolanaExecutor: Source token account does not exist");
+    }
+    const destinationAccountInfo = await this.connection.getAccountInfo(destinationTokenAccount);
+    if (!destinationAccountInfo) {
+      transaction.add(
+        (0, import_spl_token2.createAssociatedTokenAccountInstruction)(
+          fromPubkey,
+          destinationTokenAccount,
+          destinationPubkey,
+          mintAddress
+        )
+      );
+    }
+    transaction.add(
+      (0, import_spl_token2.createTransferInstruction)(
+        sourceTokenAccount,
+        destinationTokenAccount,
+        fromPubkey,
+        Number(transfer.amount)
+      )
+    );
+    return this.setTransactionDefaults(transaction, fromPubkey);
+  }
+  async executeQuery(executable) {
+    const action = (0, import_warps4.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");
+    let queryAddress;
+    try {
+      if (!executable.destination) throw new Error("WarpSolanaExecutor: Query address is required");
+      queryAddress = new import_web34.PublicKey(executable.destination);
+    } catch {
+      throw new Error(`WarpSolanaExecutor: Invalid address for query: ${executable.destination}`);
+    }
+    try {
+      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 = (0, import_warps4.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 = (0, import_warps4.extractResolvedInputValues)(executable.resolvedInputs);
+      return {
+        status: isSuccess ? "success" : "error",
+        warp: executable.warp,
+        action: executable.action,
+        user: (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name),
+        txHash: null,
+        tx: null,
+        next,
+        values,
+        output: { ...output, _DATA: decodedResult },
+        messages: (0, import_warps4.applyOutputToMessages)(executable.warp, output, this.config),
+        destination,
+        resolvedInputs
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const destinationInput = executable.resolvedInputs.find(
+        (i) => i.input.position === "receiver" || i.input.position === "destination"
+      );
+      const destination = destinationInput?.value || executable.destination;
+      const resolvedInputs = (0, import_warps4.extractResolvedInputValues)(executable.resolvedInputs);
+      return {
+        status: "error",
+        warp: executable.warp,
+        action: executable.action,
+        user: (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name),
+        txHash: null,
+        tx: null,
+        next: null,
+        values: { string: [], native: [], mapped: {} },
+        output: { _DATA: errorMessage, _ERROR: errorMessage },
+        messages: {},
+        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(transaction, fromPubkey) {
+    try {
+      const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash("confirmed");
+      transaction.recentBlockhash = blockhash;
+      if (fromPubkey) {
+        transaction.feePayer = fromPubkey;
+      }
+      const instructions = transaction.instructions;
+      const hasTransfer = instructions.some(
+        (ix) => ix.programId.equals(import_web34.SystemProgram.programId) && ix.data.length === 4
+      );
+      const hasTokenTransfer = instructions.some(
+        (ix) => ix.programId.toBase58() === WarpSolanaConstants.Programs.TokenProgram
+      );
+      let computeUnits = WarpSolanaConstants.ComputeUnitLimit.Default;
+      if (hasTransfer && !hasTokenTransfer) {
+        computeUnits = WarpSolanaConstants.ComputeUnitLimit.Transfer;
+      } else if (hasTokenTransfer) {
+        computeUnits = WarpSolanaConstants.ComputeUnitLimit.TokenTransfer;
+      } else {
+        computeUnits = WarpSolanaConstants.ComputeUnitLimit.ContractCall;
+      }
+      transaction.add(
+        import_web34.ComputeBudgetProgram.setComputeUnitLimit({
+          units: computeUnits
+        })
+      );
+      transaction.add(
+        import_web34.ComputeBudgetProgram.setComputeUnitPrice({
+          microLamports: WarpSolanaConstants.PriorityFee.Default
+        })
+      );
+      return transaction;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`WarpSolanaExecutor: Failed to set transaction defaults: ${errorMessage}`);
+    }
+  }
+};
+
+// 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);
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/account/${address}${cluster}`;
+  }
+  getTransactionUrl(hash, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/tx/${hash}${cluster}`;
+  }
+  getBlockUrl(blockNumber, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/block/${blockNumber}${cluster}`;
+  }
+  getAssetUrl(identifier, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const cluster = this.config.env === "mainnet" ? "" : `?cluster=${this.config.env}`;
+    return `${baseUrl}/token/${identifier}${cluster}`;
+  }
+  getContractUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    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
+var import_warps5 = require("@vleap/warps");
+var import_web35 = require("@solana/web3.js");
+var bip39 = __toESM(require("@scure/bip39"), 1);
+var import_english = require("@scure/bip39/wordlists/english");
+var import_bs582 = __toESM(require("bs58"), 1);
+var WarpSolanaWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const providerConfig = (0, import_warps5.getProviderConfig)(config, chain.name, config.env, chain.defaultApiUrl);
+    this.connection = new import_web35.Connection(providerConfig.url, "confirmed");
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    const keypair = this.getKeypair();
+    if (tx instanceof import_web35.VersionedTransaction) {
+      tx.sign([keypair]);
+      return tx;
+    }
+    if (tx instanceof import_web35.Transaction) {
+      tx.sign(keypair);
+      return tx;
+    }
+    if (tx.transaction) {
+      if (tx.transaction instanceof import_web35.Transaction) {
+        tx.transaction.sign(keypair);
+        return { ...tx, transaction: tx.transaction.serialize() };
+      }
+      if (typeof tx.transaction === "object") {
+        try {
+          const transaction = import_web35.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 signTransactions(txs) {
+    if (txs.length === 0) return [];
+    const keypair = this.getKeypair();
+    return Promise.all(
+      txs.map(async (tx) => {
+        if (tx instanceof import_web35.VersionedTransaction) {
+          tx.sign([keypair]);
+          return tx;
+        }
+        if (tx instanceof import_web35.Transaction) {
+          tx.sign(keypair);
+          return tx;
+        }
+        if (tx.transaction && typeof tx.transaction === "object") {
+          const transaction = import_web35.Transaction.from(tx.transaction);
+          transaction.sign(keypair);
+          return { ...tx, transaction: transaction.serialize() };
+        }
+        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 import_bs582.default.encode(signature);
+  }
+  async sendTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    let transaction;
+    if (tx instanceof import_web35.VersionedTransaction) {
+      transaction = tx;
+    } else if (tx instanceof import_web35.Transaction) {
+      transaction = tx;
+    } else if (tx.transaction) {
+      if (tx.transaction instanceof import_web35.Transaction) {
+        transaction = tx.transaction;
+      } else if (tx.transaction instanceof import_web35.VersionedTransaction) {
+        transaction = tx.transaction;
+      } else if (typeof tx.transaction === "object") {
+        try {
+          transaction = import_web35.Transaction.from(tx.transaction);
+        } catch {
+          throw new Error("Invalid transaction format");
+        }
+      } else if (Buffer.isBuffer(tx.transaction) || typeof tx.transaction === "string") {
+        transaction = import_web35.Transaction.from(tx.transaction);
+      } else {
+        throw new Error("Transaction must be signed before sending");
+      }
+    } else {
+      throw new Error("Transaction must be signed before sending");
+    }
+    const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
+      skipPreflight: true,
+      maxRetries: 3
+    });
+    return signature;
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  create(mnemonic) {
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const keypair = import_web35.Keypair.fromSeed(seed.slice(0, 32));
+    return {
+      address: keypair.publicKey.toBase58(),
+      privateKey: import_bs582.default.encode(keypair.secretKey),
+      mnemonic
+    };
+  }
+  generate() {
+    const keypair = import_web35.Keypair.generate();
+    const entropy = keypair.secretKey.slice(0, 16);
+    const mnemonic = bip39.entropyToMnemonic(entropy, import_english.wordlist);
+    return {
+      address: keypair.publicKey.toBase58(),
+      privateKey: import_bs582.default.encode(keypair.secretKey),
+      mnemonic
+    };
+  }
+  getAddress() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  getPublicKey() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  getKeypair() {
+    const privateKey = (0, import_warps5.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
+    if (privateKey) {
+      try {
+        const secretKey = import_bs582.default.decode(privateKey);
+        if (secretKey.length === 64) {
+          return import_web35.Keypair.fromSecretKey(secretKey);
+        } else if (secretKey.length === 32) {
+          return import_web35.Keypair.fromSeed(secretKey);
+        } 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");
+      }
+    }
+    const mnemonic = (0, import_warps5.getWarpWalletMnemonicFromConfig)(this.config, this.chain.name);
+    if (mnemonic) {
+      const seed = bip39.mnemonicToSeedSync(mnemonic);
+      return import_web35.Keypair.fromSeed(seed.slice(0, 32));
+    }
+    throw new Error("No private key or mnemonic provided");
+  }
+};
+
+// 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: "solana",
+  identifier: "SOL",
+  symbol: "SOL",
+  name: "Solana",
+  decimals: 9,
+  logoUrl: "https://vleap.ai/images/tokens/sol.svg"
+};
+var getSolanaAdapter = createSolanaAdapter("solana", {
+  mainnet: {
+    name: "solana",
+    displayName: "Solana Mainnet",
+    chainId: "101",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.mainnet-beta.solana.com",
+    logoUrl: "https://vleap.ai/images/chains/solana.svg",
+    nativeToken: NativeTokenSol
+  },
+  testnet: {
+    name: "solana",
+    displayName: "Solana Testnet",
+    chainId: "103",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.testnet.solana.com",
+    logoUrl: "https://vleap.ai/images/chains/solana.svg",
+    nativeToken: NativeTokenSol
+  },
+  devnet: {
+    name: "solana",
+    displayName: "Solana Devnet",
+    chainId: "103",
+    blockTime: 400,
+    addressHrp: "",
+    defaultApiUrl: "https://api.devnet.solana.com",
+    logoUrl: "https://vleap.ai/images/chains/solana.svg",
+    nativeToken: NativeTokenSol
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExplorerUrls,
+  KnownTokens,
+  NativeTokenSol,
+  SolanaExplorerMap,
+  SolanaExplorerNames,
+  SolanaExplorerUrls,
+  SolanaExplorers,
+  WarpSolanaConstants,
+  WarpSolanaDataLoader,
+  WarpSolanaExecutor,
+  WarpSolanaExplorer,
+  WarpSolanaOutput,
+  WarpSolanaSerializer,
+  WarpSolanaWallet,
+  findKnownTokenById,
+  getKnownTokensForChain,
+  getSolanaAdapter
+});
+//# sourceMappingURL=index.js.map