@xlink-network/xlink-sdk/lib/XLinkSDK.js

XLINK js SDK

"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
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/XLinkSDK.ts
var XLinkSDK_exports = {};
__export(XLinkSDK_exports, {
  XLinkSDK: () => XLinkSDK
});
module.exports = __toCommonJS(XLinkSDK_exports);

// src/bitcoinUtils/btcAddresses.ts
var import_btc_signer2 = require("@scure/btc-signer");

// src/utils/typeHelpers.ts
function isNotNull(input) {
  return input != null;
}
function checkNever(_x) {
  return;
}
function assertExclude(asserting, excluding) {
  return;
}
((assertExclude2) => {
  assertExclude2.i = () => null;
})(assertExclude || (assertExclude = {}));

// src/utils/types/knownIds.ts
var chainId = (value) => value;
var tokenId = (value) => value;
var KnownTokenId;
((KnownTokenId6) => {
  function isKnownToken(value) {
    return isBitcoinToken(value) || isBRC20Token(value) || isRunesToken(value) || isEVMToken(value) || isStacksToken(value);
  }
  KnownTokenId6.isKnownToken = isKnownToken;
  let Bitcoin;
  ((Bitcoin2) => {
    Bitcoin2.BTC = tokenId("btc-btc");
  })(Bitcoin = KnownTokenId6.Bitcoin || (KnownTokenId6.Bitcoin = {}));
  function isBitcoinToken(value) {
    return _allKnownBitcoinTokens.includes(value);
  }
  KnownTokenId6.isBitcoinToken = isBitcoinToken;
  function isBRC20Token(value) {
    return value.startsWith("brc20-");
  }
  KnownTokenId6.isBRC20Token = isBRC20Token;
  function isRunesToken(value) {
    return value.startsWith("runes-");
  }
  KnownTokenId6.isRunesToken = isRunesToken;
  let EVM;
  ((EVM2) => {
    EVM2.sUSDT = tokenId("evm-susdt");
    EVM2.USDT = tokenId("evm-usdt");
    EVM2.USDC = tokenId("evm-usdc");
    EVM2.aBTC = tokenId("evm-abtc");
    EVM2.WBTC = tokenId("evm-wbtc");
    EVM2.BTCB = tokenId("evm-btcb");
    EVM2.cbBTC = tokenId("evm-cbbtc");
    EVM2.LUNR = tokenId("evm-lunr");
    EVM2.ALEX = tokenId("evm-alex");
    EVM2.SKO = tokenId("evm-sko");
    EVM2.vLiSTX = tokenId("evm-vlistx");
    EVM2.vLiALEX = tokenId("evm-vlialex");
    EVM2.uBTC = tokenId("evm-ubtc");
    EVM2.wuBTC = tokenId("evm-wubtc");
    EVM2.DB20 = tokenId("evm-db20");
    EVM2.DOG = tokenId("evm-dog");
  })(EVM = KnownTokenId6.EVM || (KnownTokenId6.EVM = {}));
  function isEVMToken(value) {
    return _allKnownEVMTokens.includes(value);
  }
  KnownTokenId6.isEVMToken = isEVMToken;
  let Stacks;
  ((Stacks2) => {
    Stacks2.sUSDT = tokenId("stx-susdt");
    Stacks2.sLUNR = tokenId("stx-slunr");
    Stacks2.aBTC = tokenId("stx-abtc");
    Stacks2.ALEX = tokenId("stx-alex");
    Stacks2.sSKO = tokenId("stx-ssko");
    Stacks2.vLiSTX = tokenId("stx-vlistx");
    Stacks2.vLiALEX = tokenId("stx-vlialex");
    Stacks2.uBTC = tokenId("stx-ubtc");
    Stacks2.DB20 = tokenId("stx-db20");
    Stacks2.DOG = tokenId("stx-dog");
  })(Stacks = KnownTokenId6.Stacks || (KnownTokenId6.Stacks = {}));
  function isStacksToken(value) {
    return _allKnownStacksTokens.includes(value);
  }
  KnownTokenId6.isStacksToken = isStacksToken;
})(KnownTokenId || (KnownTokenId = {}));
var createBRC20Token = (brc20tick) => {
  return `brc20-${brc20tick}`;
};
var createRunesToken = (runeId) => {
  return `runes-${runeId}`;
};
var _allKnownBitcoinTokens = Object.values(KnownTokenId.Bitcoin);
var _allKnownEVMTokens = Object.values(KnownTokenId.EVM);
var _allKnownStacksTokens = Object.values(KnownTokenId.Stacks);
var KnownChainId;
((KnownChainId4) => {
  function isKnownChain(value) {
    return isBitcoinChain(value) || isBRC20Chain(value) || isRunesChain(value) || isEVMChain(value) || isStacksChain(value);
  }
  KnownChainId4.isKnownChain = isKnownChain;
  let Bitcoin;
  ((Bitcoin2) => {
    Bitcoin2.Mainnet = chainId("bitcoin-mainnet");
    Bitcoin2.Testnet = chainId("bitcoin-testnet");
  })(Bitcoin = KnownChainId4.Bitcoin || (KnownChainId4.Bitcoin = {}));
  function isBitcoinChain(value) {
    return _allKnownBitcoinChains.includes(value);
  }
  KnownChainId4.isBitcoinChain = isBitcoinChain;
  let Runes;
  ((Runes2) => {
    Runes2.Mainnet = chainId("runes-mainnet");
    Runes2.Testnet = chainId("runes-testnet");
  })(Runes = KnownChainId4.Runes || (KnownChainId4.Runes = {}));
  function isRunesChain(value) {
    return _allKnownRunesChains.includes(value);
  }
  KnownChainId4.isRunesChain = isRunesChain;
  let BRC20;
  ((BRC202) => {
    BRC202.Mainnet = chainId("brc20-mainnet");
    BRC202.Testnet = chainId("brc20-testnet");
  })(BRC20 = KnownChainId4.BRC20 || (KnownChainId4.BRC20 = {}));
  function isBRC20Chain(value) {
    return _allKnownBRC20Chains.includes(value);
  }
  KnownChainId4.isBRC20Chain = isBRC20Chain;
  let EVM;
  ((EVM2) => {
    EVM2.Ethereum = chainId("evm-ethereum");
    EVM2.Sepolia = chainId("evm-sepolia");
    EVM2.BSC = chainId("evm-bsc");
    EVM2.BSCTestnet = chainId("evm-bsctestnet");
    EVM2.CoreDAO = chainId("evm-coredao");
    EVM2.CoreDAOTestnet = chainId("evm-coredao-testnet");
    EVM2.Bsquared = chainId("evm-bsquared");
    EVM2.BOB = chainId("evm-bob");
    EVM2.Bitlayer = chainId("evm-bitlayer");
    EVM2.Lorenzo = chainId("evm-lorenzo");
    EVM2.Merlin = chainId("evm-merlin");
    EVM2.AILayer = chainId("evm-ailayer");
    EVM2.Mode = chainId("evm-mode");
    EVM2.XLayer = chainId("evm-xlayer");
    EVM2.Arbitrum = chainId("evm-arbitrum");
    EVM2.Aurora = chainId("evm-aurora");
    EVM2.BlifeTestnet = chainId("evm-blife-testnet");
    EVM2.BitboyTestnet = chainId("evm-bitboy-testnet");
    EVM2.Manta = chainId("evm-manta");
    EVM2.Linea = chainId("evm-linea");
    EVM2.Base = chainId("evm-base");
    EVM2.BeraTestnet = chainId("evm-bera-testnet");
  })(EVM = KnownChainId4.EVM || (KnownChainId4.EVM = {}));
  function isEVMMainnetChain(value) {
    return _allKnownEVMMainnetChains.includes(value);
  }
  KnownChainId4.isEVMMainnetChain = isEVMMainnetChain;
  function isEVMTestnetChain(value) {
    return _allKnownEVMTestnetChains.includes(value);
  }
  KnownChainId4.isEVMTestnetChain = isEVMTestnetChain;
  function isEVMChain(value) {
    return _allKnownEVMChains.includes(value);
  }
  KnownChainId4.isEVMChain = isEVMChain;
  let Stacks;
  ((Stacks2) => {
    Stacks2.Mainnet = chainId("stacks-mainnet");
    Stacks2.Testnet = chainId("stacks-testnet");
  })(Stacks = KnownChainId4.Stacks || (KnownChainId4.Stacks = {}));
  function isStacksChain(value) {
    return _allKnownStacksChains.includes(value);
  }
  KnownChainId4.isStacksChain = isStacksChain;
})(KnownChainId || (KnownChainId = {}));
var _allKnownBitcoinChains = Object.values(KnownChainId.Bitcoin);
var _allKnownRunesChains = Object.values(KnownChainId.Runes);
var _allKnownBRC20Chains = Object.values(KnownChainId.BRC20);
var _allKnownEVMChains = Object.values(KnownChainId.EVM);
var _allKnownStacksChains = Object.values(KnownChainId.Stacks);
var _allKnownEVMMainnetChains = [
  KnownChainId.EVM.Ethereum,
  KnownChainId.EVM.BSC,
  KnownChainId.EVM.CoreDAO,
  KnownChainId.EVM.Bsquared,
  KnownChainId.EVM.BOB,
  KnownChainId.EVM.Bitlayer,
  KnownChainId.EVM.Lorenzo,
  KnownChainId.EVM.Merlin,
  KnownChainId.EVM.AILayer,
  KnownChainId.EVM.Mode,
  KnownChainId.EVM.XLayer,
  KnownChainId.EVM.Arbitrum,
  KnownChainId.EVM.Aurora,
  KnownChainId.EVM.Manta,
  KnownChainId.EVM.Linea,
  KnownChainId.EVM.Base
];
var _allKnownEVMTestnetChains = [
  KnownChainId.EVM.Sepolia,
  KnownChainId.EVM.BSCTestnet,
  KnownChainId.EVM.CoreDAOTestnet,
  KnownChainId.EVM.BlifeTestnet,
  KnownChainId.EVM.BitboyTestnet,
  KnownChainId.EVM.BeraTestnet
];
var _allNoLongerSupportedEVMChains = [
  KnownChainId.EVM.Lorenzo
];
var _restEVMChain = null;
checkNever(_restEVMChain);

