@hyperbridge/sdk 1.9.4 → 1.9.6

package/dist/node/index.js

@@ -3612,6 +3612,8 @@ var Chains = /* @__PURE__ */ ((Chains3) => {
   Chains3["POLKADOT_ASSET_HUB_PASEO"] = "EVM-420420417";
   Chains3["TRON_MAINNET"] = "EVM-728126428";
   Chains3["TRON_NILE"] = "EVM-3448148188";
+  Chains3["PHAROS_MAINNET"] = "EVM-688600";
+  Chains3["PHAROS_ATLANTIC"] = "EVM-688689";
   return Chains3;
 })(Chains || {});
 var polkadotAssetHubPaseo = defineChain({
@@ -3625,6 +3627,22 @@ var polkadotAssetHubPaseo = defineChain({
     default: { name: "Routescan", url: "https://polkadot.testnet.routescan.io" }
   }
 });
+var pharosMainnet = defineChain({
+  id: 688600,
+  name: "Pharos Mainnet",
+  nativeCurrency: { name: "PHRS", symbol: "PHRS", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://atlantic.dplabs-internal.com"] }
+  }
+});
+var pharosAtlantic = defineChain({
+  id: 688689,
+  name: "Pharos Atlantic Testnet",
+  nativeCurrency: { name: "PHRS", symbol: "PHRS", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://atlantic.dplabs-internal.com"] }
+  }
+});
 var tronNile = defineChain({
   id: 3448148188,
   name: "TRON Nile Testnet",
@@ -4343,6 +4361,30 @@ var chainConfigs = {
     defaultRpcUrl: "https://testnet-asset-hub-eth-rpc.polkadot.io",
     consensusStateId: "PAS0",
     coingeckoId: "polkadot"
+  },
+  688600: {
+    chainId: 688600,
+    stateMachineId: "EVM-688600" /* PHAROS_MAINNET */,
+    viemChain: pharosMainnet,
+    wrappedNativeDecimals: 18,
+    addresses: {
+      Host: "0x0000000000000000000000000000000000000000"
+    },
+    consensusStateId: "PHAR",
+    coingeckoId: "pharos"
+  },
+  688689: {
+    chainId: 688689,
+    stateMachineId: "EVM-688689" /* PHAROS_ATLANTIC */,
+    viemChain: pharosAtlantic,
+    wrappedNativeDecimals: 18,
+    addresses: {
+      TokenGateway: "0x451bDd8273839AD0Ec7F4Fa798E8B3DABb223fD8",
+      Host: "0xED54E9b64043c389173316B6351Bd25491060eA8",
+      IntentGatewayV2: "0xb8039832c6c9266F928d038eA49A8a169300C670"
+    },
+    consensusStateId: "PHAR",
+    coingeckoId: "pharos"
   }
 };
 var configsByStateMachineId = Object.fromEntries(
@@ -5493,7 +5535,9 @@ var chains = {
   [unichain.id]: unichain,
   [tron.id]: tron,
   [tronNile.id]: tronNile,
-  [polkadotAssetHubPaseo.id]: polkadotAssetHubPaseo
+  [polkadotAssetHubPaseo.id]: polkadotAssetHubPaseo,
+  [pharosMainnet.id]: pharosMainnet,
+  [pharosAtlantic.id]: pharosAtlantic
 };
 var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
 var EvmChain = class _EvmChain {
@@ -5534,8 +5578,12 @@ var EvmChain = class _EvmChain {
       // Gnosis Chiado
       420420417: "PAS0",
       // Polkadot Asset Hub (Paseo)
-      420420419: "DOT0"
+      420420419: "DOT0",
       // Polkadot Asset Hub (Polkadot)
+      688600: "PHAR",
+      // Pharos Mainnet
+      688689: "PHAR"
+      // Pharos Atlantic (Testnet)
     };
     if (!params.consensusStateId) {
       params.consensusStateId = defaultConsensusStateIds[params.chainId];
@@ -7762,6 +7810,312 @@ var PolkadotHubChain = class _PolkadotHubChain {
     return this.evm.getTransactionReceipt(hash);
   }
 };
+var PharosProofNodeCodec = Struct({
+  proofNode: Vector(u8),
+  nextBeginOffset: u32,
+  nextEndOffset: u32
+});
+var SiblingLeftmostLeafProofCodec = Struct({
+  slotIndex: u8,
+  leftmostLeafKey: Vector(u8),
+  proofPath: Vector(PharosProofNodeCodec)
+});
+var NonExistenceProofCodec = Struct({
+  proofNodes: Vector(PharosProofNodeCodec),
+  siblingProofs: Vector(SiblingLeftmostLeafProofCodec)
+});
+var AccountProofDataCodec = Struct({
+  proofNodes: Vector(PharosProofNodeCodec),
+  rawValue: Vector(u8)
+});
+var PharosStateProof = Struct({
+  storageProof: Vector(Tuple(Vector(u8), Vector(PharosProofNodeCodec))),
+  storageValues: Vector(Tuple(Vector(u8), Vector(u8))),
+  nonExistenceProofs: Vector(Tuple(Vector(u8), NonExistenceProofCodec)),
+  accountProofs: Vector(Tuple(Vector(u8), AccountProofDataCodec))
+});
+
+// src/chains/pharos.ts
+var EvmHttpRpc = class {
+  constructor(url) {
+    this.url = url;
+  }
+  url;
+  async call(method, params = []) {
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params })
+    });
+    if (!response.ok) {
+      throw new Error(`Pharos RPC HTTP error: ${response.status}`);
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(`Pharos RPC error: ${json.error.message}`);
+    }
+    if (json.result === void 0) {
+      throw new Error("Pharos RPC: missing result");
+    }
+    return json.result;
+  }
+};
+function padTo32Bytes(hex) {
+  const bytes = hexToBytes(hex);
+  if (bytes.length > 32) {
+    throw new Error(`Pharos value exceeds 32 bytes: ${hex}`);
+  }
+  const out = new Uint8Array(32);
+  out.set(bytes, 32 - bytes.length);
+  return out;
+}
+function rpcToProofNodes(nodes) {
+  return nodes.map((n) => ({
+    proofNode: Array.from(hexToBytes(n.proofNode)),
+    nextBeginOffset: n.nextBeginOffset,
+    nextEndOffset: n.nextEndOffset
+  }));
+}
+function rpcToSiblingProofs(siblings) {
+  return (siblings ?? []).map((s) => ({
+    slotIndex: s.slotIndex,
+    leftmostLeafKey: Array.from(hexToBytes(s.leftmostLeafKey)),
+    proofPath: rpcToProofNodes(s.proofPath)
+  }));
+}
+function blockTag(at) {
+  return at === void 0 ? "latest" : `0x${at.toString(16)}`;
+}
+function newAccumulator() {
+  return {
+    storageProof: /* @__PURE__ */ new Map(),
+    storageValues: /* @__PURE__ */ new Map(),
+    nonExistenceProofs: /* @__PURE__ */ new Map(),
+    accountProofs: /* @__PURE__ */ new Map()
+  };
+}
+function hexKey2(bytes) {
+  return bytesToHex(bytes);
+}
+function mapToEntries(m) {
+  const entries = [];
+  for (const [k, v] of m.entries()) {
+    entries.push([Array.from(hexToBytes(k)), v]);
+  }
+  return entries;
+}
+function encodeAccumulator(acc) {
+  const encoded = PharosStateProof.enc({
+    storageProof: mapToEntries(acc.storageProof),
+    storageValues: mapToEntries(acc.storageValues),
+    nonExistenceProofs: mapToEntries(acc.nonExistenceProofs),
+    accountProofs: mapToEntries(acc.accountProofs)
+  });
+  return bytesToHex(encoded);
+}
+var PharosChain = class _PharosChain {
+  constructor(params, evm) {
+    this.params = params;
+    this.evm = evm;
+    this.rpc = new EvmHttpRpc(replaceWebsocketWithHttp(params.rpcUrl));
+  }
+  params;
+  evm;
+  rpc;
+  static fromParams(params) {
+    const evm = EvmChain.fromParams(params);
+    return new _PharosChain(params, evm);
+  }
+  /**
+   * Creates a `PharosChain` by auto-detecting the EVM chain ID and `IsmpHost`
+   * address via {@link EvmChain.create}.
+   *
+   * @param rpcUrl - HTTP(S) JSON-RPC URL of the Pharos node
+   * @param bundlerUrl - Optional ERC-4337 bundler URL forwarded to `EvmChain.create`
+   */
+  static async create(rpcUrl, bundlerUrl) {
+    const evm = await EvmChain.create(rpcUrl, bundlerUrl);
+    const chainId = Number.parseInt(evm.config.stateMachineId.replace(/^EVM-/, ""), 10);
+    if (!Number.isFinite(chainId)) {
+      throw new Error(`Unexpected EVM stateMachineId: ${evm.config.stateMachineId}`);
+    }
+    const params = {
+      chainId,
+      rpcUrl: evm.config.rpcUrl,
+      host: evm.config.host,
+      consensusStateId: evm.config.consensusStateId,
+      bundlerUrl: evm.bundlerUrl
+    };
+    return new _PharosChain(params, evm);
+  }
+  get client() {
+    return this.evm.client;
+  }
+  get host() {
+    return this.evm.host;
+  }
+  get bundlerUrl() {
+    return this.evm.bundlerUrl;
+  }
+  get configService() {
+    return this.evm.configService;
+  }
+  get config() {
+    return this.evm.config;
+  }
+  hostAddress() {
+    return getAddress(this.evm.host);
+  }
+  /**
+   * Fetch a storage proof for `slotKeys` under `address` at the given block and
+   * merge the response into the supplied accumulator. Mirrors the membership
+   * proof path of `PharosEvmClient::fetch_pharos_proof` on the Rust side.
+   */
+  async fetchStorageProofInto(acc, at, address, slotKeys) {
+    const rpcProof = await this.rpc.call("eth_getProof", [
+      address,
+      slotKeys,
+      blockTag(at)
+    ]);
+    for (const sp of rpcProof.storageProof) {
+      const slotKey = hexKey2(padTo32Bytes(sp.key));
+      if (sp.isExist) {
+        acc.storageProof.set(slotKey, rpcToProofNodes(sp.proof));
+        acc.storageValues.set(slotKey, Array.from(padTo32Bytes(sp.value)));
+      } else {
+        acc.nonExistenceProofs.set(slotKey, {
+          proofNodes: rpcToProofNodes(sp.proof),
+          siblingProofs: rpcToSiblingProofs(sp.siblingLeftmostLeafProofs)
+        });
+      }
+    }
+  }
+  /**
+   * Fetch an account proof (no storage keys) at the given block and record it on
+   * the accumulator. Mirrors `PharosEvmClient::fetch_account_proof`.
+   */
+  async fetchAccountProofInto(acc, at, address) {
+    const rpcProof = await this.rpc.call("eth_getProof", [
+      address,
+      [],
+      blockTag(at)
+    ]);
+    const addrBytes = hexToBytes(address);
+    acc.accountProofs.set(hexKey2(addrBytes), {
+      proofNodes: rpcToProofNodes(rpcProof.accountProof),
+      rawValue: Array.from(hexToBytes(rpcProof.rawValue))
+    });
+  }
+  timestamp() {
+    return this.evm.timestamp();
+  }
+  requestReceiptKey(commitment) {
+    return this.evm.requestReceiptKey(commitment);
+  }
+  queryRequestReceipt(commitment) {
+    return this.evm.queryRequestReceipt(commitment);
+  }
+  /**
+   * Query a Pharos state proof for the request/response commitments in `message`.
+   *
+   * Mirrors `PharosEvmClient::query_requests_proof` / `query_responses_proof`:
+   * for every commitment we derive the second storage slot (`slot1` from
+   * {@link requestCommitmentKey} / {@link responseCommitmentKey}) and request it
+   * from the ISMP host via `eth_getProof`.
+   */
+  async queryProof(message, _counterparty, at) {
+    if (at === void 0) {
+      throw new Error("PharosChain.queryProof requires an explicit block height `at`");
+    }
+    const slotKeys = "Requests" in message ? message.Requests.map((c) => requestCommitmentKey(c).slot1) : message.Responses.map((c) => responseCommitmentKey(c));
+    const acc = newAccumulator();
+    await this.fetchStorageProofInto(acc, at, this.hostAddress(), slotKeys);
+    return encodeAccumulator(acc);
+  }
+  /**
+   * Query a Pharos state proof for arbitrary keys.
+   *
+   * Supports the same key shapes as `PharosEvmClient::query_state_proof`:
+   *   - 32-byte keys: ISMP host storage slots
+   *   - 52-byte keys: `address (20) || slot (32)` grouped by contract
+   *   - 20-byte keys: account queries (proves the account leaf itself)
+   *
+   * If `address` is provided, all keys are treated as 32-byte slots under that
+   * contract (matching the `EvmChain.queryStateProof` contract-override shape).
+   */
+  async queryStateProof(at, keys, address) {
+    const acc = newAccumulator();
+    if (address !== void 0) {
+      await this.fetchStorageProofInto(acc, at, getAddress(address), keys);
+      return encodeAccumulator(acc);
+    }
+    const keyBytes = keys.map((k) => hexToBytes(k));
+    const hostAddr = this.hostAddress();
+    const ismpSlots = [];
+    const groups = /* @__PURE__ */ new Map();
+    const accountQueries = [];
+    for (const bytes of keyBytes) {
+      if (bytes.length === 32) {
+        ismpSlots.push(bytesToHex(bytes));
+      } else if (bytes.length === 52) {
+        const addr = getAddress(bytesToHex(bytes.subarray(0, 20)));
+        const slot = bytesToHex(bytes.subarray(20, 52));
+        const list = groups.get(addr) ?? [];
+        list.push(slot);
+        groups.set(addr, list);
+      } else if (bytes.length === 20) {
+        accountQueries.push(getAddress(bytesToHex(bytes)));
+      } else {
+        throw new Error(
+          `PharosChain.queryStateProof: unsupported key length ${bytes.length}; expected 20, 32, or 52`
+        );
+      }
+    }
+    if (ismpSlots.length > 0) {
+      await this.fetchStorageProofInto(acc, at, hostAddr, ismpSlots);
+    }
+    for (const [addr, slots] of groups) {
+      await this.fetchStorageProofInto(acc, at, addr, slots);
+    }
+    for (const addr of accountQueries) {
+      await this.fetchAccountProofInto(acc, at, addr);
+    }
+    return encodeAccumulator(acc);
+  }
+  encode(message) {
+    return this.evm.encode(message);
+  }
+  latestStateMachineHeight(stateMachineId) {
+    return this.evm.latestStateMachineHeight(stateMachineId);
+  }
+  challengePeriod(stateMachineId) {
+    return this.evm.challengePeriod(stateMachineId);
+  }
+  stateMachineUpdateTime(stateMachineHeight) {
+    return this.evm.stateMachineUpdateTime(stateMachineHeight);
+  }
+  getHostNonce() {
+    return this.evm.getHostNonce();
+  }
+  quoteNative(request, fee) {
+    return this.evm.quoteNative(request, fee);
+  }
+  getFeeTokenWithDecimals() {
+    return this.evm.getFeeTokenWithDecimals();
+  }
+  getPlaceOrderCalldata(txHash, intentGatewayAddress) {
+    return this.evm.getPlaceOrderCalldata(txHash, intentGatewayAddress);
+  }
+  estimateGas(request) {
+    return this.evm.estimateGas(request);
+  }
+  broadcastTransaction(signedTransaction) {
+    return this.evm.broadcastTransaction(signedTransaction);
+  }
+  getTransactionReceipt(hash) {
+    return this.evm.getTransactionReceipt(hash);
+  }
+};
 function getPeakPosByHeight(height) {
   return (1n << BigInt(height + 1)) - 2n;
 }
