@vleap/warps-adapter-near 0.1.0-beta.10

package/dist/index.js

@@ -0,0 +1,1339 @@
+"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,
+  NativeTokenNear: () => NativeTokenNear,
+  NearAdapter: () => NearAdapter,
+  NearExplorerMap: () => NearExplorerMap,
+  NearExplorerNames: () => NearExplorerNames,
+  NearExplorerUrls: () => NearExplorerUrls,
+  NearExplorers: () => NearExplorers,
+  NearTokens: () => NearTokens,
+  WarpNearConstants: () => WarpNearConstants,
+  WarpNearDataLoader: () => WarpNearDataLoader,
+  WarpNearExecutor: () => WarpNearExecutor,
+  WarpNearExplorer: () => WarpNearExplorer,
+  WarpNearOutput: () => WarpNearOutput,
+  WarpNearSerializer: () => WarpNearSerializer,
+  WarpNearWallet: () => WarpNearWallet,
+  findKnownTokenById: () => findKnownTokenById,
+  getKnownTokensForChain: () => getKnownTokensForChain
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/WarpNearDataLoader.ts
+var import_warps = require("@vleap/warps");
+var import_near_api_js = require("near-api-js");
+
+// src/constants.ts
+var WarpNearConstants = {
+  NativeToken: {
+    Identifier: "NEAR",
+    Decimals: 24
+  },
+  Gas: {
+    Default: "300000000000000",
+    Transfer: "100000000000000",
+    FunctionCall: "300000000000000"
+  }
+};
+var NearExplorers = /* @__PURE__ */ ((NearExplorers2) => {
+  NearExplorers2["NearExplorer"] = "near_explorer";
+  NearExplorers2["NearBlocks"] = "near_blocks";
+  NearExplorers2["NearScan"] = "nearscan";
+  return NearExplorers2;
+})(NearExplorers || {});
+var NearExplorerMap = {
+  near: {
+    mainnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */],
+    testnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */],
+    devnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */]
+  }
+};
+var ExplorerUrls = {
+  ["near_explorer" /* NearExplorer */]: "https://explorer.near.org",
+  ["near_blocks" /* NearBlocks */]: "https://nearblocks.io",
+  ["nearscan" /* NearScan */]: "https://nearscan.io"
+};
+var NearExplorerNames = {
+  mainnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */],
+  testnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */],
+  devnet: ["near_explorer" /* NearExplorer */, "near_blocks" /* NearBlocks */, "nearscan" /* NearScan */]
+};
+var NearExplorerUrls = ExplorerUrls;
+
+// src/tokens.ts
+var NearTokens = [];
+var KnownTokens = {
+  near: {
+    mainnet: NearTokens,
+    testnet: NearTokens,
+    devnet: NearTokens
+  }
+};
+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/WarpNearDataLoader.ts
+var WarpNearDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.cache = new import_warps.WarpCache(config.cache?.type);
+    const providerConfig = (0, import_warps.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.nearConfig = {
+      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
+      nodeUrl: providerConfig.url,
+      keyStore: new import_near_api_js.keyStores.InMemoryKeyStore()
+    };
+  }
+  async getAccount(address) {
+    try {
+      const near = await (0, import_near_api_js.connect)(this.nearConfig);
+      const account = await near.account(address);
+      const balance = await account.getAccountBalance();
+      const balanceBigInt = BigInt(balance.total);
+      return {
+        chain: this.chain.name,
+        address,
+        balance: balanceBigInt
+      };
+    } catch (error) {
+      throw new Error(`Failed to get account: ${error}`);
+    }
+  }
+  async getAccountAssets(address) {
+    try {
+      const account = await this.getAccount(address);
+      const assets = account.balance > 0n ? [{ ...this.chain.nativeToken, amount: account.balance }] : [];
+      const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
+      const knownTokens = getKnownTokensForChain(this.chain.name, env);
+      for (const token of knownTokens) {
+        try {
+          const near = await (0, import_near_api_js.connect)(this.nearConfig);
+          const accountObj = await near.account(address);
+          const balance = await accountObj.viewFunction({
+            contractId: token.identifier,
+            methodName: "ft_balance_of",
+            args: { account_id: address }
+          });
+          if (balance && BigInt(balance) > 0n) {
+            assets.push({
+              ...token,
+              amount: BigInt(balance)
+            });
+          }
+        } catch {
+        }
+      }
+      return assets;
+    } catch (error) {
+      return [];
+    }
+  }
+  async getAsset(identifier) {
+    try {
+      if (identifier === this.chain.nativeToken.identifier || identifier === WarpNearConstants.NativeToken.Identifier) {
+        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
+        };
+      }
+      try {
+        const near = await (0, import_near_api_js.connect)(this.nearConfig);
+        const account = await near.account(identifier);
+        const metadata = await account.viewFunction({
+          contractId: identifier,
+          methodName: "ft_metadata",
+          args: {}
+        });
+        const asset = {
+          chain: this.chain.name,
+          identifier,
+          name: metadata.name || "Unknown Token",
+          symbol: metadata.symbol || "UNKNOWN",
+          amount: 0n,
+          decimals: metadata.decimals || WarpNearConstants.NativeToken.Decimals,
+          logoUrl: metadata.icon || ""
+        };
+        this.cache.set(cacheKey, asset, import_warps.CacheTtl.OneHour);
+        return asset;
+      } catch {
+        const asset = {
+          chain: this.chain.name,
+          identifier,
+          name: "Unknown Token",
+          symbol: "UNKNOWN",
+          amount: 0n,
+          decimals: WarpNearConstants.NativeToken.Decimals,
+          logoUrl: ""
+        };
+        return asset;
+      }
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    try {
+      const near = await (0, import_near_api_js.connect)(this.nearConfig);
+      const txStatus = await near.connection.provider.txStatus(identifier, this.nearConfig.networkId);
+      if (!txStatus) return null;
+      const statusObj = txStatus.status;
+      const isSuccess = statusObj && ("SuccessValue" in statusObj || "SuccessReceiptId" in statusObj);
+      const status = isSuccess ? "success" : "failed";
+      const transaction = txStatus.transaction;
+      const receipt = txStatus.receipts?.[0];
+      const sender = transaction.signer_id;
+      const receiver = transaction.receiver_id;
+      const value = transaction.actions?.[0]?.Transfer?.deposit ? BigInt(transaction.actions[0].Transfer.deposit) : 0n;
+      return {
+        chain: this.chain.name,
+        id: identifier,
+        receiver,
+        sender,
+        value,
+        function: transaction.actions?.[0]?.FunctionCall?.method_name || "transfer",
+        status,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: status === "failed" ? JSON.stringify(txStatus.status) : null,
+        tx: txStatus
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+};
+
+// src/WarpNearExecutor.ts
+var import_warps4 = require("@vleap/warps");
+var import_near_api_js3 = require("near-api-js");
+
+// src/WarpNearOutput.ts
+var import_warps3 = require("@vleap/warps");
+var import_near_api_js2 = require("near-api-js");
+
+// src/WarpNearSerializer.ts
+var import_warps2 = require("@vleap/warps");
+var WarpNearSerializer = class {
+  constructor() {
+    this.coreSerializer = new import_warps2.WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      if (value.endsWith(".near") || value.length > 2 && value.length < 65 && /^[a-z0-9._-]+$/.test(value) && !value.includes(" ")) {
+        return `address:${value}`;
+      }
+      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 Uint8Array) {
+      return `hex:${Buffer.from(value).toString("hex")}`;
+    }
+    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/WarpNearOutput.ts
+var WarpNearOutput = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpNearSerializer();
+    const providerConfig = (0, import_warps3.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.nearConfig = {
+      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
+      nodeUrl: providerConfig.url,
+      keyStore: new import_near_api_js2.keyStores.InMemoryKeyStore()
+    };
+    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.handleTransactionHash(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?.hash || "";
+    const rawValues = [transactionHash];
+    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 handleTransactionHash(warp, actionIndex, hash, resolvedInputs = []) {
+    try {
+      const near = await (0, import_near_api_js2.connect)(this.nearConfig);
+      const txStatus = await near.connection.provider.txStatus(hash, this.nearConfig.networkId);
+      if (!txStatus) {
+        return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+      }
+      const statusObj = txStatus.status;
+      const success = statusObj && ("SuccessValue" in statusObj || "SuccessReceiptId" in statusObj);
+      const transaction = txStatus.transaction;
+      const rawValues = [hash];
+      const stringValues = rawValues.map(String);
+      return {
+        status: success ? "success" : "error",
+        warp,
+        action: actionIndex,
+        user: (0, import_warps3.getWarpWalletAddressFromConfig)(this.config, this.chain.name),
+        txHash: hash,
+        tx: {
+          hash,
+          transaction,
+          status: txStatus.status
+        },
+        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 near = await (0, import_near_api_js2.connect)(this.nearConfig);
+      const txStatus = await near.connection.provider.txStatus(txHash, this.nearConfig.networkId);
+      if (!txStatus) {
+        return { status: "pending" };
+      }
+      const statusObj = txStatus.status;
+      const isSuccess = statusObj && ("SuccessValue" in statusObj || "SuccessReceiptId" in statusObj);
+      return {
+        status: isSuccess ? "confirmed" : "failed",
+        blockNumber: txStatus.transaction_outcome?.block_hash ? 0 : void 0,
+        gasUsed: BigInt(0)
+      };
+    } catch (error) {
+      throw new Error(`Failed to get transaction status: ${error}`);
+    }
+  }
+  async getTransactionReceipt(txHash) {
+    try {
+      const near = await (0, import_near_api_js2.connect)(this.nearConfig);
+      const txStatus = await near.connection.provider.txStatus(txHash, this.nearConfig.networkId);
+      if (!txStatus) {
+        return null;
+      }
+      return {
+        hash: txHash,
+        transaction: txStatus.transaction,
+        status: txStatus.status
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+};
+
+// src/WarpNearExecutor.ts
+var WarpNearExecutor = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpNearSerializer();
+    const providerConfig = (0, import_warps4.getProviderConfig)(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.nearConfig = {
+      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
+      nodeUrl: providerConfig.url,
+      keyStore: new import_near_api_js3.keyStores.InMemoryKeyStore()
+    };
+    this.output = new WarpNearOutput(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("WarpNearExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    } else if (action.type === "collect") {
+      throw new Error("WarpNearExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    }
+    if (!tx) throw new Error(`WarpNearExecutor: 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("WarpNearExecutor: createTransfer - user address not set");
+    if (!executable.destination) throw new Error("WarpNearExecutor: Destination address is required");
+    if (executable.transfers && executable.transfers.length > 0) {
+      return this.createTokenTransferTransaction(executable, userWallet);
+    }
+    const amount = executable.value > 0n ? executable.value : 0n;
+    const amountInYoctoNear = amount.toString();
+    return {
+      receiverId: executable.destination,
+      actions: [
+        {
+          type: "Transfer",
+          params: {
+            deposit: amountInYoctoNear
+          }
+        }
+      ]
+    };
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpNearExecutor: 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("WarpNearExecutor: Contract action must have a function name");
+    if (!executable.destination) throw new Error("WarpNearExecutor: Contract address is required");
+    try {
+      const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+      const args = nativeArgs.length > 0 ? nativeArgs : {};
+      const gas = WarpNearConstants.Gas.FunctionCall;
+      const deposit = executable.value > 0n ? executable.value.toString() : "0";
+      return {
+        receiverId: executable.destination,
+        actions: [
+          {
+            type: "FunctionCall",
+            params: {
+              methodName: action.func,
+              args,
+              gas,
+              deposit
+            }
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`WarpNearExecutor: Failed to create contract call: ${errorMessage}`);
+    }
+  }
+  async createTokenTransferTransaction(executable, userWallet) {
+    if (executable.transfers.length === 0) throw new Error("WarpNearExecutor: No transfers provided");
+    if (!this.chain.nativeToken?.identifier) throw new Error("WarpNearExecutor: No native token defined for this chain");
+    const nativeTokenTransfers = executable.transfers.filter(
+      (transfer) => transfer.identifier === this.chain.nativeToken.identifier || transfer.identifier === WarpNearConstants.NativeToken.Identifier
+    );
+    const ftTokenTransfers = executable.transfers.filter(
+      (transfer) => transfer.identifier !== this.chain.nativeToken.identifier && transfer.identifier !== WarpNearConstants.NativeToken.Identifier
+    );
+    if (nativeTokenTransfers.length === 1 && ftTokenTransfers.length === 0) {
+      const transfer = nativeTokenTransfers[0];
+      if (transfer.amount <= 0n) throw new Error("WarpNearExecutor: Native token transfer amount must be positive");
+      return {
+        receiverId: executable.destination,
+        actions: [
+          {
+            type: "Transfer",
+            params: {
+              deposit: transfer.amount.toString()
+            }
+          }
+        ]
+      };
+    }
+    if (nativeTokenTransfers.length === 0 && ftTokenTransfers.length === 1) {
+      return this.createSingleTokenTransfer(executable, ftTokenTransfers[0]);
+    }
+    if (executable.transfers.length > 1) throw new Error("WarpNearExecutor: Multiple token transfers not yet supported");
+    throw new Error("WarpNearExecutor: Invalid transfer configuration");
+  }
+  async createSingleTokenTransfer(executable, transfer) {
+    if (!executable.destination) throw new Error("WarpNearExecutor: Destination address is required");
+    const userWallet = (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpNearExecutor: User wallet not set");
+    const args = {
+      receiver_id: executable.destination,
+      amount: transfer.amount.toString()
+    };
+    return {
+      receiverId: transfer.identifier,
+      actions: [
+        {
+          type: "FunctionCall",
+          params: {
+            methodName: "ft_transfer",
+            args,
+            gas: WarpNearConstants.Gas.FunctionCall,
+            deposit: "1"
+          }
+        }
+      ]
+    };
+  }
+  async executeQuery(executable) {
+    const action = (0, import_warps4.getWarpActionByIndex)(executable.warp, executable.action);
+    if (action.type !== "query") throw new Error(`WarpNearExecutor: Invalid action type for executeQuery: ${action.type}`);
+    if (!action.func) throw new Error("WarpNearExecutor: Query action must have a function name");
+    let queryAddress;
+    try {
+      if (!executable.destination) throw new Error("WarpNearExecutor: Query address is required");
+      queryAddress = executable.destination;
+    } catch {
+      throw new Error(`WarpNearExecutor: Invalid address for query: ${executable.destination}`);
+    }
+    try {
+      const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+      const args = nativeArgs.length > 0 ? nativeArgs : {};
+      const near = await (0, import_near_api_js3.connect)(this.nearConfig);
+      const account = await near.account(queryAddress);
+      const result = await account.viewFunction({
+        contractId: queryAddress,
+        methodName: action.func,
+        args
+      });
+      const { values, output } = await this.output.extractQueryOutput(
+        executable.warp,
+        Array.isArray(result) ? result : [result],
+        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: "success",
+        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: result },
+        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
+      };
+    }
+  }
+};
+
+// src/WarpNearExplorer.ts
+var WarpNearExplorer = class {
+  constructor(chain, config) {
+    this.chain = chain;
+    this.config = config;
+  }
+  getExplorers() {
+    const explorers = NearExplorerNames[this.config.env];
+    if (!explorers) {
+      return ["near_explorer" /* NearExplorer */];
+    }
+    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 = NearExplorerUrls[userPreference];
+      if (url2) return url2;
+    }
+    if (explorer) {
+      const url2 = NearExplorerUrls[explorer];
+      if (url2) return url2;
+    }
+    const primaryExplorer = this.getPrimaryExplorer();
+    const url = NearExplorerUrls[primaryExplorer];
+    return url || NearExplorerUrls[primaryExplorer];
+  }
+  getAccountUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    return `${baseUrl}${network}/accounts/${address}`;
+  }
+  getTransactionUrl(hash, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    return `${baseUrl}${network}/transactions/${hash}`;
+  }
+  getBlockUrl(blockNumber, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    return `${baseUrl}${network}/blocks/${blockNumber}`;
+  }
+  getAssetUrl(identifier, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    return `${baseUrl}${network}/tokens/${identifier}`;
+  }
+  getContractUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    return `${baseUrl}${network}/accounts/${address}`;
+  }
+  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 network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = NearExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}${network}/accounts/${address}`;
+      }
+    });
+    return urls;
+  }
+  getTransactionUrls(hash) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = NearExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}${network}/transactions/${hash}`;
+      }
+    });
+    return urls;
+  }
+  getAssetUrls(identifier) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = NearExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}${network}/tokens/${identifier}`;
+      }
+    });
+    return urls;
+  }
+  getContractUrls(address) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = NearExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}${network}/accounts/${address}`;
+      }
+    });
+    return urls;
+  }
+  getBlockUrls(blockNumber) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    const network = this.config.env === "mainnet" ? "" : `/${this.config.env}`;
+    explorers.forEach((explorer) => {
+      const url = NearExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}${network}/blocks/${blockNumber}`;
+      }
+    });
+    return urls;
+  }
+};
+
+// src/WarpNearWallet.ts
+var import_warps8 = require("@vleap/warps");
+var import_near_api_js6 = require("near-api-js");
+
+// src/providers/MnemonicWalletProvider.ts
+var import_crypto = require("@near-js/crypto");
+var bip39 = __toESM(require("@scure/bip39"), 1);
+var import_english = require("@scure/bip39/wordlists/english.js");
+var import_warps5 = require("@vleap/warps");
+var import_bs58 = __toESM(require("bs58"), 1);
+var import_near_api_js4 = require("near-api-js");
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = (0, import_warps5.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+    if (address) return address;
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return (0, import_crypto.keyToImplicitAddress)(publicKey.toString());
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return publicKey.toString();
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const keypair = this.getKeyPair();
+    return tx;
+  }
+  async signMessage(message) {
+    const keypair = this.getKeyPair();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = keypair.sign(messageBytes);
+    return import_bs58.default.encode(signature.signature);
+  }
+  getKeyPairInstance() {
+    return this.getKeyPair();
+  }
+  create(mnemonic) {
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const secretKey = seed.slice(0, 32);
+    const keyPair = import_near_api_js4.KeyPair.fromString(import_bs58.default.encode(secretKey));
+    const publicKey = keyPair.getPublicKey();
+    const accountId = (0, import_crypto.keyToImplicitAddress)(publicKey.toString());
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: accountId,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  generate() {
+    const mnemonic = bip39.generateMnemonic(import_english.wordlist);
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const secretKey = seed.slice(0, 32);
+    const keyPair = import_near_api_js4.KeyPair.fromString(import_bs58.default.encode(secretKey));
+    const publicKey = keyPair.getPublicKey();
+    const accountId = (0, import_crypto.keyToImplicitAddress)(publicKey.toString());
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: accountId,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  getKeyPair() {
+    if (this.keypair) return this.keypair;
+    const mnemonic = (0, import_warps5.getWarpWalletMnemonicFromConfig)(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const secretKey = seed.slice(0, 32);
+    this.keypair = import_near_api_js4.KeyPair.fromString(import_bs58.default.encode(secretKey));
+    return this.keypair;
+  }
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/PrivateKeyWalletProvider.ts
+var import_crypto2 = require("@near-js/crypto");
+var bip392 = __toESM(require("@scure/bip39"), 1);
+var import_warps6 = require("@vleap/warps");
+var import_bs582 = __toESM(require("bs58"), 1);
+var import_near_api_js5 = require("near-api-js");
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = (0, import_warps6.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+    if (address) return address;
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return (0, import_crypto2.keyToImplicitAddress)(publicKey.toString());
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return publicKey.toString();
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const keypair = this.getKeyPair();
+    return tx;
+  }
+  async signMessage(message) {
+    const keypair = this.getKeyPair();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = keypair.sign(messageBytes);
+    return import_bs582.default.encode(signature.signature);
+  }
+  getKeyPairInstance() {
+    return this.getKeyPair();
+  }
+  create(mnemonic) {
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const secretKey = seed.slice(0, 32);
+    const keyPair = import_near_api_js5.KeyPair.fromString(import_bs582.default.encode(secretKey));
+    const publicKey = keyPair.getPublicKey();
+    const accountId = (0, import_crypto2.keyToImplicitAddress)(publicKey.toString());
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: accountId,
+      privateKey: keyPair.toString(),
+      mnemonic: null
+    };
+  }
+  generate() {
+    const keyPair = import_near_api_js5.KeyPair.fromRandom("ed25519");
+    const publicKey = keyPair.getPublicKey();
+    const accountId = (0, import_crypto2.keyToImplicitAddress)(publicKey.toString());
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: accountId,
+      privateKey: keyPair.toString(),
+      mnemonic: null
+    };
+  }
+  getKeyPair() {
+    if (this.keypair) return this.keypair;
+    const privateKey = (0, import_warps6.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
+    if (!privateKey) throw new Error("No private key provided");
+    try {
+      return import_near_api_js5.KeyPair.fromString(privateKey);
+    } 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
+var import_warps7 = require("@vleap/warps");
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+  }
+  async getAddress() {
+    return (0, import_warps7.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return null;
+  }
+  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}`);
+  }
+  create(mnemonic) {
+    const address = (0, import_warps7.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  generate() {
+    const address = (0, import_warps7.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/WarpNearWallet.ts
+var WarpNearWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    const providerConfig = (0, import_warps8.getProviderConfig)(config, chain.name, config.env, chain.defaultApiUrl);
+    this.nearConfig = {
+      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
+      nodeUrl: providerConfig.url,
+      keyStore: new import_near_api_js6.keyStores.InMemoryKeyStore()
+    };
+    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`);
+    const accountId = this.getAddress();
+    if (!accountId) throw new Error("No account ID available");
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const keyPair = this.walletProvider.getKeyPairInstance();
+      await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
+      const near = await (0, import_near_api_js6.connect)(this.nearConfig);
+      const account = await near.account(accountId);
+      if (tx.signature) {
+        return tx;
+      }
+      const signedTx = await account.signAndSendTransaction({
+        receiverId: tx.receiverId,
+        actions: tx.actions
+      });
+      return {
+        ...tx,
+        signature: signedTx.transaction.hash,
+        transactionHash: signedTx.transaction.hash
+      };
+    }
+    throw new Error("Wallet provider does not support signing transactions");
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    const signedTxs = [];
+    for (const tx of txs) {
+      signedTxs.push(await this.signTransaction(tx));
+    }
+    return signedTxs;
+  }
+  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 await this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    const accountId = this.getAddress();
+    if (!accountId) throw new Error("No account ID available");
+    if (tx.transactionHash) {
+      return tx.transactionHash;
+    }
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const keyPair = this.walletProvider.getKeyPairInstance();
+      await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
+      const near = await (0, import_near_api_js6.connect)(this.nearConfig);
+      const account = await near.account(accountId);
+      const result = await account.signAndSendTransaction({
+        receiverId: tx.receiverId,
+        actions: tx.actions
+      });
+      return result.transaction.hash;
+    }
+    throw new Error("Wallet provider does not support sending transactions");
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  create(provider, mnemonic) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.create(mnemonic);
+  }
+  generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  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() {
+    (0, import_warps8.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}`);
+  }
+};
+
+// src/chains/common.ts
+var createNearAdapter = (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 WarpNearExecutor(config, chainInfos[config.env]),
+      output: new WarpNearOutput(config, chainInfos[config.env]),
+      serializer: new WarpNearSerializer(),
+      registry: fallback.registry,
+      explorer: new WarpNearExplorer(chainInfos[config.env], config),
+      abiBuilder: () => fallback.abiBuilder(),
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpNearDataLoader(config, chainInfos[config.env]),
+      wallet: new WarpNearWallet(config, chainInfos[config.env])
+    };
+  };
+};
+
+// src/chains/near.ts
+var NativeTokenNear = {
+  chain: "near",
+  identifier: "NEAR",
+  symbol: "NEAR",
+  name: "NEAR",
+  decimals: 24,
+  logoUrl: "https://joai.ai/images/tokens/near-black.svg"
+};
+var NearAdapter = createNearAdapter("near", {
+  mainnet: {
+    name: "near",
+    displayName: "NEAR Mainnet",
+    chainId: "mainnet",
+    blockTime: 1200,
+    addressHrp: "",
+    defaultApiUrl: "https://rpc.mainnet.near.org",
+    logoUrl: "https://joai.ai/images/chains/near-black.svg",
+    nativeToken: NativeTokenNear
+  },
+  testnet: {
+    name: "near",
+    displayName: "NEAR Testnet",
+    chainId: "testnet",
+    blockTime: 1200,
+    addressHrp: "",
+    defaultApiUrl: "https://rpc.testnet.near.org",
+    logoUrl: "https://joai.ai/images/chains/near-black.svg",
+    nativeToken: NativeTokenNear
+  },
+  devnet: {
+    name: "near",
+    displayName: "NEAR Devnet",
+    chainId: "testnet",
+    blockTime: 1200,
+    addressHrp: "",
+    defaultApiUrl: "https://rpc.testnet.near.org",
+    logoUrl: "https://joai.ai/images/chains/near-black.svg",
+    nativeToken: NativeTokenNear
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExplorerUrls,
+  KnownTokens,
+  NativeTokenNear,
+  NearAdapter,
+  NearExplorerMap,
+  NearExplorerNames,
+  NearExplorerUrls,
+  NearExplorers,
+  NearTokens,
+  WarpNearConstants,
+  WarpNearDataLoader,
+  WarpNearExecutor,
+  WarpNearExplorer,
+  WarpNearOutput,
+  WarpNearSerializer,
+  WarpNearWallet,
+  findKnownTokenById,
+  getKnownTokensForChain
+});
+//# sourceMappingURL=index.js.map