// src/bitcoinUtils/bitcoinHelpers.ts
var btc = __toESM(require("@scure/btc-signer"));
var import_btc_signer = require("@scure/btc-signer");

// src/utils/bigintHelpers.ts
var MAX_BIGINT = BigInt(Number.MAX_VALUE);
function sum(nums) {
  return nums.reduce((acc, val) => acc + val, 0n);
}
function max(nums) {
  return nums.reduce((acc, val) => acc > val ? acc : val, 0n);
}

// src/utils/BigNumber.ts
var import_big = require("big.js");

// src/utils/arrayHelpers.ts
function hasAny(ary) {
  return ary.length > 0;
}
function hasLength(input, length) {
  return input.length === length;
}
function last(ary) {
  return ary[ary.length - 1];
}
var _concat = [].concat;
function concat(...inputArrays) {
  return _concat.apply([], inputArrays);
}
var _reduce = [].reduce;
function reduce(fn, initialValue, inputArray) {
  return _reduce.call(inputArray, fn, initialValue);
}
function range(start, end) {
  return Array.from({ length: end - start }, (_, i) => i + start);
}

// src/utils/BigNumber.ts
import_big.Big.PE = 21;
import_big.Big.NE = -21;
var toBig = (num) => {
  if (num instanceof import_big.Big) {
    return num;
  }
  return new import_big.Big(num);
};
var fromBig = (num) => {
  return num;
};
var BigNumber;
((BigNumber2) => {
  ({ roundUp: BigNumber2.roundUp, roundDown: BigNumber2.roundDown, roundHalfUp: BigNumber2.roundHalfUp, roundHalfEven: BigNumber2.roundHalfEven } = import_big.Big);
  let defaultRoundingMode = BigNumber2.roundHalfUp;
  BigNumber2.setDefaultRoundingMode = (roundingMode) => {
    defaultRoundingMode = roundingMode;
  };
  BigNumber2.isBigNumber = (num) => {
    return num instanceof import_big.Big;
  };
  BigNumber2.safeFrom = (value) => {
    try {
      return (0, BigNumber2.from)(value);
    } catch (e) {
      return void 0;
    }
  };
  BigNumber2.from = (value) => {
    return fromBig(toBig(value));
  };
  BigNumber2.toString = (value) => {
    return toBig(value).toString();
  };
  BigNumber2.toNumber = (value) => {
    return toBig(value).toNumber();
  };
  BigNumber2.toBigInt = curry2(
    (options, value) => {
      return BigInt(
        (0, BigNumber2.toFixed)(
          {
            precision: 0,
            roundingMode: options.roundingMode ?? defaultRoundingMode
          },
          toBig(value)
        )
      );
    }
  );
  BigNumber2.toFixed = curry2(
    (options, value) => {
      return toBig(value).toFixed(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.toExponential = curry2(
    (options, value) => {
      return toBig(value).toExponential(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.isNegative = (value) => {
    return toBig(value).lt(0);
  };
  BigNumber2.isGtZero = (value) => {
    return toBig(value).gt(0);
  };
  BigNumber2.isZero = (value) => {
    return toBig(value).eq(0);
  };
  BigNumber2.isEq = curry2(
    (value, a) => {
      return toBig(value).eq(toBig(a));
    }
  );
  BigNumber2.isGt = curry2(
    (value, a) => {
      return toBig(value).gt(toBig(a));
    }
  );
  BigNumber2.isGte = curry2(
    (value, a) => {
      return toBig(value).gte(toBig(a));
    }
  );
  BigNumber2.isLt = curry2(
    (value, a) => {
      return toBig(value).lt(toBig(a));
    }
  );
  BigNumber2.isLte = curry2(
    (value, a) => {
      return toBig(value).lte(toBig(a));
    }
  );
  BigNumber2.setPrecision = curry2(
    (options, value) => {
      return fromBig(
        toBig(
          toBig(value).toPrecision(
            options.precision,
            options.roundingMode ?? defaultRoundingMode
          )
        )
      );
    }
  );
  BigNumber2.getPrecision = (value) => {
    return toBig(value).c.length - (toBig(value).e + 1);
  };
  BigNumber2.getIntegerLength = (value) => {
    return toBig(value).e + 1;
  };
  BigNumber2.leftMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance }, value)
  );
  BigNumber2.rightMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance: -distance }, value)
  );
  BigNumber2.moveDecimals = curry2(
    (options, value) => {
      if (options.distance > 0) {
        return fromBig(toBig(value).div(10 ** options.distance));
      }
      if (options.distance < 0) {
        return fromBig(toBig(value).mul(10 ** -options.distance));
      }
      return (0, BigNumber2.from)(value);
    }
  );
  BigNumber2.getDecimalPart = curry2(
    (options, value) => {
      const formatted = (0, BigNumber2.toFixed)(
        {
          precision: Math.min((0, BigNumber2.getPrecision)(value), options.precision),
          roundingMode: BigNumber2.roundDown
        },
        value
      );
      const [, decimals] = formatted.split(".");
      if (decimals == null) return void 0;
      return decimals;
    }
  );
  BigNumber2.abs = (value) => {
    return fromBig(toBig(value).abs());
  };
  BigNumber2.neg = (value) => {
    return fromBig(toBig(value).neg());
  };
  BigNumber2.sqrt = (value) => {
    return fromBig(toBig(value).sqrt());
  };
  BigNumber2.add = curry2(
    (value, a) => {
      return fromBig(toBig(value).add(toBig(a)));
    }
  );
  BigNumber2.minus = curry2(
    (value, a) => {
      return fromBig(toBig(value).minus(toBig(a)));
    }
  );
  BigNumber2.mul = curry2(
    (value, a) => {
      return fromBig(toBig(value).mul(toBig(a)));
    }
  );
  BigNumber2.cumulativeMul = curry2(
    (value, as) => {
      return reduce(
        (acc, currentRate) => [
          ...acc,
          BigNumber2.mul(last(acc), currentRate)
        ],
        [(0, BigNumber2.from)(value)],
        as
      );
    }
  );
  BigNumber2.div = curry2(
    (value, a) => {
      return fromBig(toBig(value).div(toBig(a)));
    }
  );
  BigNumber2.pow = curry2((value, a) => {
    return fromBig(toBig(value).pow(a));
  });
  BigNumber2.round = curry2(
    (options, value) => {
      return fromBig(
        toBig(value).round(
          options.precision,
          options.roundingMode ?? defaultRoundingMode
        )
      );
    }
  );
  BigNumber2.toPrecision = curry2(
    (options, value) => {
      return toBig(value).toPrecision(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.ascend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? -1 : (0, BigNumber2.isGt)(a, b) ? 1 : 0
  );
  BigNumber2.descend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? 1 : (0, BigNumber2.isGt)(a, b) ? -1 : 0
  );
  BigNumber2.sort = (comparator, numbers) => {
    const _numbers = numbers.map((a) => fromBig(toBig(a)));
    _numbers.sort(comparator);
    return _numbers;
  };
  BigNumber2.max = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.descend, numbers)[0]);
  };
  BigNumber2.min = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.ascend, numbers)[0]);
  };
  BigNumber2.clamp = (range2, n) => {
    const [min2, max3] = range2;
    if ((0, BigNumber2.isGte)(n, max3)) return max3;
    if ((0, BigNumber2.isLte)(n, min2)) return min2;
    return n;
  };
  BigNumber2.sum = (numbers) => {
    return numbers.map((n) => fromBig(toBig(n))).reduce((acc, n) => (0, BigNumber2.add)(acc, n), BigNumber2.ZERO);
  };
  BigNumber2.ZERO = BigNumber2.from(0);
  BigNumber2.ONE = BigNumber2.from(1);
})(BigNumber || (BigNumber = {}));
function curry2(fn) {
  return function(a, b) {
    if (arguments.length > 1) {
      return fn(a, b);
    }
    return (b2) => fn(a, b2);
  };
}