@@ -15436,7 +15790,7 @@ var OrderExecutor = class {
   async *executeOrder(options) {
     const { order, sessionPrivateKey, auctionTimeMs, pollIntervalMs = DEFAULT_POLL_INTERVAL, solver } = options;
     const commitment = order.id;
-    const isSameChain = order.source === order.destination;
+    order.source === order.destination;
     if (!this.ctx.intentsCoprocessor) {
       yield { status: "FAILED", error: "IntentsCoprocessor required for order execution" };
       return;
@@ -15465,10 +15819,15 @@ var OrderExecutor = class {
     });
     const deadlineTimeout = this.deadlineStream(order.deadline, commitment);
     const combined = mergeRace(deadlineTimeout, executionStream);
-    for await (const update of combined) {
-      yield update;
-      if (update.status === "EXPIRED" || update.status === "FILLED") return;
-      if (update.status === "BID_SELECTED" && !isSameChain) return;
+    try {
+      for await (const update of combined) {
+        yield update;
+        if (update.status === "EXPIRED" || update.status === "FILLED") return;
+      }
+    } finally {
+      console.log(`[OrderExecutor] Tearing down streams for commitment=${commitment}`);
+      await executionStream.return(void 0);
+      await deadlineTimeout.return(void 0);
     }
   }
   /**
@@ -15489,6 +15848,12 @@ var OrderExecutor = class {
       targetAssets
     } = params;
     let { totalFilledAssets, remainingAssets } = params;
+    const MAX_BID_ATTEMPTS = 2;
+    const bidFailCounts = /* @__PURE__ */ new Map();
+    const isFreshBid = (bid) => {
+      const key = userOpHashKey(bid.userOp);
+      return !usedUserOps.has(key) && (bidFailCounts.get(key) ?? 0) < MAX_BID_ATTEMPTS;
+    };
     const solverLockStartTime = Date.now();
     yield { status: "AWAITING_BIDS", commitment, totalFilledAssets, remainingAssets };
     try {
@@ -15516,7 +15881,7 @@ var OrderExecutor = class {
         let freshBids;
         try {
           const bids = await this.fetchBids({ commitment, solver, solverLockStartTime });
-          freshBids = bids.filter((bid) => !usedUserOps.has(userOpHashKey(bid.userOp)));
+          freshBids = bids.filter(isFreshBid);
         } catch {
           await sleep(pollIntervalMs);
           continue;
@@ -15544,6 +15909,14 @@ var OrderExecutor = class {
             remainingAssets,
             error: `Failed to select bid and submit: ${err instanceof Error ? err.message : String(err)}`
           };
+          try {
+            const sorted = await this.bidManager.validateAndSortBids(freshBids, order);
+            if (sorted.length > 0) {
+              const key = userOpHashKey(sorted[0].bid.userOp);
+              bidFailCounts.set(key, (bidFailCounts.get(key) ?? 0) + 1);
+            }
+          } catch {
+          }
           await sleep(pollIntervalMs);
           continue;
         }
@@ -19146,9 +19519,9 @@ async function fetchLocalAssetId(params) {
   const palletPrefix = xxhashAsU8a("TokenGateway", 128);
   const storagePrefix = xxhashAsU8a("LocalAssets", 128);
   const full_key = new Uint8Array([...palletPrefix, ...storagePrefix, ...assetId]);
-  const hexKey2 = bytesToHex(full_key);
+  const hexKey3 = bytesToHex(full_key);
   const storage_value = await api.rpc.state.getStorage(
-    hexKey2
+    hexKey3
   );
   if (storage_value.isSome) {
     const assetId2 = storage_value.value.toU8a();
@@ -19421,6 +19794,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, IndexerClient, IntentGateway, ABI7 as IntentGatewayV2ABI, IntentOrderStatus, IntentsCoprocessor, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, PolkadotHubChain, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, IndexerClient, IntentGateway, ABI7 as IntentGatewayV2ABI, IntentOrderStatus, IntentsCoprocessor, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, PharosChain, PolkadotHubChain, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map