damm-sdk 1.4.18 → 1.4.21

package/dist/index.cjs

@@ -150,9 +150,14 @@ var init_base = __esm(() => {
 });
 
 // node_modules/viem/_esm/errors/data.js
-var SizeExceedsPaddingSizeError;
+var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm(() => {
   init_base();
+  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size: size2 }) {
+      super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+    }
+  };
   SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
     constructor({ size: size2, targetSize, type }) {
       super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
@@ -214,6 +219,25 @@ var init_encoding = __esm(() => {
   };
 });
 
+// node_modules/viem/_esm/utils/data/trim.js
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  let sliceLength = 0;
+  for (let i = 0;i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  if (typeof hexOrBytes === "string") {
+    if (data.length === 1 && dir === "right")
+      data = `${data}0`;
+    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+  }
+  return data;
+}
+
 // node_modules/viem/_esm/utils/encoding/fromHex.js
 function assertSize(hexOrBytes, { size: size2 }) {
   if (size(hexOrBytes) > size2)
@@ -795,6 +819,67 @@ var init_isAddress = __esm(() => {
   isAddressCache = /* @__PURE__ */ new LruMap(8192);
 });
 
+// node_modules/viem/_esm/utils/data/concat.js
+function concatHex(values) {
+  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+
+// node_modules/viem/_esm/utils/data/slice.js
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: "start",
+      size: size(value)
+    });
+}
+function assertEndOffset(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: "end",
+      size: size(value)
+    });
+  }
+}
+function sliceHex(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+var init_slice = __esm(() => {
+  init_data();
+  init_size();
+});
+
+// node_modules/viem/_esm/utils/encoding/fromBytes.js
+function bytesToBigInt(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes, opts);
+  return hexToBigInt(hex, opts);
+}
+function bytesToNumber(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes, opts);
+  return hexToNumber(hex, opts);
+}
+function bytesToString(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes, { dir: "right" });
+  }
+  return new TextDecoder().decode(bytes);
+}
+var init_fromBytes = __esm(() => {
+  init_fromHex();
+  init_toHex();
+});
+
 // node_modules/viem/_esm/constants/number.js
 var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
 var init_number = __esm(() => {
@@ -1686,7 +1771,7 @@ var init_buffer = __esm(() => {
         return false;
     }
   };
-  Buffer2.concat = function concat(list, length) {
+  Buffer2.concat = function concat2(list, length) {
     if (!Array.isArray(list))
       throw new TypeError('"list" argument must be an Array of Buffers');
     if (list.length === 0)
@@ -1857,7 +1942,7 @@ var init_buffer = __esm(() => {
   Buffer2.prototype.toJSON = function toJSON() {
     return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
   };
-  Buffer2.prototype.slice = function slice(start, end) {
+  Buffer2.prototype.slice = function slice2(start, end) {
     let len2 = this.length;
     if (start = ~~start, end = end === undefined ? len2 : ~~end, start < 0) {
       if (start += len2, start < 0)
@@ -7369,7 +7454,7 @@ var require_hash = __commonJS((exports2) => {
   hash.ripemd160 = hash.ripemd.ripemd160;
 });
 
-// node_modules/aes-js/index.js
+// node_modules/@ethersproject/json-wallets/node_modules/aes-js/index.js
 var require_aes_js = __commonJS((exports2, module2) => {
   (function(root) {
     function checkInt2(value) {
@@ -7436,7 +7521,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
         }
         return coerceArray(result);
       }
-      function fromBytes(bytes) {
+      function fromBytes2(bytes) {
         var result = [], i2 = 0;
         while (i2 < bytes.length) {
           var c = bytes[i2];
@@ -7455,7 +7540,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
       }
       return {
         toBytes: toBytes3,
-        fromBytes
+        fromBytes: fromBytes2
       };
     }();
     var convertHex = function() {
@@ -7467,7 +7552,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
         return result;
       }
       var Hex = "0123456789abcdef";
-      function fromBytes(bytes) {
+      function fromBytes2(bytes) {
         var result = [];
         for (var i2 = 0;i2 < bytes.length; i2++) {
           var v = bytes[i2];
@@ -7477,7 +7562,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
       }
       return {
         toBytes: toBytes3,
-        fromBytes
+        fromBytes: fromBytes2
       };
     }();
     var numberOfRounds = { 16: 10, 24: 12, 32: 14 };
@@ -11832,7 +11917,7 @@ var require_lib2 = __commonJS((exports2) => {
     return logger47.throwArgumentError("invalid arrayify value", "value", value);
   }
   exports2.arrayify = arrayify2;
-  function concat3(items) {
+  function concat4(items) {
     var objects = items.map(function(item) {
       return arrayify2(item);
     });
@@ -11846,7 +11931,7 @@ var require_lib2 = __commonJS((exports2) => {
     }, 0);
     return addSlice2(result);
   }
-  exports2.concat = concat3;
+  exports2.concat = concat4;
   function stripZeros2(value) {
     var result = arrayify2(value);
     if (result.length === 0) {
@@ -12120,7 +12205,7 @@ var require_lib2 = __commonJS((exports2) => {
   exports2.splitSignature = splitSignature2;
   function joinSignature2(signature2) {
     signature2 = splitSignature2(signature2);
-    return hexlify2(concat3([
+    return hexlify2(concat4([
       signature2.r,
       signature2.s,
       signature2.recoveryParam ? "0x1c" : "0x1b"
@@ -23219,8 +23304,8 @@ var require_stream = __commonJS((exports2, module2) => {
       consume(n, hasStrings) {
         let data = this.head.data;
         if (n < data.length) {
-          let slice2 = data.slice(0, n);
-          return this.head.data = data.slice(n), slice2;
+          let slice3 = data.slice(0, n);
+          return this.head.data = data.slice(n), slice3;
         }
         if (n === data.length)
           return this.shift();
@@ -44813,6 +44898,8 @@ var require_utils6 = __commonJS((exports2) => {
 var exports_src = {};
 __export(exports_src, {
   wrapEthTrx: () => wrapEthTrx,
+  wormholeTransferTrx: () => wormholeTransferTrx,
+  wormholeReceiveMessageTrx: () => wormholeReceiveMessageTrx,
   withdrawMorphoVaultTrx: () => withdrawMorphoVaultTrx,
   withdrawMorphoVaultAssetTrx: () => withdrawMorphoVaultAssetTrx,
   withdrawMorphoBlueTrx: () => withdrawMorphoBlueTrx,
@@ -44890,6 +44977,8 @@ __export(exports_src, {
   pendleMerkleClaimTrx: () => pendleMerkleClaimTrx,
   pendleMerkleClaimCalldata: () => pendleMerkleClaimCalldata,
   pauseVaultTrx: () => pauseVaultTrx,
+  parseSignedQuote: () => parseSignedQuote,
+  normalizeEmitterForVaaLookup: () => normalizeEmitterForVaaLookup,
   merklClaimTrx: () => merklClaimTrx,
   merklClaimCalldata: () => merklClaimCalldata,
   merklAbi: () => merkl_distributor_abi_default,
@@ -44899,9 +44988,18 @@ __export(exports_src, {
   lagoonV1FactoryAbi: () => factory_abi_default,
   initiateVaultClosingTrx: () => initiateVaultClosingTrx,
   gnosisTrx: () => gnosisTrx,
+  getWormholeScanApiUrl: () => getWormholeScanApiUrl,
+  getWormholeChainId: () => getWormholeChainId,
   getGnosisTrxSimulationResult: () => getGnosisTrxSimulationResult,
+  getExecutorApiUrl: () => getExecutorApiUrl,
+  getCCIPChainSelector: () => getCCIPChainSelector,
+  getAxelarGmpApiUrl: () => getAxelarGmpApiUrl,
   getAddressOrThrow: () => getAddressOrThrow,
   getAddressNameOrThrow: () => getAddressNameOrThrow,
+  fetchWormholeVAA: () => fetchWormholeVAA,
+  fetchExecutorTxStatus: () => fetchExecutorTxStatus,
+  fetchExecutorQuote: () => fetchExecutorQuote,
+  fetchAxelarGmpStatus: () => fetchAxelarGmpStatus,
   executeTrx: () => executeTrx,
   executeNextTx: () => executeNextTx,
   executeGnosisTrx: () => executeGnosisTrx,
@@ -44909,6 +45007,7 @@ __export(exports_src, {
   execWithRoleReturnDataTrx: () => execWithRoleReturnDataTrx,
   execTransactionWithDelay: () => execTransactionWithDelay,
   execTransactionFromModuleTrx: () => execTransactionFromModuleTrx,
+  encodeTransceiverInstructions: () => encodeTransceiverInstructions,
   depositToLendleTrx: () => depositToLendleTrx,
   depositSyrupVaultTrx: () => depositSyrupVaultTrx,
   depositOriginArmWethTrx: () => depositOriginArmWethTrx,
@@ -44919,14 +45018,21 @@ __export(exports_src, {
   depositGearboxVaultTrx: () => depositGearboxVaultTrx,
   depositForBurnToCctpTrx: () => depositForBurnToCctpTrx,
   depositFluidLiteTrx: () => depositFluidLiteTrx,
+  decodeVaaBase64: () => decodeVaaBase64,
+  decodeQuoteDeliveryPriceResult: () => decodeQuoteDeliveryPriceResult,
   createVaultProxyTrx: () => createVaultProxyTrx,
   createOrderTrx: () => createOrderTrx,
   createCall: () => createCall,
   closeVaultTrx: () => closeVaultTrx,
   claimRedeemOriginArmTrx: () => claimRedeemOriginArmTrx,
   claimFundingFeesTrx: () => claimFundingFeesTrx,
+  ccipSendTrx: () => ccipSendTrx,
   cancelOrderTrx: () => cancelOrderTrx,
   calculateDeterministicVaultAddress: () => calculateDeterministicVaultAddress,
+  buildWormholeTransferArgsFromAvatar: () => buildWormholeTransferArgsFromAvatar,
+  buildRelayInstructions: () => buildRelayInstructions,
+  buildMonadDefaultTransceiverInstructions: () => buildMonadDefaultTransceiverInstructions,
+  buildCCIPMessage: () => buildCCIPMessage,
   borrowMorphoBlueTrx: () => borrowMorphoBlueTrx,
   borrowFromLendleTrx: () => borrowFromLendleTrx,
   borrowFromAaveV3Trx: () => borrowFromAaveV3Trx,
@@ -44934,11 +45040,18 @@ __export(exports_src, {
   approveTokenThroughPermit2: () => approveTokenThroughPermit2,
   approveErc721Trx: () => approveErc721Trx,
   approveERC20Trx: () => approveERC20Trx,
+  addressToBytes32: () => addressToBytes32,
   addToVaultWhitelistTrx: () => addToVaultWhitelistTrx,
   ZodiacRolesAbi: () => zodiac_roles_abi_default,
   ZodiacDelayAbi: () => zodiac_delay_abi_default,
   ZERO_ADDRESS: () => ZERO_ADDRESS,
   WrapEthCalldata: () => WrapEthCalldata,
+  WormholeTransferCalldata: () => WormholeTransferCalldata,
+  WormholeTransceiverAbi: () => wormhole_transceiver_abi_default,
+  WormholeReceiveMessageCalldata: () => WormholeReceiveMessageCalldata,
+  WormholeMultiNttAbi: () => wormhole_multi_ntt_abi_default,
+  WormholeGmpManagerAbi: () => gmp_manager_abi_default,
+  WormholeCalculateFeeCalldata: () => WormholeCalculateFeeCalldata,
   WithdrawMorphoVaultCalldata: () => WithdrawMorphoVaultCalldata,
   WithdrawMorphoVaultAssetCalldata: () => WithdrawMorphoVaultAssetCalldata,
   WithdrawMorphoBlueCalldata: () => WithdrawMorphoBlueCalldata,
@@ -44950,6 +45063,11 @@ __export(exports_src, {
   WithdrawFluidLiteCalldata: () => WithdrawFluidLiteCalldata,
   WithdrawCollateralMorphoBlueCalldata: () => WithdrawCollateralMorphoBlueCalldata,
   WethAbi: () => weth_abi_default,
+  WORMHOLE_EXECUTOR_API_TESTNET: () => WORMHOLE_EXECUTOR_API_TESTNET,
+  WORMHOLE_EXECUTOR_API_MAINNET: () => WORMHOLE_EXECUTOR_API_MAINNET,
+  WORMHOLE_CHAIN_IDS: () => WORMHOLE_CHAIN_IDS,
+  WORMHOLESCAN_API_TESTNET: () => WORMHOLESCAN_API_TESTNET,
+  WORMHOLESCAN_API_MAINNET: () => WORMHOLESCAN_API_MAINNET,
   UpdateTotalAssetsLifespanCalldata: () => UpdateTotalAssetsLifespanCalldata,
   UpdateOrderCalldata: () => UpdateOrderCalldata,
   UnwrapWethCalldata: () => UnwrapWethCalldata,
@@ -45033,6 +45151,8 @@ __export(exports_src, {
   MorphoBlueAbi: () => morpho_blue_abi_default,
   LendlePoolAbi: () => lendle_pool_abi_default,
   InitiateClosingCalldata: () => InitiateClosingCalldata,
+  GmpManagerQuoteDeliveryPriceTrx: () => GmpManagerQuoteDeliveryPriceTrx,
+  GmpManagerQuoteDeliveryPriceCalldata: () => GmpManagerQuoteDeliveryPriceCalldata,
   GMX_EXCHANGE_ROUTER_ARB: () => GMX_EXCHANGE_ROUTER_ARB,
   GMXExchangeRouterAbi: () => exchange_router_abi_default,
   FluidLiteAbi: () => fluid_lite_abi_default,
@@ -45052,6 +45172,7 @@ __export(exports_src, {
   DelayedTransactionCalldata: () => DelayedTransactionCalldata,
   DecreasePositionSwapType: () => DecreasePositionSwapType,
   DELEGATE_CALL_OP_CODE: () => DELEGATE_CALL_OP_CODE,
+  DEFAULT_NTT_REDEMPTION_GAS_LIMIT: () => DEFAULT_NTT_REDEMPTION_GAS_LIMIT,
   DAI_ARB: () => DAI_ARB,
   CreateVaultProxyCalldata: () => CreateVaultProxyCalldata,
   CreateOrderCalldata: () => CreateOrderCalldata,
@@ -45062,6 +45183,11 @@ __export(exports_src, {
   CctpTokenMessengerV2Abi: () => token_messenger_v2_abi_default,
   CctpMessageTransmitterV2Abi: () => message_transmitter_v2_abi_default,
   CancelOrderCalldata: () => CancelOrderCalldata,
+  CCIP_CHAIN_SELECTORS: () => CCIP_CHAIN_SELECTORS,
+  CCIPSendCalldata: () => CCIPSendCalldata,
+  CCIPRouterAbi: () => ccip_router_abi_default,
+  CCIPGetFeeTrx: () => CCIPGetFeeTrx,
+  CCIPGetFeeCalldata: () => CCIPGetFeeCalldata,
   CALL_OP_CODE: () => CALL_OP_CODE,
   BorrowMorphoBlueCalldata: () => BorrowMorphoBlueCalldata,
   BorrowFromLendleCalldata: () => BorrowFromLendleCalldata,
@@ -45071,7 +45197,9 @@ __export(exports_src, {
   AddToVaultWhitelistCalldata: () => AddToVaultWhitelistCalldata,
   Actions: () => Actions2,
   AaveL2PoolAbi: () => aave_pool_L2_abi_default,
-  AaveL1PoolAbi: () => aave_pool_abi_default
+  AaveL1PoolAbi: () => aave_pool_abi_default,
+  AXELAR_GMP_API_TESTNET: () => AXELAR_GMP_API_TESTNET,
+  AXELAR_GMP_API_MAINNET: () => AXELAR_GMP_API_MAINNET
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -45468,10 +45596,14 @@ var erc721_abi_default = [
 var zeroAddress = "0x0000000000000000000000000000000000000000";
 // node_modules/viem/_esm/index.js
 init_number();
+init_toBytes();
 init_toHex();
+init_fromBytes();
 init_fromHex();
 init_getAddress();
 init_pad();
+init_size();
+init_slice();
 
 // src/types/primitives.ts
 var createCall = (call) => {
@@ -45891,7 +46023,7 @@ function arrayify(value, options) {
   }
   return logger.throwArgumentError("invalid arrayify value", "value", value);
 }
-function concat2(items) {
+function concat3(items) {
   const objects = items.map((item) => arrayify(item));
   const length = objects.reduce((accum, item) => accum + item.length, 0);
   const result = new Uint8Array(length);
@@ -46163,7 +46295,7 @@ function splitSignature(signature) {
 }
 function joinSignature(signature) {
   signature = splitSignature(signature);
-  return hexlify(concat2([
+  return hexlify(concat3([
     signature.r,
     signature.s,
     signature.recoveryParam ? "0x1c" : "0x1b"
@@ -47777,13 +47909,13 @@ class Writer {
     return data.length;
   }
   appendWriter(writer) {
-    return this._writeData(concat2(writer._data));
+    return this._writeData(concat3(writer._data));
   }
   writeBytes(value) {
     let bytes = arrayify(value);
     const paddingOffset = bytes.length % this.wordSize;
     if (paddingOffset) {
-      bytes = concat2([bytes, this._padding.slice(paddingOffset)]);
+      bytes = concat3([bytes, this._padding.slice(paddingOffset)]);
     }
     return this._writeData(bytes);
   }
@@ -47796,7 +47928,7 @@ class Writer {
       });
     }
     if (bytes.length % this.wordSize) {
-      bytes = concat2([this._padding.slice(bytes.length % this.wordSize), bytes]);
+      bytes = concat3([this._padding.slice(bytes.length % this.wordSize), bytes]);
     }
     return bytes;
   }
@@ -48108,7 +48240,7 @@ function getCreate2Address(from2, salt, initCodeHash) {
   if (hexDataLength(initCodeHash) !== 32) {
     logger8.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", initCodeHash);
   }
-  return getAddress2(hexDataSlice(keccak2562(concat2(["0xff", getAddress2(from2), salt, initCodeHash])), 12));
+  return getAddress2(hexDataSlice(keccak2562(concat3(["0xff", getAddress2(from2), salt, initCodeHash])), 12));
 }
 
 // node_modules/@ethersproject/abi/lib.esm/coders/address.js
@@ -48700,7 +48832,7 @@ function formatBytes32String(text) {
   if (bytes.length > 31) {
     throw new Error("bytes32 string must be less than 32 bytes");
   }
-  return hexlify(concat2([bytes, HashZero]).slice(0, 32));
+  return hexlify(concat3([bytes, HashZero]).slice(0, 32));
 }
 function parseBytes32String(bytes) {
   const data = arrayify(bytes);
@@ -49441,12 +49573,12 @@ function namehash(name) {
   let result = Zeros;
   const comps = ensNameSplit(name);
   while (comps.length) {
-    result = keccak2562(concat2([result, keccak2562(comps.pop())]));
+    result = keccak2562(concat3([result, keccak2562(comps.pop())]));
   }
   return hexlify(result);
 }
 function dnsEncode(name) {
-  return hexlify(concat2(ensNameSplit(name).map((comp) => {
+  return hexlify(concat3(ensNameSplit(name).map((comp) => {
     if (comp.length > 63) {
       throw new Error("invalid DNS encoded entry; length exceeds 63 bytes");
     }
@@ -49464,7 +49596,7 @@ function hashMessage(message) {
   if (typeof message === "string") {
     message = toUtf8Bytes(message);
   }
-  return keccak2562(concat2([
+  return keccak2562(concat3([
     toUtf8Bytes(messagePrefix),
     toUtf8Bytes(String(message.length)),
     message
@@ -50118,7 +50250,7 @@ class Interface {
     if (typeof fragment === "string") {
       fragment = this.getError(fragment);
     }
-    return hexlify(concat2([
+    return hexlify(concat3([
       this.getSighash(fragment),
       this._encodeParams(fragment.inputs, values || [])
     ]));
@@ -50137,7 +50269,7 @@ class Interface {
     if (typeof functionFragment === "string") {
       functionFragment = this.getFunction(functionFragment);
     }
-    return hexlify(concat2([
+    return hexlify(concat3([
       this.getSighash(functionFragment),
       this._encodeParams(functionFragment.inputs, values || [])
     ]));
@@ -50316,7 +50448,7 @@ class Interface {
         dynamic.push(false);
       }
     });
-    let resultIndexed = topics != null ? this._abiCoder.decode(indexed, concat2(topics)) : null;
+    let resultIndexed = topics != null ? this._abiCoder.decode(indexed, concat3(topics)) : null;
     let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);
     let result = [];
     let nonIndexedIndex = 0, indexedIndex = 0;
@@ -53899,7 +54031,7 @@ class ContractFactory {
       }
     }
     logger19.checkArgumentCount(args.length, this.interface.deploy.inputs.length, " in Contract constructor");
-    tx.data = hexlify(concat2([
+    tx.data = hexlify(concat3([
       this.bytecode,
       this.interface.encodeDeploy(args)
     ]));
@@ -54198,7 +54330,7 @@ function bytes32(value) {
   return hexZeroPad(hexlify(value), 32);
 }
 function base58check(data) {
-  return Base58.encode(concat2([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));
+  return Base58.encode(concat3([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));
 }
 function getWordlist(wordlist2) {
   if (wordlist2 == null) {
@@ -54250,13 +54382,13 @@ class HDNode {
     if (this.depth >= 256) {
       throw new Error("Depth too large!");
     }
-    return base58check(concat2([
+    return base58check(concat3([
       this.privateKey != null ? "0x0488ADE4" : "0x0488B21E",
       hexlify(this.depth),
       this.parentFingerprint,
       hexZeroPad(hexlify(this.index), 4),
       this.chainCode,
-      this.privateKey != null ? concat2(["0x00", this.privateKey]) : this.publicKey
+      this.privateKey != null ? concat3(["0x00", this.privateKey]) : this.publicKey
     ]));
   }
   neuter() {
@@ -54689,7 +54821,7 @@ function _decrypt(data, key2, ciphertext) {
 }
 function _getAccount(data, key2) {
   const ciphertext = looseArrayify(searchPath(data, "crypto/ciphertext"));
-  const computedMAC = hexlify(keccak2562(concat2([key2.slice(16, 32), ciphertext]))).substring(2);
+  const computedMAC = hexlify(keccak2562(concat3([key2.slice(16, 32), ciphertext]))).substring(2);
   if (computedMAC !== searchPath(data, "crypto/mac").toLowerCase()) {
     throw new Error("invalid password");
   }
@@ -54881,7 +55013,7 @@ function encrypt(account, password, options, progressCallback) {
     const counter = new import_aes_js2.default.Counter(iv);
     const aesCtr = new import_aes_js2.default.ModeOfOperation.ctr(derivedKey, counter);
     const ciphertext = arrayify(aesCtr.encrypt(privateKey));
-    const mac = keccak2562(concat2([macPrefix, ciphertext]));
+    const mac = keccak2562(concat3([macPrefix, ciphertext]));
     const data = {
       address: account.address.substring(2).toLowerCase(),
       id: uuidV4(uuidRandom),
@@ -55104,7 +55236,7 @@ class Wallet extends Signer {
       options = {};
     }
     if (options.extraEntropy) {
-      entropy = arrayify(hexDataSlice(keccak2562(concat2([entropy, options.extraEntropy])), 0, 16));
+      entropy = arrayify(hexDataSlice(keccak2562(concat3([entropy, options.extraEntropy])), 0, 16));
     }
     const mnemonic = entropyToMnemonic(entropy, options.locale);
     return Wallet.fromMnemonic(mnemonic, options.path, options.locale);
@@ -56425,7 +56557,7 @@ function bytes32ify(value) {
   return hexZeroPad(BigNumber.from(value).toHexString(), 32);
 }
 function base58Encode(data) {
-  return Base58.encode(concat2([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));
+  return Base58.encode(concat3([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));
 }
 var matcherIpfs = new RegExp("^(ipfs)://(.*)$", "i");
 var matchers = [
@@ -56573,7 +56705,7 @@ class Resolver {
       if (p2pkh) {
         const length = parseInt(p2pkh[1], 16);
         if (p2pkh[2].length === length * 2 && length >= 1 && length <= 75) {
-          return base58Encode(concat2([[coinInfo.p2pkh], "0x" + p2pkh[2]]));
+          return base58Encode(concat3([[coinInfo.p2pkh], "0x" + p2pkh[2]]));
         }
       }
     }
@@ -56582,7 +56714,7 @@ class Resolver {
       if (p2sh) {
         const length = parseInt(p2sh[1], 16);
         if (p2sh[2].length === length * 2 && length >= 1 && length <= 75) {
-          return base58Encode(concat2([[coinInfo.p2sh], "0x" + p2sh[2]]));
+          return base58Encode(concat3([[coinInfo.p2sh], "0x" + p2sh[2]]));
         }
       }
     }
@@ -56778,9 +56910,9 @@ class Resolver {
   getText(key2) {
     return __awaiter10(this, undefined, undefined, function* () {
       let keyBytes = toUtf8Bytes(key2);
-      keyBytes = concat2([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
+      keyBytes = concat3([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
       if (keyBytes.length % 32 !== 0) {
-        keyBytes = concat2([keyBytes, hexZeroPad("0x", 32 - key2.length % 32)]);
+        keyBytes = concat3([keyBytes, hexZeroPad("0x", 32 - key2.length % 32)]);
       }
       const hexBytes = yield this._fetchBytes("0x59d1d43c", hexlify(keyBytes));
       if (hexBytes == null || hexBytes === "0x") {
@@ -60726,7 +60858,7 @@ __export(exports_utils, {
   defaultPath: () => defaultPath,
   defaultAbiCoder: () => defaultAbiCoder,
   deepCopy: () => deepCopy,
-  concat: () => concat2,
+  concat: () => concat3,
   computePublicKey: () => computePublicKey,
   computeHmac: () => computeHmac,
   computeAddress: () => computeAddress,
@@ -60827,7 +60959,7 @@ function _pack(type, value, isArray) {
     value.forEach(function(value2) {
       result.push(_pack(baseType, value2, true));
     });
-    return concat2(result);
+    return concat3(result);
   }
   return logger44.throwArgumentError("invalid type", "type", type);
 }
@@ -60839,7 +60971,7 @@ function pack2(types, values) {
   types.forEach(function(type, index) {
     tight.push(_pack(type, values[index]));
   });
-  return hexlify(concat2(tight));
+  return hexlify(concat3(tight));
 }
 function keccak2563(types, values) {
   return keccak2562(pack2(types, values));
@@ -62057,7 +62189,9 @@ var contractsRegistry_default = {
     wormhole: {
       executor: "0x84EEe8dBa37C36947397E1E11251cA9A06Fc6F8a",
       multiTokenNTT: "0x556790e948b9920A8868bCAFcC87D25e82e8a075",
-      multiNTTWithExecutor: "0x03dB430D830601DB368991eE55DAa9A708df7912"
+      multiNTTWithExecutor: "0x03dB430D830601DB368991eE55DAa9A708df7912",
+      gmpManager: "0xc6793a32761a11e96c97A3D18fC6545ea931F0E9",
+      genericWormholeTransceiver: "0x9D0eADF3fc10380C4D2F5ba79499C6194549C7D2"
     },
     "1inch": {
       aggregatorV6: "0x111111125421cA6dc452d289314280a0f8842A65"
@@ -62451,7 +62585,9 @@ var contractsRegistry_default = {
     wormhole: {
       executor: "0xC04dE634982cAdF2A677310b73630B7Ac56A3f65",
       multiTokenNTT: "0x36878C6FCa7e0E8a88F90dc410CfBBcA5B695C95",
-      multiNTTWithExecutor: "0xFEA937F7124E19124671f1685671d3f04a9Af4E4"
+      multiNTTWithExecutor: "0xFEA937F7124E19124671f1685671d3f04a9Af4E4",
+      gmpManager: "0x92957b3D0CaB3eA7110fEd1ccc4eF564981a59Fc",
+      genericWormholeTransceiver: "0x1a0f31492Ca69DF6A82906Ce88613AeCD9245C44"
     },
     enso: {
       routerV2: "0xCfBAa9Cfce952Ca4F4069874fF1Df8c05e37a3c7"
@@ -73654,7 +73790,7 @@ function computeZksyncCreate2Address(sender, bytecodeHash, salt, input) {
   }
   var prefix2 = keccak2562(toUtf8Bytes("zksyncCreate2"));
   var inputHash = keccak2562(input);
-  var addressBytes = keccak2562(concat2([prefix2, hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
+  var addressBytes = keccak2562(concat3([prefix2, hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
   return getAddress2(addressBytes);
 }
 var MAX_SAFE_INTEGER3 = /* @__PURE__ */ import_jsbi3.default.BigInt(Number.MAX_SAFE_INTEGER);
@@ -93908,6 +94044,147 @@ var sendOFTTrx = ({
     value: args.nativeFee
   });
 };
+// src/integrations/ccip/ccip.router.abi.ts
+var ccip_router_abi_default = [
+  {
+    inputs: [
+      { name: "destinationChainSelector", type: "uint64" },
+      {
+        name: "message",
+        type: "tuple",
+        components: [
+          { name: "receiver", type: "bytes" },
+          { name: "data", type: "bytes" },
+          {
+            name: "tokenAmounts",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "feeToken", type: "address" },
+          { name: "extraArgs", type: "bytes" }
+        ]
+      }
+    ],
+    name: "ccipSend",
+    outputs: [{ name: "messageId", type: "bytes32" }],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "destinationChainSelector", type: "uint64" },
+      {
+        name: "message",
+        type: "tuple",
+        components: [
+          { name: "receiver", type: "bytes" },
+          { name: "data", type: "bytes" },
+          {
+            name: "tokenAmounts",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "feeToken", type: "address" },
+          { name: "extraArgs", type: "bytes" }
+        ]
+      }
+    ],
+    name: "getFee",
+    outputs: [{ name: "fee", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+// src/integrations/ccip/ccip.router.ts
+var ccipRouterInterface = new exports_ethers.utils.Interface(ccip_router_abi_default);
+var CCIP_CHAIN_SELECTORS = Object.freeze({
+  1: "5009297550715157269",
+  42161: "4949039107694359620",
+  8453: "15971525489660198786",
+  10: "3734403246176062136",
+  137: "4051577828743386545",
+  56: "11344663589394136015",
+  143: "8481857512324358265"
+});
+var getCCIPChainSelector = (chainId) => {
+  const selector = CCIP_CHAIN_SELECTORS[chainId];
+  if (!selector) {
+    throw new Error(`CCIP: No chain selector for chainId ${chainId}`);
+  }
+  return selector;
+};
+var CCIPGetFeeCalldata = (args) => {
+  return ccipRouterInterface.encodeFunctionData("getFee", [
+    args.destinationChainSelector,
+    {
+      receiver: args.message.receiver,
+      data: args.message.data,
+      tokenAmounts: args.message.tokenAmounts.map((t) => ({
+        token: t.token,
+        amount: t.amount
+      })),
+      feeToken: args.message.feeToken,
+      extraArgs: args.message.extraArgs
+    }
+  ]);
+};
+var CCIPGetFeeTrx = ({
+  routerAddress,
+  args
+}) => {
+  return createCall({
+    operation: 0,
+    to: routerAddress,
+    data: CCIPGetFeeCalldata(args),
+    value: 0n
+  });
+};
+var CCIPSendCalldata = (args) => {
+  return ccipRouterInterface.encodeFunctionData("ccipSend", [
+    args.destinationChainSelector,
+    {
+      receiver: args.message.receiver,
+      data: args.message.data,
+      tokenAmounts: args.message.tokenAmounts.map((t) => ({
+        token: t.token,
+        amount: t.amount
+      })),
+      feeToken: args.message.feeToken,
+      extraArgs: args.message.extraArgs
+    }
+  ]);
+};
+var ccipSendTrx = ({
+  routerAddress,
+  args
+}) => {
+  return createCall({
+    operation: 0,
+    to: routerAddress,
+    data: CCIPSendCalldata(args),
+    value: args.nativeFee
+  });
+};
+var buildCCIPMessage = ({
+  receiver,
+  token,
+  amount
+}) => {
+  const receiverEncoded = "0x" + receiver.slice(2).padStart(64, "0");
+  return Object.freeze({
+    receiver: receiverEncoded,
+    data: "0x",
+    tokenAmounts: Object.freeze([Object.freeze({ token, amount })]),
+    feeToken: "0x0000000000000000000000000000000000000000",
+    extraArgs: "0x"
+  });
+};
 // src/integrations/cctp/token.messenger.v2.abi.ts
 var token_messenger_v2_abi_default = [
   {
@@ -95521,6 +95798,372 @@ var pendleMerkleClaimTrx = ({
     value: 0n
   });
 };
+// src/integrations/wormhole/wormhole.multi.ntt.abi.ts
+var wormhole_multi_ntt_abi_default = [
+  {
+    inputs: [
+      { name: "multiTokenNtt", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "recipientChain", type: "uint16" },
+      { name: "recipient", type: "bytes32" },
+      { name: "refundAddress", type: "bytes32" },
+      { name: "transceiverInstructions", type: "bytes" },
+      {
+        name: "executorArgs",
+        type: "tuple",
+        components: [
+          { name: "value", type: "uint256" },
+          { name: "refundAddress", type: "address" },
+          { name: "signedQuote", type: "bytes" },
+          { name: "instructions", type: "bytes" }
+        ]
+      },
+      {
+        name: "feeArgs",
+        type: "tuple",
+        components: [
+          { name: "dbps", type: "uint16" },
+          { name: "payee", type: "address" }
+        ]
+      }
+    ],
+    name: "transfer",
+    outputs: [{ name: "sequence", type: "uint64" }],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "dbps", type: "uint16" }
+    ],
+    name: "calculateFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "executor",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "chainId",
+    outputs: [{ name: "", type: "uint16" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+// src/integrations/wormhole/gmp.manager.abi.ts
+var gmp_manager_abi_default = [
+  {
+    inputs: [
+      { name: "recipientChain", type: "uint16" },
+      { name: "transceiverInstructions", type: "bytes" }
+    ],
+    name: "quoteDeliveryPrice",
+    outputs: [
+      { name: "", type: "uint256[]" },
+      { name: "", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+// src/integrations/wormhole/wormhole.transceiver.abi.ts
+var wormhole_transceiver_abi_default = [
+  {
+    inputs: [{ name: "encodedMessage", type: "bytes" }],
+    name: "receiveMessage",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+// src/integrations/wormhole/gmp.manager.ts
+var gmpManagerInterface = new exports_ethers.utils.Interface(gmp_manager_abi_default);
+var GmpManagerQuoteDeliveryPriceCalldata = (args) => {
+  return gmpManagerInterface.encodeFunctionData("quoteDeliveryPrice", [
+    args.recipientChain,
+    args.transceiverInstructions
+  ]);
+};
+var GmpManagerQuoteDeliveryPriceTrx = ({
+  gmpManagerAddress,
+  args
+}) => {
+  return createCall({
+    operation: 0,
+    to: gmpManagerAddress,
+    data: GmpManagerQuoteDeliveryPriceCalldata(args),
+    value: 0n
+  });
+};
+var decodeQuoteDeliveryPriceResult = (resultHex) => {
+  const decoded = gmpManagerInterface.decodeFunctionResult("quoteDeliveryPrice", resultHex);
+  const perTransceiver = decoded[0].map((v) => BigInt(v.toString()));
+  const total = BigInt(decoded[1].toString());
+  return { perTransceiver, total };
+};
+var encodeTransceiverInstruction = (index, payload) => {
+  if (index < 0 || index > 255)
+    throw new Error(`encodeTransceiverInstruction: index out of range: ${index}`);
+  const payloadLen = size(payload);
+  if (payloadLen > 255)
+    throw new Error(`encodeTransceiverInstruction: payload length ${payloadLen} exceeds uint8 max`);
+  return concatHex([toHex(index, { size: 1 }), toHex(payloadLen, { size: 1 }), payload]);
+};
+var encodeTransceiverInstructions = (instructions) => {
+  if (instructions.length > 255)
+    throw new Error(`encodeTransceiverInstructions: too many instructions: ${instructions.length}`);
+  return concatHex([
+    toHex(instructions.length, { size: 1 }),
+    ...instructions.map((i2) => encodeTransceiverInstruction(i2.index, i2.payload))
+  ]);
+};
+var buildMonadDefaultTransceiverInstructions = ({
+  axelarMaxFee
+}) => {
+  if (axelarMaxFee < 0n)
+    throw new Error("buildMonadDefaultTransceiverInstructions: negative axelarMaxFee");
+  return encodeTransceiverInstructions([
+    { index: 0, payload: "0x01" },
+    { index: 1, payload: toHex(axelarMaxFee, { size: 32 }) }
+  ]);
+};
+// src/integrations/wormhole/wormhole.transceiver.ts
+var transceiverInterface = new exports_ethers.utils.Interface(wormhole_transceiver_abi_default);
+var WormholeReceiveMessageCalldata = ({ vaa }) => {
+  return transceiverInterface.encodeFunctionData("receiveMessage", [vaa]);
+};
+var wormholeReceiveMessageTrx = ({
+  transceiverAddress,
+  vaa
+}) => {
+  return createCall({
+    operation: 0,
+    to: transceiverAddress,
+    data: WormholeReceiveMessageCalldata({ vaa }),
+    value: 0n
+  });
+};
+// src/integrations/wormhole/wormhole.scan.api.ts
+var WORMHOLESCAN_API_MAINNET = "https://api.wormholescan.io";
+var WORMHOLESCAN_API_TESTNET = "https://api.testnet.wormholescan.io";
+var getWormholeScanApiUrl = (network = "Mainnet") => network === "Mainnet" ? WORMHOLESCAN_API_MAINNET : WORMHOLESCAN_API_TESTNET;
+var normalizeEmitterForVaaLookup = (emitter) => {
+  const byteLen = size(emitter);
+  if (byteLen !== 20 && byteLen !== 32) {
+    throw new Error(`normalizeEmitterForVaaLookup: expected 20- or 32-byte hex, got ${byteLen} bytes`);
+  }
+  return pad(emitter, { size: 32 }).slice(2).toLowerCase();
+};
+var fetchWormholeVAA = async (args, network = "Mainnet") => {
+  const emitterPadded = normalizeEmitterForVaaLookup(args.emitterAddress);
+  const url = `${getWormholeScanApiUrl(network)}/api/v1/vaas/${args.emitterChain}/${emitterPadded}/${args.sequence.toString()}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`WormholeScan VAA lookup returned ${response.status} ${response.statusText}: ${body}`);
+  }
+  const parsed = await response.json();
+  if (!parsed.data) {
+    throw new Error(`WormholeScan VAA lookup returned 200 but no data for chain=${args.emitterChain} emitter=${args.emitterAddress} sequence=${args.sequence}`);
+  }
+  return parsed.data;
+};
+var decodeVaaBase64 = (base64) => bytesToHex(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
+// src/integrations/wormhole/axelar.gmp.api.ts
+var AXELAR_GMP_API_MAINNET = "https://api.axelarscan.io";
+var AXELAR_GMP_API_TESTNET = "https://testnet.api.axelarscan.io";
+var getAxelarGmpApiUrl = (network = "Mainnet") => network === "Mainnet" ? AXELAR_GMP_API_MAINNET : AXELAR_GMP_API_TESTNET;
+var fetchAxelarGmpStatus = async ({ sourceTxHash }, network = "Mainnet") => {
+  const response = await fetch(`${getAxelarGmpApiUrl(network)}/gmp/searchGMP`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ txHash: sourceTxHash })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Axelar GMP status API returned ${response.status} ${response.statusText}: ${body}`);
+  }
+  const parsed = await response.json();
+  const entry = parsed.data?.[0];
+  if (!entry)
+    return null;
+  const executedEntry = entry["executed"];
+  return Object.freeze({
+    status: String(entry["status"] ?? "unknown"),
+    simplifiedStatus: entry["simplified_status"],
+    executed: Boolean(entry["executed"]),
+    approved: Boolean(entry["approved"]),
+    destinationTxHash: executedEntry?.transactionHash,
+    destinationBlockNumber: executedEntry?.blockNumber,
+    raw: entry
+  });
+};
+// src/integrations/wormhole/wormhole.multi.ntt.ts
+var wormholeMultiNttInterface = new exports_ethers.utils.Interface(wormhole_multi_ntt_abi_default);
+var WORMHOLE_CHAIN_IDS = Object.freeze({
+  1: 2,
+  143: 48
+});
+var getWormholeChainId = (chainId) => {
+  const whChainId = WORMHOLE_CHAIN_IDS[chainId];
+  if (whChainId === undefined) {
+    throw new Error(`Wormhole: No chain ID mapping for chainId ${chainId}`);
+  }
+  return whChainId;
+};
+var addressToBytes32 = (addr) => pad(addr, { size: 32 }).toLowerCase();
+var WormholeTransferCalldata = (args) => {
+  return wormholeMultiNttInterface.encodeFunctionData("transfer", [
+    args.multiTokenNtt,
+    args.token,
+    args.amount,
+    args.recipientChain,
+    args.recipient,
+    args.refundAddress,
+    args.transceiverInstructions,
+    {
+      value: args.executorArgs.value,
+      refundAddress: args.executorArgs.refundAddress,
+      signedQuote: args.executorArgs.signedQuote,
+      instructions: args.executorArgs.instructions
+    },
+    {
+      dbps: args.feeArgs.dbps,
+      payee: args.feeArgs.payee
+    }
+  ]);
+};
+var wormholeTransferTrx = ({
+  wrapperAddress,
+  args,
+  transceiverFee = 0n
+}) => {
+  return createCall({
+    operation: 0,
+    to: wrapperAddress,
+    data: WormholeTransferCalldata(args),
+    value: args.executorArgs.value + transceiverFee
+  });
+};
+var DEFAULT_NTT_REDEMPTION_GAS_LIMIT = 1000000n;
+var buildRelayInstructions = ({
+  gasLimit = DEFAULT_NTT_REDEMPTION_GAS_LIMIT,
+  msgValue = 0n
+} = {}) => {
+  if (gasLimit < 0n)
+    throw new Error("buildRelayInstructions: negative gasLimit");
+  if (msgValue < 0n)
+    throw new Error("buildRelayInstructions: negative msgValue");
+  return concatHex([
+    "0x01",
+    toHex(gasLimit, { size: 16 }),
+    toHex(msgValue, { size: 16 })
+  ]);
+};
+var WormholeCalculateFeeCalldata = ({ amount, dbps }) => {
+  return wormholeMultiNttInterface.encodeFunctionData("calculateFee", [amount, dbps]);
+};
+var buildWormholeTransferArgsFromAvatar = ({
+  multiTokenNtt,
+  token,
+  amount,
+  recipientChain,
+  avatar,
+  relayFee,
+  signedQuote,
+  relayInstructions,
+  transceiverInstructions = "0x",
+  dbps = 0,
+  payee
+}) => {
+  const avatarBytes32 = addressToBytes32(avatar);
+  return Object.freeze({
+    multiTokenNtt,
+    token,
+    amount,
+    recipientChain,
+    recipient: avatarBytes32,
+    refundAddress: avatarBytes32,
+    transceiverInstructions,
+    executorArgs: Object.freeze({
+      value: relayFee,
+      refundAddress: avatar,
+      signedQuote,
+      instructions: relayInstructions
+    }),
+    feeArgs: Object.freeze({
+      dbps,
+      payee: payee ?? "0x0000000000000000000000000000000000000000"
+    })
+  });
+};
+// src/integrations/wormhole/executor.quote.api.ts
+var WORMHOLE_EXECUTOR_API_MAINNET = "https://executor.labsapis.com";
+var WORMHOLE_EXECUTOR_API_TESTNET = "https://executor-testnet.labsapis.com";
+var getExecutorApiUrl = (network = "Mainnet") => network === "Mainnet" ? WORMHOLE_EXECUTOR_API_MAINNET : WORMHOLE_EXECUTOR_API_TESTNET;
+var fetchExecutorQuote = async (args, network = "Mainnet") => {
+  const url = `${getExecutorApiUrl(network)}/v0/quote`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      srcChain: args.srcChain,
+      dstChain: args.dstChain,
+      relayInstructions: args.relayInstructions
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Wormhole executor quote API returned ${response.status} ${response.statusText}: ${body}`);
+  }
+  return await response.json();
+};
+var parseSignedQuote = (signedQuote) => {
+  if (size(signedQuote) !== 165) {
+    throw new Error(`parseSignedQuote: expected 165 bytes, got ${size(signedQuote)}`);
+  }
+  const prefixBytes = hexToBytes(sliceHex(signedQuote, 0, 4));
+  const prefix2 = bytesToString(prefixBytes);
+  if (prefix2 !== "EQ01") {
+    throw new Error(`parseSignedQuote: invalid prefix '${prefix2}', expected 'EQ01'`);
+  }
+  return Object.freeze({
+    prefix: "EQ01",
+    quoterAddress: sliceHex(signedQuote, 4, 24),
+    payeeAddress: sliceHex(signedQuote, 24, 56),
+    srcChain: bytesToNumber(hexToBytes(sliceHex(signedQuote, 56, 58))),
+    dstChain: bytesToNumber(hexToBytes(sliceHex(signedQuote, 58, 60))),
+    expiryTimeSeconds: bytesToBigInt(hexToBytes(sliceHex(signedQuote, 60, 68))),
+    baseFee: bytesToBigInt(hexToBytes(sliceHex(signedQuote, 68, 76))),
+    dstGasPrice: bytesToBigInt(hexToBytes(sliceHex(signedQuote, 76, 84))),
+    srcPrice: bytesToBigInt(hexToBytes(sliceHex(signedQuote, 84, 92))),
+    dstPrice: bytesToBigInt(hexToBytes(sliceHex(signedQuote, 92, 100)))
+  });
+};
+var fetchExecutorTxStatus = async ({
+  txHash,
+  chainId
+}, network = "Mainnet") => {
+  const url = `${getExecutorApiUrl(network)}/v0/status/tx`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ txHash, chainId })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Wormhole executor status API returned ${response.status} ${response.statusText}: ${body}`);
+  }
+  return await response.json();
+};
 // src/lib/utils.ts
 var executeTrx = ({
   client,
@@ -95615,4 +96258,4 @@ var simulateOrThrow = async (env2) => {
   };
 };
 
-//# debugId=00888F308F3528CC64756E2164756E21
+//# debugId=A0C783FEF91F3ABA64756E2164756E21