// src/bitcoinUtils/bitcoinHelpers.ts
function sumUTXO(utxos) {
  return sum(utxos.map((utxo) => utxo.amount));
}
function addressToScriptPubKey(network, address) {
  const addr = (0, import_btc_signer.Address)(network).decode(address);
  return import_btc_signer.OutScript.encode(addr);
}
function bitcoinToSatoshi(bitcoinAmount) {
  return BigNumber.toBigInt({}, BigNumber.rightMoveDecimals(8, bitcoinAmount));
}

// src/bitcoinUtils/btcAddresses.ts
function getBTCPegInAddress(fromChain, toChain) {
  let addr;
  switch (fromChain) {
    case KnownChainId.Bitcoin.Mainnet:
      addr = "bc1q9hs56nskqsxmgend4w0823lmef33sux6p8rzlp";
      break;
    case KnownChainId.Bitcoin.Testnet:
      addr = "tb1qeprcndv9n8luumegjsnljjcf68e7ay62n5a667";
      break;
    default:
      checkNever(fromChain);
  }
  if (addr == null) return void 0;
  const script = addressToScriptPubKey(
    fromChain === KnownChainId.Bitcoin.Mainnet ? import_btc_signer2.NETWORK : import_btc_signer2.TEST_NETWORK,
    addr
  );
  return {
    address: addr,
    scriptPubKey: script
  };
}

