@vleap/warps-adapter-evm 0.2.0-alpha.2

package/dist/index.mjs

@@ -0,0 +1,761 @@
+// src/config.ts
+var EVM_CHAIN_CONFIGS = {
+  ethereum: {
+    mainnet: {
+      apiUrl: "https://eth-mainnet.g.alchemy.com/v2/demo",
+      explorerUrl: "https://etherscan.io",
+      chainId: "1",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12
+    },
+    testnet: {
+      apiUrl: "https://eth-sepolia.g.alchemy.com/v2/demo",
+      explorerUrl: "https://sepolia.etherscan.io",
+      chainId: "11155111",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12
+    }
+  },
+  arbitrum: {
+    mainnet: {
+      apiUrl: "https://arb-mainnet.g.alchemy.com/v2/demo",
+      explorerUrl: "https://arbiscan.io",
+      chainId: "42161",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1
+    },
+    testnet: {
+      apiUrl: "https://arb-sepolia.g.alchemy.com/v2/demo",
+      explorerUrl: "https://sepolia.arbiscan.io",
+      chainId: "421614",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1
+    }
+  },
+  base: {
+    mainnet: {
+      apiUrl: "https://mainnet.base.org",
+      explorerUrl: "https://basescan.org",
+      chainId: "8453",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2
+    },
+    testnet: {
+      apiUrl: "https://sepolia.base.org",
+      explorerUrl: "https://sepolia.basescan.org",
+      chainId: "84532",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2
+    }
+  }
+};
+var DEFAULT_CHAIN = "ethereum";
+var getEvmChainConfig = (chain = DEFAULT_CHAIN, env) => {
+  const chainConfigs = EVM_CHAIN_CONFIGS[chain];
+  if (!chainConfigs) {
+    throw new Error(`Unsupported EVM chain: ${chain}`);
+  }
+  const config = chainConfigs[env];
+  if (!config) {
+    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  }
+  return config;
+};
+var getEvmApiUrl = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).apiUrl;
+};
+var getEvmExplorerUrl = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).explorerUrl;
+};
+var getEvmChainId = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).chainId;
+};
+var getEvmRegistryAddress = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).registryAddress;
+};
+var getEvmNativeToken = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).nativeToken;
+};
+var getEvmBlockTime = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).blockTime || 12;
+};
+var getSupportedEvmChains = () => {
+  return Object.keys(EVM_CHAIN_CONFIGS);
+};
+var getSupportedEnvironments = (chain) => {
+  const chainConfigs = EVM_CHAIN_CONFIGS[chain];
+  if (!chainConfigs) {
+    return [];
+  }
+  return Object.keys(chainConfigs);
+};
+
+// src/constants.ts
+var WarpEvmConstants = {
+  ChainName: "evm",
+  ChainPrefix: "evm",
+  Ether: {
+    Identifier: "ETH",
+    DisplayName: "Ether",
+    Decimals: 18
+  },
+  GasLimit: {
+    Default: 21e3,
+    ContractCall: 1e5,
+    ContractDeploy: 5e5,
+    Transfer: 21e3,
+    Approve: 46e3,
+    Swap: 2e5
+  },
+  GasPrice: {
+    Default: "20000000000",
+    // 20 gwei
+    Low: "10000000000",
+    // 10 gwei
+    Medium: "20000000000",
+    // 20 gwei
+    High: "50000000000"
+    // 50 gwei
+  },
+  Network: {
+    Ethereum: {
+      ChainId: "1",
+      Name: "Ethereum",
+      BlockTime: 12
+    },
+    Arbitrum: {
+      ChainId: "42161",
+      Name: "Arbitrum",
+      BlockTime: 1
+    },
+    Base: {
+      ChainId: "8453",
+      Name: "Base",
+      BlockTime: 2
+    }
+  },
+  Validation: {
+    AddressLength: 42,
+    HexPrefix: "0x",
+    MinGasLimit: 21e3,
+    MaxGasLimit: 3e7
+  },
+  Timeouts: {
+    DefaultRpcTimeout: 3e4,
+    // 30 seconds
+    GasEstimationTimeout: 1e4,
+    // 10 seconds
+    QueryTimeout: 15e3
+    // 15 seconds
+  }
+};
+
+// src/WarpEvmBuilder.ts
+import { ethers } from "ethers";
+var WarpEvmBuilder = class {
+  constructor(config) {
+    this.config = config;
+    this.warp = {};
+    this.actions = [];
+  }
+  async createFromRaw(encoded) {
+    try {
+      const decoded = JSON.parse(encoded);
+      return decoded;
+    } catch (error) {
+      throw new Error(`Failed to decode warp from raw data: ${error}`);
+    }
+  }
+  setTitle(title) {
+    this.warp.title = title;
+    return this;
+  }
+  setDescription(description) {
+    this.warp.description = description;
+    return this;
+  }
+  setPreview(preview) {
+    this.warp.preview = preview;
+    return this;
+  }
+  setActions(actions) {
+    this.actions = actions;
+    return this;
+  }
+  addAction(action) {
+    this.actions.push(action);
+    return this;
+  }
+  async build() {
+    if (!this.warp.title) {
+      throw new Error("Warp title is required");
+    }
+    return {
+      protocol: "warp",
+      name: this.warp.name || "evm-warp",
+      title: this.warp.title,
+      description: this.warp.description || null,
+      preview: this.warp.preview || null,
+      actions: this.actions,
+      meta: {
+        chain: "evm",
+        hash: ethers.keccak256(ethers.toUtf8Bytes(this.warp.title)),
+        creator: this.config.user?.wallets?.evm || "",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  createInscriptionTransaction(warp) {
+    const warpData = JSON.stringify(warp);
+    const data = ethers.toUtf8Bytes(warpData);
+    return {
+      data: ethers.hexlify(data)
+    };
+  }
+  async createFromTransaction(tx, validate) {
+    if (!tx.data || tx.data === "0x") {
+      throw new Error("Transaction has no data");
+    }
+    try {
+      const data = ethers.toUtf8String(tx.data);
+      const warp = JSON.parse(data);
+      if (validate) {
+        if (!warp.protocol || warp.protocol !== "warp") {
+          throw new Error("Invalid warp protocol");
+        }
+        if (!warp.title) {
+          throw new Error("Warp title is required");
+        }
+      }
+      return warp;
+    } catch (error) {
+      throw new Error(`Failed to create warp from transaction: ${error}`);
+    }
+  }
+  async createFromTransactionHash(hash, cache) {
+    try {
+      const provider = new ethers.JsonRpcProvider(getEvmApiUrl(this.config.env));
+      const tx = await provider.getTransaction(hash);
+      if (!tx) {
+        return null;
+      }
+      return await this.createFromTransaction(tx);
+    } catch (error) {
+      return null;
+    }
+  }
+};
+
+// src/WarpEvmExecutor.ts
+import {
+  applyResultsToMessages,
+  getNextInfo,
+  getWarpActionByIndex
+} from "@vleap/warps";
+import { ethers as ethers3 } from "ethers";
+
+// src/WarpEvmResults.ts
+import {
+  evaluateResultsCommon,
+  parseResultsOutIndex,
+  WarpConstants as WarpConstants2
+} from "@vleap/warps";
+
+// src/WarpEvmSerializer.ts
+import {
+  WarpConstants,
+  WarpSerializer
+} from "@vleap/warps";
+import { ethers as ethers2 } from "ethers";
+var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
+var WarpEvmSerializer = class {
+  constructor() {
+    this.coreSerializer = new WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      if (ethers2.isAddress(value)) {
+        return `address:${value}`;
+      }
+      if (ethers2.isHexString(value) && !ethers2.isAddress(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 (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);
+      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;
+      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/WarpEvmResults.ts
+var WarpEvmResults = class {
+  constructor(config) {
+    this.config = config;
+    this.serializer = new WarpEvmSerializer();
+  }
+  async getTransactionExecutionResults(warp, tx) {
+    const success = tx.status === 1;
+    const gasUsed = tx.gasUsed?.toString() || "0";
+    const gasPrice = tx.gasPrice?.toString() || "0";
+    const blockNumber = tx.blockNumber?.toString() || "0";
+    const transactionHash = tx.hash;
+    const logs = tx.logs.map((log) => ({
+      address: log.address,
+      topics: log.topics,
+      data: log.data,
+      blockNumber: log.blockNumber?.toString() || "0",
+      transactionHash: log.transactionHash,
+      index: log.index?.toString() || "0"
+    }));
+    return {
+      success,
+      warp,
+      action: 0,
+      user: this.config.user?.wallets?.evm || null,
+      txHash: transactionHash,
+      next: null,
+      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
+      results: {},
+      messages: {}
+    };
+  }
+  async extractQueryResults(warp, typedValues, actionIndex, inputs) {
+    const values = typedValues.map((t) => this.serializer.typedToString(t));
+    const valuesRaw = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    let results = {};
+    if (!warp.results) return { values, results };
+    const getNestedValue = (path) => {
+      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
+      if (indices.length === 0) return void 0;
+      let value = valuesRaw[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.results)) {
+      if (path.startsWith(WarpConstants2.Transform.Prefix)) continue;
+      const currentActionIndex = parseResultsOutIndex(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        results[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        results[key] = getNestedValue(path) || null;
+      } else {
+        results[key] = path;
+      }
+    }
+    return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
+  }
+};
+
+// src/WarpEvmExecutor.ts
+var WarpEvmExecutor = class {
+  constructor(config) {
+    this.config = config;
+    this.serializer = new WarpEvmSerializer();
+    this.provider = new ethers3.JsonRpcProvider(getEvmApiUrl(config.env));
+    this.results = new WarpEvmResults(config);
+  }
+  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("WarpEvmExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    } else if (action.type === "collect") {
+      throw new Error("WarpEvmExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    }
+    if (!tx) throw new Error(`WarpEvmExecutor: Invalid action type (${action.type})`);
+    return tx;
+  }
+  async createTransferTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpEvmExecutor: createTransfer - user address not set");
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid destination address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpEvmExecutor: Transfer value cannot be negative: ${executable.value}`);
+    }
+    const tx = {
+      to: executable.destination,
+      value: executable.value,
+      data: executable.data ? this.serializer.stringToTyped(executable.data) : "0x"
+    };
+    return this.estimateGasAndSetDefaults(tx, userWallet);
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpEvmExecutor: createContractCall - user address not set");
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) {
+      throw new Error("WarpEvmExecutor: Contract action must have a function name");
+    }
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid contract address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpEvmExecutor: Contract call value cannot be negative: ${executable.value}`);
+    }
+    try {
+      const iface = new ethers3.Interface([`function ${action.func}`]);
+      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      const tx = {
+        to: executable.destination,
+        value: executable.value,
+        data: encodedData
+      };
+      return this.estimateGasAndSetDefaults(tx, userWallet);
+    } catch (error) {
+      throw new Error(`WarpEvmExecutor: Failed to encode function data for ${action.func}: ${error}`);
+    }
+  }
+  async executeQuery(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type !== "query") {
+      throw new Error(`WarpEvmExecutor: Invalid action type for executeQuery: ${action.type}`);
+    }
+    if (!action.func) {
+      throw new Error("WarpEvmExecutor: Query action must have a function name");
+    }
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid contract address for query: ${executable.destination}`);
+    }
+    try {
+      const iface = new ethers3.Interface([`function ${action.func}`]);
+      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      const result = await this.provider.call({
+        to: executable.destination,
+        data: encodedData
+      });
+      const decodedResult = iface.decodeFunctionResult(action.func, result);
+      const isSuccess = true;
+      const { values, results } = await this.results.extractQueryResults(
+        executable.warp,
+        decodedResult,
+        executable.action,
+        executable.resolvedInputs
+      );
+      const adapter = getEvmAdapter(this.config);
+      const next = getNextInfo(this.config, adapter, executable.warp, executable.action, results);
+      return {
+        success: isSuccess,
+        warp: executable.warp,
+        action: executable.action,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        txHash: null,
+        next,
+        values,
+        results,
+        messages: applyResultsToMessages(executable.warp, results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        warp: executable.warp,
+        action: executable.action,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        txHash: null,
+        next: null,
+        values: [],
+        results: {},
+        messages: {}
+      };
+    }
+  }
+  async preprocessInput(chain, input, type, value) {
+    const typedValue = this.serializer.stringToTyped(value);
+    switch (type) {
+      case "address":
+        if (!ethers3.isAddress(typedValue)) {
+          throw new Error(`Invalid address format: ${typedValue}`);
+        }
+        return ethers3.getAddress(typedValue);
+      case "hex":
+        if (!ethers3.isHexString(typedValue)) {
+          throw new Error(`Invalid hex format: ${typedValue}`);
+        }
+        return typedValue;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        const bigIntValue = BigInt(typedValue);
+        if (bigIntValue < 0) {
+          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
+        }
+        return bigIntValue.toString();
+      default:
+        return String(typedValue);
+    }
+  }
+  async estimateGasAndSetDefaults(tx, from) {
+    try {
+      const gasEstimate = await this.provider.estimateGas({
+        ...tx,
+        from
+      });
+      if (gasEstimate < BigInt(WarpEvmConstants.Validation.MinGasLimit)) {
+        throw new Error(`Gas estimate too low: ${gasEstimate}`);
+      }
+      if (gasEstimate > BigInt(WarpEvmConstants.Validation.MaxGasLimit)) {
+        throw new Error(`Gas estimate too high: ${gasEstimate}`);
+      }
+      const feeData = await this.provider.getFeeData();
+      if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          maxFeePerGas: feeData.maxFeePerGas,
+          maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        };
+      } else if (feeData.gasPrice) {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          gasPrice: feeData.gasPrice
+        };
+      } else {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        };
+      }
+    } catch (error) {
+      let defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Default);
+      if (tx.data && tx.data !== "0x") {
+        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.ContractCall);
+      } else {
+        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Transfer);
+      }
+      return {
+        ...tx,
+        gasLimit: defaultGasLimit,
+        gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+      };
+    }
+  }
+  async signMessage(message, privateKey) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/WarpEvmExplorer.ts
+var WarpEvmExplorer = class {
+  constructor(chainInfo, chainName = "ethereum") {
+    this.chainInfo = chainInfo;
+    this.chainName = chainName;
+  }
+  getAccountUrl(address) {
+    const baseUrl = this.chainInfo.explorerUrl || getEvmExplorerUrl("mainnet", this.chainName);
+    return `${baseUrl}/address/${address}`;
+  }
+  getTransactionUrl(hash) {
+    const baseUrl = this.chainInfo.explorerUrl || getEvmExplorerUrl("mainnet", this.chainName);
+    return `${baseUrl}/tx/${hash}`;
+  }
+};
+
+// src/main.ts
+var getEvmAdapter = (config, fallback) => {
+  if (!fallback) throw new Error("EVM adapter requires a fallback adapter");
+  return {
+    chain: WarpEvmConstants.ChainName,
+    prefix: WarpEvmConstants.ChainPrefix,
+    builder: () => new WarpEvmBuilder(config),
+    executor: new WarpEvmExecutor(config),
+    results: new WarpEvmResults(config),
+    serializer: new WarpEvmSerializer(),
+    registry: fallback.registry,
+    explorer: (chainInfo) => new WarpEvmExplorer(chainInfo),
+    abiBuilder: () => fallback.abiBuilder(),
+    brandBuilder: () => fallback.brandBuilder()
+  };
+};
+export {
+  EVM_CHAIN_CONFIGS,
+  WarpEvmBuilder,
+  WarpEvmConstants,
+  WarpEvmExecutor,
+  WarpEvmExplorer,
+  WarpEvmResults,
+  WarpEvmSerializer,
+  getEvmAdapter,
+  getEvmApiUrl,
+  getEvmBlockTime,
+  getEvmChainConfig,
+  getEvmChainId,
+  getEvmExplorerUrl,
+  getEvmNativeToken,
+  getEvmRegistryAddress,
+  getSupportedEnvironments,
+  getSupportedEvmChains
+};
+//# sourceMappingURL=index.mjs.map