// src/evmUtils/addressHelpers.ts
var import_viem = require("viem");
var nativeCurrencyAddress = import_viem.zeroAddress;

// src/evmUtils/evmClients.ts
var import_viem3 = require("viem");
var import_chains2 = require("viem/chains");

// src/evmUtils/evmChainInfos.ts
var import_viem2 = require("viem");
var import_chains = require("viem/chains");
var coreDaoTestnet = (0, import_viem2.defineChain)({
  id: 1115,
  name: "Core Dao Testnet",
  nativeCurrency: {
    name: "CORE",
    symbol: "CORE",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
      blockCreated: 15979981
    }
  },
  rpcUrls: {
    default: { http: ["https://rpc.test.btcs.network"] }
  },
  blockExplorers: {
    default: {
      name: "Core Dao Testnet Explorer",
      url: "https://scan.test.btcs.network"
    }
  },
  testnet: true
});
var bsquared = (0, import_viem2.defineChain)({
  id: 223,
  name: "B\xB2",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0x648cB32CCc0253fd2D811c506F969c1611Eaa82f",
      blockCreated: 5662185
    }
  },
  rpcUrls: {
    default: { http: ["https://rpc.bsquared.network"] },
    alt: { http: ["https://b2-mainnet.alt.technology"] },
    ankr: { http: ["https://rpc.ankr.com/b2"] }
  },
  blockExplorers: {
    default: {
      name: "B\xB2 Explorer",
      url: "https://explorer.bsquared.network"
    }
  },
  testnet: false
});
var bsquaredTestnet = (0, import_viem2.defineChain)({
  id: 1123,
  name: "B\xB2 Testnet",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  rpcUrls: {
    default: { http: ["https://testnet-rpc.bsquared.network"] },
    alt: { http: ["https://b2-testnet.alt.technology"] },
    ankr: { http: ["https://rpc.ankr.com/b2_testnet"] }
  },
  blockExplorers: {
    default: {
      name: "B\xB2 Testnet Explorer",
      url: "https://testnet-explorer.bsquared.network/"
    }
  },
  testnet: true
});
var bob = (0, import_viem2.defineChain)({
  ...import_chains.bob
});
var bobTestnet = (0, import_viem2.defineChain)({
  id: 111,
  name: "BOB Testnet",
  nativeCurrency: {
    name: "ETH",
    symbol: "ETH",
    decimals: 18
  },
  rpcUrls: {
    default: { http: ["https://testnet.rpc.gobob.xyz/"] }
  },
  blockExplorers: {
    default: {
      name: "BOB Testnet Explorer",
      url: "https://testnet-explorer.gobob.xyz"
    }
  },
  testnet: true
});
var bitlayer = (0, import_viem2.defineChain)({
  id: 200901,
  name: "Bitlayer",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0xca11bde05977b3631167028862be2a173976ca11",
      blockCreated: 3225645
    }
  },
  rpcUrls: {
    default: { http: ["https://rpc.bitlayer.org"] }
  },
  blockExplorers: {
    default: {
      name: "Bitlayer Explorer",
      url: "https://www.btrscan.com"
    }
  },
  testnet: false
});
var bitlayerTestnet = (0, import_viem2.defineChain)({
  id: 200810,
  name: "Bitlayer Testnet",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  rpcUrls: {
    default: { http: ["https://testnet-rpc.bitlayer.org"] }
  },
  blockExplorers: {
    default: {
      name: "Bitlayer Testnet Explorer",
      url: "https://testnet.btrscan.com"
    }
  },
  testnet: true
});
var lorenzo = (0, import_viem2.defineChain)({
  id: 8329,
  name: "Lorenzo",
  nativeCurrency: {
    name: "stBTC",
    symbol: "stBTC",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0x756e73C560Aeeb310b127F214e11e03139FC8f0a",
      blockCreated: 2490478
    }
  },
  rpcUrls: {
    default: { http: ["https://rpc.lorenzo-protocol.xyz"] }
  },
  blockExplorers: {
    default: {
      name: "Lorenzo Explorer",
      url: "https://scan.lorenzo-protocol.xyz"
    }
  },
  testnet: false
});
var lorenzoTestnet = (0, import_viem2.defineChain)({
  id: 83291,
  name: "Lorenzo Testnet",
  nativeCurrency: {
    name: "stBTC",
    symbol: "stBTC",
    decimals: 18
  },
  rpcUrls: {
    default: { http: ["https://rpc-testnet.lorenzo-protocol.xyz"] }
  },
  blockExplorers: {
    default: {
      name: "Lorenzo Testnet Explorer",
      url: "https://scan-testnet.lorenzo-protocol.xyz"
    }
  },
  testnet: true
});
var merlin = (0, import_viem2.defineChain)({
  ...import_chains.merlin,
  contracts: {
    ...import_chains.merlin.contracts,
    multicall3: {
      address: "0x13caE7bc3C7F02FF64cB17076F289467fB133e04",
      blockCreated: 12377144
    }
  }
});
var merlinTestnet = (0, import_viem2.defineChain)({
  id: 686868,
  name: "Merlin Testnet",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
      blockCreated: 4632260
    }
  },
  rpcUrls: {
    default: { http: ["https://testnet-rpc.merlinchain.io"] }
  },
  blockExplorers: {
    default: {
      name: "Merlin Testnet Explorer",
      url: "https://testnet-scan.merlinchain.io"
    }
  },
  testnet: true
});
var ailayer = (0, import_viem2.defineChain)({
  id: 2649,
  name: "AILayer",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  contracts: {
    multicall3: {
      address: "0x8BDc1E8149E7259833f8776CAfDa5c55Cfb8Bbd9",
      blockCreated: 4351314
    }
  },
  rpcUrls: {
    default: {
      http: ["https://mainnet-rpc.ailayer.xyz/"],
      webSocket: ["wss://mainnet-rpc.ailayer.xyz"]
    }
  },
  blockExplorers: {
    default: {
      name: "AILayer Explorer",
      url: "https://mainnet-explorer.ailayer.xyz"
    }
  },
  testnet: false
});
var ailayerTestnet = (0, import_viem2.defineChain)({
  id: 2648,
  name: "AILayer Testnet",
  nativeCurrency: {
    name: "BTC",
    symbol: "BTC",
    decimals: 18
  },
  rpcUrls: {
    default: {
      http: ["https://testnet-rpc.ailayer.xyz"],
      webSocket: ["wss://testnet-rpc.ailayer.xyz"]
    }
  },
  blockExplorers: {
    default: {
      name: "AILayer Testnet Explorer",
      url: "https://testnet-explorer.ailayer.xyz"
    }
  },
  testnet: true
});
var xLayer = (0, import_viem2.defineChain)({
  ...import_chains.xLayer,
  contracts: {
    ...import_chains.xLayer.contracts,
    multicall3: {
      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
      blockCreated: 47416
    }
  }
});
var blifeTestnet = (0, import_viem2.defineChain)({
  id: 34798,
  name: "Blife Testnet",
  nativeCurrency: {
    name: "WBTC",
    symbol: "WBTC",
    decimals: 18
  },
  rpcUrls: {
    default: {
      http: ["https://private-testnet.blifeprotocol.com:25600"]
    }
  },
  blockExplorers: {
    default: {
      name: "Blife Testnet Explorer",
      url: "https://private-testnet.blifeprotocol.com/",
      apiUrl: ""
    }
  },
  testnet: true
});
var berachainTestnet = (0, import_viem2.defineChain)({
  id: 80084,
  name: "Berachain Bartio",
  nativeCurrency: {
    decimals: 18,
    name: "BERA Token",
    symbol: "BERA"
  },
  rpcUrls: {
    default: {
      http: ["https://api.routescan.io/v2/network/testnet/evm/80084/etherscan"]
    }
  },
  blockExplorers: {
    default: {
      name: "Berachain Bartio Testnet Explorer",
      url: "https://bartio.beratrail.io/",
      apiUrl: ""
    }
  },
  testnet: true
});

// src/evmUtils/evmContractAddresses.ts
var EVMChain = KnownChainId.EVM;
var EVMToken = KnownTokenId.EVM;
var EVMEndpointContract;
((EVMEndpointContract2) => {
  EVMEndpointContract2.BridgeEndpoint = "BridgeEndpoint";
  EVMEndpointContract2.NativeBridgeEndpoint = "NativeBridgeEndpoint";
  EVMEndpointContract2.BridgeConfig = "BridgeConfig";
  EVMEndpointContract2.TimeLock = "TimeLock";
  EVMEndpointContract2.Registry = "Registry";
})(EVMEndpointContract || (EVMEndpointContract = {}));
var evmContractAddresses = {
  [EVMChain.Ethereum]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0x79d1C91053baceced5C796aB8a765E4d5aB38e8a"
  },
  [EVMChain.BSC]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0x7062dB5dcaECDb355878a0BAB00A6941345D8711"
  },
  [EVMChain.CoreDAO]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0x7062dB5dcaECDb355878a0BAB00A6941345D8711"
  },
  [EVMChain.Bsquared]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.BOB]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Bitlayer]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Lorenzo]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Merlin]: {
    // https://t.me/c/1599543687/57297
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.AILayer]: {
    // https://t.me/c/1599543687/57439
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Mode]: {
    // https://t.me/c/1599543687/57779
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.XLayer]: {
    // https://t.me/c/1599543687/58186
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Arbitrum]: {
    // https://t.me/c/1599543687/58824
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Aurora]: {
    // https://t.me/c/1599543687/59145
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Manta]: {
    // https://t.me/c/1599543687/60487
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Linea]: {
    // https://t.me/c/1599543687/61611
    // https://t.me/c/1599543687/61873
    // https://t.me/c/1599543687/61734
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  [EVMChain.Base]: {
    // https://t.me/c/1599543687/64684
    [EVMEndpointContract.BridgeConfig]: "0xf99f62475F50BE59393dbdc148E6627E4E88Fc24"
  },
  // testnet
  [EVMChain.Sepolia]: {
    [EVMEndpointContract.BridgeConfig]: "0xE76e9e28ab8f7974F8bA24e4d83f9550BFe08d21"
  },
  [EVMChain.BSCTestnet]: {},
  [EVMChain.CoreDAOTestnet]: {
    [EVMEndpointContract.BridgeConfig]: "0xdbe8BBA9C95140bc4F5e3480Fe6a958Cd1C7E6CC"
  },
  [EVMChain.BlifeTestnet]: {
    [EVMEndpointContract.BridgeConfig]: "0x643F9D448BC0F8D365bd0DbEEcB5BC6A7b96d922",
    [EVMToken.WBTC]: nativeCurrencyAddress
  },
  [EVMChain.BitboyTestnet]: {
    [EVMEndpointContract.BridgeEndpoint]: "0x3114671EefE856B32851DF4bc5b6278d5A74b86b",
    [EVMToken.sUSDT]: "0x0d05e721F127AF25bDa0FE8836F1A2127028ad01",
    [EVMToken.aBTC]: "0xEf33A9Afa67bad73b8df4beBD4C5Adc678D70528",
    [EVMToken.ALEX]: "0x1DcD5BE312cc70c1e86218D2aC86EDDf79a851E4"
  },
  [EVMChain.BeraTestnet]: {
    // https://t.me/c/1599543687/60509
    // [EVMEndpointContract.BridgeConfig]:
    //   "0xBa175fDaB00e7FCF603f43bE8f68dB7f4de9f3A9",
    // https://t.me/c/1599543687/60499
    [EVMEndpointContract.Registry]: "0x6c74Bc8c54114b8Fed89686cC345eBCd838Fa0b9",
    [EVMToken.aBTC]: "0xD66FEeb23463f99f56363a7de7acEd7d04F3356e",
    [EVMToken.ALEX]: "0x3114671EefE856B32851DF4bc5b6278d5A74b86b",
    [EVMToken.vLiALEX]: "0x8EcfD0a81c2965d16b78e86b8E4Dc71D0109e0e1",
    [EVMToken.vLiSTX]: "0x2e3149230f98e7474AAAB3c1F6323BADfC4A66F8",
    [EVMToken.sUSDT]: "0x8F4eB4dB1493D800Bf476137A25dC3c3cD58952C",
    [EVMToken.wuBTC]: "0x391c193a3268aA0A93D76EAc85B88985b5CB92da"
  }
};

// src/evmUtils/evmClients.ts
var defaultEvmClients = {
  [EVMChain.Ethereum]: (0, import_viem3.createClient)({
    chain: import_chains2.mainnet,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Sepolia]: (0, import_viem3.createClient)({
    chain: import_chains2.sepolia,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.BSC]: (0, import_viem3.createClient)({
    chain: import_chains2.bsc,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.BSCTestnet]: (0, import_viem3.createClient)({
    chain: import_chains2.bscTestnet,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.CoreDAO]: (0, import_viem3.createClient)({
    chain: import_chains2.coreDao,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.CoreDAOTestnet]: (0, import_viem3.createClient)({
    chain: coreDaoTestnet,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Bsquared]: (0, import_viem3.createClient)({
    chain: bsquared,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.BOB]: (0, import_viem3.createClient)({
    chain: import_chains2.bob,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Bitlayer]: (0, import_viem3.createClient)({
    chain: bitlayer,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Lorenzo]: (0, import_viem3.createClient)({
    chain: lorenzo,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Merlin]: (0, import_viem3.createClient)({
    chain: import_chains2.merlin,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.AILayer]: (0, import_viem3.createClient)({
    chain: ailayer,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Mode]: (0, import_viem3.createClient)({
    chain: import_chains2.mode,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.XLayer]: (0, import_viem3.createClient)({
    chain: xLayer,
    transport: (0, import_viem3.fallback)([(0, import_viem3.http)(), (0, import_viem3.http)("https://xlayerrpc.okx.com")]),
    batch: { multicall: true }
  }),
  [EVMChain.Arbitrum]: (0, import_viem3.createClient)({
    chain: import_chains2.arbitrum,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Aurora]: (0, import_viem3.createClient)({
    chain: import_chains2.aurora,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Manta]: (0, import_viem3.createClient)({
    chain: import_chains2.manta,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Linea]: (0, import_viem3.createClient)({
    chain: import_chains2.linea,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.Base]: (0, import_viem3.createClient)({
    chain: import_chains2.base,
    transport: (0, import_viem3.http)(),
    batch: { multicall: true }
  }),
  [EVMChain.BlifeTestnet]: (0, import_viem3.createClient)({
    chain: blifeTestnet,
    transport: (0, import_viem3.http)()
  }),
  [EVMChain.BeraTestnet]: (0, import_viem3.createClient)({
    chain: berachainTestnet,
    transport: (0, import_viem3.http)()
  })
};

// src/evmUtils/xlinkContractHelpers.ts
var import_viem4 = require("viem");
var import_actions = require("viem/actions");

// src/evmUtils/contractAbi/bridgeConfig.ts
var BridgeConfigAbi = [
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: "address",
        name: "previousOwner",
        type: "address"
      },
      {
        indexed: true,
        internalType: "address",
        name: "newOwner",
        type: "address"
      }
    ],
    name: "OwnershipTransferred",
    type: "event"
  },
  {
    inputs: [
      {
        internalType: "string",
        name: "",
        type: "string"
      }
    ],
    name: "config",
    outputs: [
      {
        internalType: "string",
        name: "",
        type: "string"
      }
    ],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [
      {
        internalType: "string[]",
        name: "keys",
        type: "string[]"
      }
    ],
    name: "getConfigs",
    outputs: [
      {
        internalType: "string[]",
        name: "",
        type: "string[]"
      }
    ],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "owner",
    outputs: [
      {
        internalType: "address",
        name: "",
        type: "address"
      }
    ],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "renounceOwnership",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function"
  },
  {
    inputs: [
      {
        internalType: "string[]",
        name: "keys",
        type: "string[]"
      },
      {
        internalType: "string[]",
        name: "values",
        type: "string[]"
      }
    ],
    name: "setConfigs",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function"
  },
  {
    inputs: [
      {
        internalType: "address",
        name: "newOwner",
        type: "address"
      }
    ],
    name: "transferOwnership",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function"
  }
];

// src/evmUtils/xlinkContractHelpers.ts
var CONTRACT_COMMON_NUMBER_SCALE = 18;
var numberFromSolidityContractNumber = (num, decimals) => {
  return BigNumber.leftMoveDecimals(
    decimals ?? CONTRACT_COMMON_NUMBER_SCALE,
    num
  );
};
var numberToSolidityContractNumber = (num, decimals) => {
  return BigNumber.toBigInt(
    {},
    BigNumber.rightMoveDecimals(decimals ?? CONTRACT_COMMON_NUMBER_SCALE, num)
  );
};
async function getEVMContractCallInfo(sdkContext, chainId2) {
  const addresses = await getAllAddresses(sdkContext, chainId2);
  if (addresses == null) return;
  const bridgeEndpointContractAddress = addresses.onChainAddresses?.[EVMEndpointContract.BridgeEndpoint] ?? addresses.localAddresses[EVMEndpointContract.BridgeEndpoint];
  if (bridgeEndpointContractAddress == null) return;
  const nativeBridgeEndpointContractAddress = addresses.onChainAddresses?.[EVMEndpointContract.NativeBridgeEndpoint] ?? addresses.localAddresses[EVMEndpointContract.NativeBridgeEndpoint];
  const registryContractAddress = addresses.onChainAddresses?.[EVMEndpointContract.Registry] ?? addresses.localAddresses[EVMEndpointContract.Registry];
  const timeLockContractAddress = addresses.onChainAddresses?.[EVMEndpointContract.TimeLock] ?? addresses.localAddresses[EVMEndpointContract.TimeLock];
  return {
    client: addresses.client,
    bridgeEndpointContractAddress,
    nativeBridgeEndpointContractAddress,
    registryContractAddress,
    timeLockContractAddress
  };
}
async function getEVMTokenContractInfo(sdkContext, chainId2, tokenId2) {
  const addresses = await getAllAddresses(sdkContext, chainId2);
  if (addresses == null) return;
  const tokenContractAddress = addresses.onChainAddresses?.[tokenId2] ?? addresses.localAddresses[tokenId2];
  if (tokenContractAddress == null) return;
  return {
    client: addresses.client,
    tokenContractAddress
  };
}
async function getEVMToken(sdkContext, chain, tokenAddress) {
  const addresses = await getAllAddresses(sdkContext, chain);
  if (addresses == null) return;
  tokenAddress = tokenAddress.toLowerCase();
  return Object.values(_allKnownEVMTokens).find(
    (token) => (addresses.onChainAddresses?.[token] ?? addresses.localAddresses?.[token])?.toLowerCase() === tokenAddress
  );
}
async function getAllAddresses(sdkContext, chainId2) {
  const client = sdkContext.evm.viemClients[chainId2];
  const localAddresses = evmContractAddresses[chainId2];
  const configContractAddress = localAddresses[EVMEndpointContract.BridgeConfig];
  if (client == null) return;
  let onChainAddresses;
  if (configContractAddress != null) {
    onChainAddresses = await getOnChainConfigs(
      sdkContext,
      chainId2,
      configContractAddress
    );
  }
  return {
    client,
    onChainAddresses,
    localAddresses
  };
}
var getOnChainConfigs = async (sdkContext, chain, configContractAddress) => {
  const cache = sdkContext.evm.onChainConfigCache;
  const cacheKey = `${chain}:${configContractAddress}`;
  if (cache != null) {
    const cachedPromise = cache.get(cacheKey);
    if (cachedPromise != null) return cachedPromise;
  }
  const client = sdkContext.evm.viemClients[chain];
  if (client == null) return;
  const promise = _getOnChainConfigsImpl(
    client,
    chain,
    configContractAddress
  ).catch((err) => {
    queueMicrotask(() => {
      if (cache != null && promise === cache.get(cacheKey)) {
        cache.delete(cacheKey);
      }
    });
    throw err;
  });
  if (cache != null) {
    cache.set(cacheKey, promise);
  }
  return promise;
};
var _getOnChainConfigsImpl = async (client, chain, configContractAddress) => {
  const configs = await (0, import_actions.readContract)(client, {
    abi: BridgeConfigAbi,
    address: configContractAddress,
    functionName: "getConfigs",
    args: [
      [
        "ENDPOINT" /* ENDPOINT */,
        "REGISTRY" /* REGISTRY */,
        "TIMELOCK" /* TIMELOCK */,
        "TOKEN_ABTC" /* TOKEN_ABTC */,
        "TOKEN_ALEX" /* TOKEN_ALEX */,
        "TOKEN_ATALEX" /* TOKEN_ATALEX */,
        "TOKEN_LISTX" /* TOKEN_LISTX */,
        "TOKEN_USDT" /* TOKEN_USDT */,
        "TOKEN_BTC" /* TOKEN_BTC */,
        "TOKEN_LUNR" /* TOKEN_LUNR */,
        "TOKEN_SKO" /* TOKEN_SKO */,
        "TOKEN_SUSDT" /* TOKEN_SUSDT */,
        "TOKEN_UBTC" /* TOKEN_UBTC */,
        "TOKEN_WUBTC" /* TOKEN_WUBTC */,
        "TOKEN_DB20" /* TOKEN_DB20 */,
        "TOKEN_DOG" /* TOKEN_DOG */,
        "ENDPOINT_NATIVE" /* ENDPOINT_NATIVE */
      ]
    ]
  }).catch((err) => {
    console.groupCollapsed(
      `Failed to read on-chain configs from ${configContractAddress} (${chain})`
    );
    console.debug(err);
    console.groupEnd();
    return null;
  });
  if (configs == null) {
    return {};
  }
  const EVMToken2 = KnownTokenId.EVM;
  return {
    [EVMEndpointContract.BridgeEndpoint]: maybeAddress(configs[0]),
    [EVMEndpointContract.Registry]: maybeAddress(configs[1]),
    [EVMEndpointContract.TimeLock]: maybeAddress(configs[2]),
    [EVMToken2.aBTC]: maybeAddress(configs[3]),
    [EVMToken2.ALEX]: maybeAddress(configs[4]),
    [EVMToken2.vLiALEX]: maybeAddress(configs[5]),
    [EVMToken2.vLiSTX]: maybeAddress(configs[6]),
    // prettier-ignore
    [chain === KnownChainId.EVM.Base ? EVMToken2.USDC : EVMToken2.USDT]: maybeAddress(configs[7]),
    // prettier-ignore
    [chain === KnownChainId.EVM.BSC ? EVMToken2.BTCB : chain === KnownChainId.EVM.Base ? EVMToken2.cbBTC : EVMToken2.WBTC]: maybeAddress(configs[8]),
    [EVMToken2.LUNR]: maybeAddress(configs[9]),
    [EVMToken2.SKO]: maybeAddress(configs[10]),
    [EVMToken2.sUSDT]: maybeAddress(configs[11]),
    [EVMToken2.uBTC]: maybeAddress(configs[12]),
    [EVMToken2.wuBTC]: maybeAddress(configs[13]),
    [EVMToken2.DB20]: maybeAddress(configs[14]),
    [EVMToken2.DOG]: maybeAddress(configs[15]),
    [EVMEndpointContract.NativeBridgeEndpoint]: maybeAddress(configs[16])
  };
};
function maybeAddress(value) {
  if (value == null) return void 0;
  if (value === "") return void 0;
  if (!(0, import_viem4.isAddress)(value)) return void 0;
  if (value === import_viem4.zeroAddress) return void 0;
  return value;
}

// src/stacksUtils/xlinkContractHelpers.ts
var import_btc_signer3 = require("@scure/btc-signer");
var import_c32check = require("c32check");
var import_clarity_codegen = require("clarity-codegen");

// generated/smartContractHelpers/codegenImport.ts
var codegenImport_exports = {};
__reExport(codegenImport_exports, require("clarity-codegen"));

// generated/smartContract/contract_xlink_btc-peg-in-endpoint-v2-05.ts
var btcPegInEndpointV205 = (0, codegenImport_exports.defineContract)({
  "btc-peg-in-endpoint-v2-05": {
    callback: {
      input: [
        { name: "sender", type: codegenImport_exports.principalT },
        { name: "payload", type: codegenImport_exports.bufferT }
      ],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "finalize-peg-in-cross": {
      input: [
        { name: "tx", type: codegenImport_exports.bufferT },
        {
          name: "block",
          type: (0, codegenImport_exports.tupleT)({ header: codegenImport_exports.bufferT, height: codegenImport_exports.uintT })
        },
        {
          name: "proof",
          type: (0, codegenImport_exports.tupleT)({ hashes: (0, codegenImport_exports.listT)(codegenImport_exports.bufferT), "tree-depth": codegenImport_exports.uintT, "tx-index": codegenImport_exports.uintT })
        },
        { name: "output-idx", type: codegenImport_exports.uintT },
        {
          name: "reveal-tx",
          type: (0, codegenImport_exports.tupleT)({ "order-idx": codegenImport_exports.uintT, tx: codegenImport_exports.bufferT })
        },
        {
          name: "reveal-block",
          type: (0, codegenImport_exports.tupleT)({ header: codegenImport_exports.bufferT, height: codegenImport_exports.uintT })
        },
        {
          name: "reveal-proof",
          type: (0, codegenImport_exports.tupleT)({ hashes: (0, codegenImport_exports.listT)(codegenImport_exports.bufferT), "tree-depth": codegenImport_exports.uintT, "tx-index": codegenImport_exports.uintT })
        },
        { name: "token-out-trait", type: codegenImport_exports.traitT }
      ],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "pause-peg-in": {
      input: [{ name: "paused", type: codegenImport_exports.booleanT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "set-fee-to-address": {
      input: [{ name: "new-fee-to-address", type: codegenImport_exports.principalT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "set-peg-in-fee": {
      input: [{ name: "fee", type: codegenImport_exports.uintT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "set-peg-in-min-fee": {
      input: [{ name: "fee", type: codegenImport_exports.uintT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
      mode: "public"
    },
    "construct-principal": {
      input: [{ name: "hash-bytes", type: codegenImport_exports.bufferT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.principalT),
      mode: "readonly"
    },
    "create-order-cross-or-fail": {
      input: [
        {
          name: "order",
          type: (0, codegenImport_exports.tupleT)({
            "chain-id": (0, codegenImport_exports.optionalT)(codegenImport_exports.uintT),
            from: codegenImport_exports.bufferT,
            to: codegenImport_exports.bufferT,
            token: codegenImport_exports.principalT,
            "token-out": codegenImport_exports.principalT
          })
        }
      ],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.bufferT),
      mode: "readonly"
    },
    "decode-from-reveal-tx-or-fail": {
      input: [
        { name: "tx", type: codegenImport_exports.bufferT },
        { name: "order-idx", type: codegenImport_exports.uintT }
      ],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({ "commit-txid": codegenImport_exports.bufferT, "order-script": codegenImport_exports.bufferT })),
      mode: "readonly"
    },
    "decode-order-cross-from-reveal-tx-or-fail": {
      input: [
        { name: "tx", type: codegenImport_exports.bufferT },
        { name: "order-idx", type: codegenImport_exports.uintT }
      ],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
        "commit-txid": codegenImport_exports.bufferT,
        "order-details": (0, codegenImport_exports.tupleT)({
          "chain-id": (0, codegenImport_exports.optionalT)(codegenImport_exports.uintT),
          from: codegenImport_exports.bufferT,
          to: codegenImport_exports.bufferT,
          token: codegenImport_exports.principalT,
          "token-out": codegenImport_exports.principalT
        })
      })),
      mode: "readonly"
    },
    "decode-order-cross-or-fail": {
      input: [{ name: "order-script", type: codegenImport_exports.bufferT }],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
        "chain-id": (0, codegenImport_exports.optionalT)(codegenImport_exports.uintT),
        from: codegenImport_exports.bufferT,
        to: codegenImport_exports.bufferT,
        token: codegenImport_exports.principalT,
        "token-out": codegenImport_exports.principalT
      })),
      mode: "readonly"
    },
    "destruct-principal": {
      input: [{ name: "address", type: codegenImport_exports.principalT }],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
        "hash-bytes": codegenImport_exports.bufferT,
        name: (0, codegenImport_exports.optionalT)(codegenImport_exports.stringAsciiT),
        version: codegenImport_exports.bufferT
      })),
      mode: "readonly"
    },
    "extract-tx-ins-outs": {
      input: [{ name: "tx", type: codegenImport_exports.bufferT }],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
        ins: (0, codegenImport_exports.listT)((0, codegenImport_exports.tupleT)({
          outpoint: (0, codegenImport_exports.tupleT)({ hash: codegenImport_exports.bufferT, index: codegenImport_exports.uintT }),
          scriptSig: codegenImport_exports.bufferT,
          sequence: codegenImport_exports.uintT
        })),
        outs: (0, codegenImport_exports.listT)((0, codegenImport_exports.tupleT)({ scriptPubKey: codegenImport_exports.bufferT, value: codegenImport_exports.uintT }))
      })),
      mode: "readonly"
    },
    "get-fee-to-address": { input: [], output: codegenImport_exports.principalT, mode: "readonly" },
    "get-peg-in-fee": { input: [], output: codegenImport_exports.uintT, mode: "readonly" },
    "get-peg-in-min-fee": { input: [], output: codegenImport_exports.uintT, mode: "readonly" },
    "get-peg-in-sent-or-default": {
      input: [{ name: "tx", type: codegenImport_exports.bufferT }, { name: "output", type: codegenImport_exports.uintT }],
      output: codegenImport_exports.booleanT,
      mode: "readonly"
    },
    "get-txid": {
      input: [{ name: "tx", type: codegenImport_exports.bufferT }],
      output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.bufferT),
      mode: "readonly"
    },
    "is-dao-or-extension": { input: [], output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT), mode: "readonly" },
    "is-peg-in-address-approved": {
      input: [{ name: "address", type: codegenImport_exports.bufferT }],
      output: codegenImport_exports.booleanT,
      mode: "readonly"
    },
    "is-peg-in-paused": { input: [], output: codegenImport_exports.booleanT, mode: "readonly" },
    "validate-tx-cross": {
      input: [
        {
          name: "commit-tx",
          type: (0, codegenImport_exports.tupleT)({ "output-idx": codegenImport_exports.uintT, tx: codegenImport_exports.bufferT })
        },
        {
          name: "reveal-tx",
          type: (0, codegenImport_exports.tupleT)({ "order-idx": codegenImport_exports.uintT, tx: codegenImport_exports.bufferT })
        },
        { name: "token-out-trait", type: codegenImport_exports.traitT }
      ],
      output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
        "amount-net": codegenImport_exports.uintT,
        fee: codegenImport_exports.uintT,
        "order-details": (0, codegenImport_exports.tupleT)({
          "chain-id": (0, codegenImport_exports.optionalT)(codegenImport_exports.uintT),
          from: codegenImport_exports.bufferT,
          to: codegenImport_exports.bufferT,
          token: codegenImport_exports.principalT,
          "token-out": codegenImport_expo