@xlink-network/xlink-sdk
Version:
1,402 lines (1,371 loc) • 137 kB
JavaScript
"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/xlinkSdkUtils/bridgeFromBitcoin.ts
var bridgeFromBitcoin_exports = {};
__export(bridgeFromBitcoin_exports, {
bridgeFromBitcoin: () => bridgeFromBitcoin,
prepareBitcoinTransaction: () => prepareBitcoinTransaction,
supportedRoutes: () => supportedRoutes
});
module.exports = __toCommonJS(bridgeFromBitcoin_exports);
var btc4 = __toESM(require("@scure/btc-signer"));
// src/bitcoinUtils/apiHelpers/broadcastRevealableTransaction.ts
var import_viem = require("viem");
// src/config.ts
var import_network = require("@stacks/network");
var backendAPIPrefix = "https://sdk-api.xlink.network/";
var STACKS_MAINNET = new import_network.StacksMainnet({
url: "https://stacks-node-api.alexlab.co"
});
var STACKS_TESTNET = new import_network.StacksMocknet({
url: "https://nakamoto-dev-api.alexlab.co"
});
// src/utils/apiHelpers.ts
async function requestAPI(sdkContext, options) {
const queryPairs = Object.entries(options.query ?? {});
const querystring = new URLSearchParams(queryPairs).toString();
const res = await fetch(
`${backendAPIPrefix}${options.path}`.replace(/(\w)\/\//g, "$1/") + (querystring ? "?" + querystring : ""),
{
method: options.method,
headers: {
"Content-Type": "application/json",
"X-Xlink-Runtime-Env": sdkContext.backendAPI.runtimeEnv
},
body: JSON.stringify(options.body)
}
);
return readAPIResponse(res);
}
var readAPIResponse = async (resp) => {
if (resp.status >= 200 && resp.status < 300) {
return resp.json();
}
if (resp.status === 429) {
throw new TooManyRequestsError(resp);
}
const respText = await resp.text();
let respData = null;
try {
respData = JSON.parse(respText);
} catch {
respData = respText;
}
const thirdPartyError = ThirdPartyRequestError.fromSerializedError(respData);
if (thirdPartyError != null) {
throw thirdPartyError;
}
throw new RequestError(
{
url: resp.url,
status: resp.status,
body: respText
},
{
cause: respData
}
);
};
var TooManyRequestsError = class extends Error {
requestUrl;
retryAfter;
constructor(resp, options) {
const _retryAfter = Number(resp.headers.get("Retry-After"));
const retryAfter = Number.isNaN(_retryAfter) ? void 0 : _retryAfter;
let errMsg = `Too many requests to SDK API server`;
if (retryAfter != null) {
errMsg += `; retry after ${retryAfter} seconds`;
}
super(errMsg, {
...options,
cause: options?.cause ?? resp
});
this.requestUrl = resp.url;
this.retryAfter = retryAfter;
}
};
var ThirdPartyRequestError = class _ThirdPartyRequestError extends Error {
constructor(serviceName, options) {
super(`Request service ${serviceName} failed`, options);
this.serviceName = serviceName;
}
isThirdPartyRequestError = true;
static fromSerializedError(err) {
if (!err.isThirdPartyRequestError) return;
return new _ThirdPartyRequestError(err.serviceName, {
cause: err.cause
});
}
};
var RequestError = class extends Error {
constructor(response, options) {
super(
`Request failed:
url: ${response.url}
detail: ${response.body}`,
options
);
this.response = response;
}
};
// src/bitcoinUtils/apiHelpers/broadcastRevealableTransaction.ts
async function broadcastRevealableTransaction(sdkContext, info) {
const resp = await requestAPI(sdkContext, {
path: `/2024-10-01/bitcoin/broadcast`,
method: "POST",
body: {
fromChain: info.fromChain,
transactionHex: info.transactionHex,
orderDataHex: (0, import_viem.toHex)(info.orderData),
orderOutputIndex: info.orderOutputIndex,
orderOutputSatoshiAmount: info.orderOutputSatsAmount.toString(),
xlinkPegInAddress: {
address: info.xlinkPegInAddress.address,
scriptPubKeyHex: (0, import_viem.toHex)(info.xlinkPegInAddress.scriptPubKey)
}
}
});
return { txid: resp.txId };
}
// src/bitcoinUtils/apiHelpers/createBitcoinPegInRecipients.ts
var import_btc_utils2 = require("@c4/btc-utils");
var import_viem2 = require("viem");
// 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;
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/utils/errors.ts
var XLinkSDKErrorBase = class extends Error {
constructor(...args) {
super(...args);
this.name = "XLinkSDKErrorBase";
}
};
var BridgeValidateFailedError = class extends XLinkSDKErrorBase {
constructor(cause) {
super("Bridge order validation failed", { cause });
this.cause = cause;
this.name = "BridgeValidateFailedError";
}
};
var StacksAddressVersionNotSupportedError = class extends XLinkSDKErrorBase {
constructor(address, versionName) {
super(`Stacks address ${address} version not supported: ${versionName}`);
this.address = address;
this.versionName = versionName;
this.name = "StacksAddressVersionNotSupportedError";
}
};
var UnsupportedBridgeRouteError = class extends XLinkSDKErrorBase {
constructor(fromChain, toChain, fromToken, toToken) {
super(
`Unsupported chain combination: ${fromToken}(${fromChain}) -> ${toToken ?? "Unknown Token"}(${toChain})`
);
this.fromChain = fromChain;
this.toChain = toChain;
this.fromToken = fromToken;
this.toToken = toToken;
this.name = "UnsupportedBridgeRouteError";
}
};
var UnsupportedChainError = class extends XLinkSDKErrorBase {
constructor(chain) {
super(`Unsupported chain: ${chain}`);
this.chain = chain;
this.name = "UnsupportedChainError";
}
};
// src/utils/hexHelpers.ts
function decodeHex(hex) {
let hexString = hex.startsWith("0x") ? hex.slice(2) : hex;
if (hexString.length % 2) hexString = `0${hexString}`;
const length = hexString.length / 2;
const bytes = new Uint8Array(length);
for (let index = 0, j = 0; index < length; index++) {
const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
if (nibbleLeft === void 0 || nibbleRight === void 0) {
throw new XLinkSDKErrorBase(
`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`
);
}
bytes[index] = nibbleLeft * 16 + nibbleRight;
}
return bytes;
}
var charCodeMap = {
zero: 48,
nine: 57,
A: 65,
F: 70,
a: 97,
f: 102
};
function charCodeToBase16(char) {
if (char >= charCodeMap.zero && char <= charCodeMap.nine)
return char - charCodeMap.zero;
if (char >= charCodeMap.A && char <= charCodeMap.F)
return char - (charCodeMap.A - 10);
if (char >= charCodeMap.a && char <= charCodeMap.f)
return char - (charCodeMap.a - 10);
return void 0;
}
var hexes = Array.from(
{ length: 256 },
(_v, i) => i.toString(16).padStart(2, "0")
);
// src/utils/typeHelpers.ts
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;
((KnownTokenId4) => {
function isKnownToken(value) {
return isBitcoinToken(value) || isBRC20Token(value) || isRunesToken(value) || isEVMToken(value) || isStacksToken(value);
}
KnownTokenId4.isKnownToken = isKnownToken;
let Bitcoin;
((Bitcoin2) => {
Bitcoin2.BTC = tokenId("btc-btc");
})(Bitcoin = KnownTokenId4.Bitcoin || (KnownTokenId4.Bitcoin = {}));
function isBitcoinToken(value) {
return _allKnownBitcoinTokens.includes(value);
}
KnownTokenId4.isBitcoinToken = isBitcoinToken;
function isBRC20Token(value) {
return value.startsWith("brc20-");
}
KnownTokenId4.isBRC20Token = isBRC20Token;
function isRunesToken(value) {
return value.startsWith("runes-");
}
KnownTokenId4.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 = KnownTokenId4.EVM || (KnownTokenId4.EVM = {}));
function isEVMToken(value) {
return _allKnownEVMTokens.includes(value);
}
KnownTokenId4.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 = KnownTokenId4.Stacks || (KnownTokenId4.Stacks = {}));
function isStacksToken(value) {
return _allKnownStacksTokens.includes(value);
}
KnownTokenId4.isStacksToken = isStacksToken;
})(KnownTokenId || (KnownTokenId = {}));
var _allKnownBitcoinTokens = Object.values(KnownTokenId.Bitcoin);
var _allKnownEVMTokens = Object.values(KnownTokenId.EVM);
var _allKnownStacksTokens = Object.values(KnownTokenId.Stacks);
var KnownChainId;
((KnownChainId3) => {
function isKnownChain(value) {
return isBitcoinChain(value) || isBRC20Chain(value) || isRunesChain(value) || isEVMChain(value) || isStacksChain(value);
}
KnownChainId3.isKnownChain = isKnownChain;
let Bitcoin;
((Bitcoin2) => {
Bitcoin2.Mainnet = chainId("bitcoin-mainnet");
Bitcoin2.Testnet = chainId("bitcoin-testnet");
})(Bitcoin = KnownChainId3.Bitcoin || (KnownChainId3.Bitcoin = {}));
function isBitcoinChain(value) {
return _allKnownBitcoinChains.includes(value);
}
KnownChainId3.isBitcoinChain = isBitcoinChain;
let Runes;
((Runes2) => {
Runes2.Mainnet = chainId("runes-mainnet");
Runes2.Testnet = chainId("runes-testnet");
})(Runes = KnownChainId3.Runes || (KnownChainId3.Runes = {}));
function isRunesChain(value) {
return _allKnownRunesChains.includes(value);
}
KnownChainId3.isRunesChain = isRunesChain;
let BRC20;
((BRC202) => {
BRC202.Mainnet = chainId("brc20-mainnet");
BRC202.Testnet = chainId("brc20-testnet");
})(BRC20 = KnownChainId3.BRC20 || (KnownChainId3.BRC20 = {}));
function isBRC20Chain(value) {
return _allKnownBRC20Chains.includes(value);
}
KnownChainId3.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 = KnownChainId3.EVM || (KnownChainId3.EVM = {}));
function isEVMMainnetChain(value) {
return _allKnownEVMMainnetChains.includes(value);
}
KnownChainId3.isEVMMainnetChain = isEVMMainnetChain;
function isEVMTestnetChain(value) {
return _allKnownEVMTestnetChains.includes(value);
}
KnownChainId3.isEVMTestnetChain = isEVMTestnetChain;
function isEVMChain(value) {
return _allKnownEVMChains.includes(value);
}
KnownChainId3.isEVMChain = isEVMChain;
let Stacks;
((Stacks2) => {
Stacks2.Mainnet = chainId("stacks-mainnet");
Stacks2.Testnet = chainId("stacks-testnet");
})(Stacks = KnownChainId3.Stacks || (KnownChainId3.Stacks = {}));
function isStacksChain(value) {
return _allKnownStacksChains.includes(value);
}
KnownChainId3.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/btcAddresses.ts
var import_btc_signer2 = require("@scure/btc-signer");
// 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/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/bitcoinUtils/prepareTransaction.ts
var import_btc_utils = require("@c4/btc-utils");
var btc2 = __toESM(require("@scure/btc-signer"));
// src/bitcoinUtils/errors.ts
var InsufficientBitcoinBalanceError = class extends XLinkSDKErrorBase {
constructor(...args) {
super(...args);
this.message = this.message || "Insufficient Bitcoin balance with network fees";
}
};
var UnsupportedBitcoinInput = class extends XLinkSDKErrorBase {
constructor(txid, index, ...args) {
super(...args);
this.txid = txid;
this.index = index;
this.message = this.message || `Not supported bitcoin input: ${txid}:${index}`;
}
};
// src/bitcoinUtils/prepareTransaction.ts
async function prepareTransaction(txInfo) {
const {
recipients,
changeAddressScriptPubKey,
opReturnData = [],
selectedUTXOs = [],
feeRate,
reselectSpendableUTXOs
} = txInfo;
const newRecipients = await Promise.all(
recipients.map(async (r) => {
const dustThreshold = await getOutputDustThresholdForOutput(
r.addressScriptPubKey
);
return {
...r,
satsAmount: max([r.satsAmount, dustThreshold])
};
})
);
const newRecipientAddresses = newRecipients.map((r) => r.addressScriptPubKey).concat(changeAddressScriptPubKey);
const satsToSend = sum(newRecipients.map((r) => r.satsAmount));
let lastSelectedUTXOs = selectedUTXOs.slice();
let lastSelectedUTXOSatsInTotal = sumUTXO(lastSelectedUTXOs);
let calculatedFee = await calculateFee({
recipientAddressScriptPubKeys: newRecipientAddresses,
opReturnData,
selectedUTXOs: lastSelectedUTXOs,
feeRate
});
let loopTimes = 0;
while (lastSelectedUTXOSatsInTotal < satsToSend + calculatedFee.fee) {
const newSatsToSend = satsToSend + calculatedFee.fee;
const newSelectedUTXOs = await reselectSpendableUTXOs(
newSatsToSend,
selectedUTXOs,
lastSelectedUTXOs
);
const newSelectedUTXOSatsInTotal = sumUTXO(newSelectedUTXOs);
if (newSelectedUTXOSatsInTotal < lastSelectedUTXOSatsInTotal) {
throw new InsufficientBitcoinBalanceError();
}
lastSelectedUTXOSatsInTotal = newSelectedUTXOSatsInTotal;
lastSelectedUTXOs = newSelectedUTXOs;
calculatedFee = await calculateFee({
recipientAddressScriptPubKeys: newRecipientAddresses,
opReturnData,
selectedUTXOs: newSelectedUTXOs,
feeRate
});
loopTimes++;
if (loopTimes > 500) {
throw new InsufficientBitcoinBalanceError();
}
}
const changeOutputDustThreshold = await getOutputDustThresholdForOutput(
changeAddressScriptPubKey
);
const changeAmount = lastSelectedUTXOSatsInTotal - sum([satsToSend, calculatedFee.fee]);
let finalChangeAmount;
let finalFeeAmount;
if (changeAmount < changeOutputDustThreshold) {
finalChangeAmount = 0n;
finalFeeAmount = lastSelectedUTXOSatsInTotal - satsToSend;
} else {
finalChangeAmount = changeAmount;
finalFeeAmount = calculatedFee.fee;
}
return {
inputs: lastSelectedUTXOs,
recipients: newRecipients,
changeAmount: finalChangeAmount,
fee: finalFeeAmount,
estimatedVSize: calculatedFee.estimatedVSize
};
}
async function getOutputDustThresholdForOutput(outputAddressScriptPubKey) {
return BigInt(
Math.ceil(
(0, import_btc_utils.getOutputDustThreshold)({
scriptPubKey: outputAddressScriptPubKey
})
)
);
}
var DEFAULT_MIN_RELAY_TX_FEE = 1000n;
async function calculateFee(info) {
const outputs = [
...info.recipientAddressScriptPubKeys.map((r) => ({
scriptPubKey: r
})),
...info.opReturnData.map((data) => ({
scriptPubKey: btc2.Script.encode(["RETURN", data])
}))
];
try {
const vSize = (0, import_btc_utils.estimateTransactionVSizeAfterSign)({
inputs: info.selectedUTXOs,
outputs
});
const txSize = BigInt(Math.ceil(vSize));
return {
estimatedVSize: vSize,
fee: max([info.feeRate * txSize, DEFAULT_MIN_RELAY_TX_FEE])
};
} catch (e) {
if (e instanceof import_btc_utils.UnsupportedInputTypeError) {
const input = e.cause;
throw new UnsupportedBitcoinInput(input.txId, input.index);
}
throw e;
}
}
// src/bitcoinUtils/apiHelpers/createBitcoinPegInRecipients.ts
var REVEAL_TX_OUTPUT_AMOUNT = 546n;
async function createBitcoinPegInRecipients(sdkContext, info) {
const pegInAddress = await getBTCPegInAddress(info.fromChain, info.toChain);
if (pegInAddress == null) {
throw new UnsupportedBridgeRouteError(
info.fromChain,
info.toChain,
KnownTokenId.Bitcoin.BTC
);
}
const resp = await requestAPI(sdkContext, {
path: `/2024-10-01/bitcoin/peg-in-recipients`,
method: "POST",
body: {
fromChain: info.fromChain,
toChain: info.toChain,
fromToken: info.fromToken,
toToken: info.toToken,
fromAddress: {
address: info.fromAddress.address,
scriptPubKeyHex: (0, import_viem2.toHex)(info.fromAddress.scriptPubKey)
},
toAddress: info.toAddress,
fromAmount: BigNumber.toString(info.fromAmount),
orderDataHex: (0, import_viem2.toHex)(info.orderData)
}
});
const recipient = resp.addresses.find(
(address) => address.type === "commitOrder"
);
const revealInputSize = (0, import_btc_utils2.estimateInputVSizeAfterSign)({
addressType: "p2tr-leafScript",
tapLeafScriptArgumentByteLengths: [
/* signature */
64
],
tapLeafScriptByteLength: recipient.tapScriptHex.length / 2,
controlBlockByteLength: 33
});
const { fee: newTxFee } = await calculateFee({
recipientAddressScriptPubKeys: [pegInAddress.scriptPubKey],
opReturnData: [],
selectedUTXOs: [],
feeRate: info.feeRate,
extraSize: revealInputSize.inputSize + revealInputSize.witnessDataSize / 4
});
const revealUTXOSatsAmount = BigNumber.sum([
newTxFee,
REVEAL_TX_OUTPUT_AMOUNT
]);
return {
address: recipient.address,
scriptPubKey: decodeHex(recipient.scriptPubKeyHex),
satsAmount: BigNumber.toBigInt(
{ roundingMode: BigNumber.roundUp },
revealUTXOSatsAmount
)
};
}
// src/bitcoinUtils/apiHelpers/createRevealTx.ts
var import_viem3 = require("viem");
async function createRevealTx(sdkContext, info) {
const resp = await requestAPI(sdkContext, {
path: `/2024-10-01/bitcoin/reveal-txs`,
method: "POST",
body: {
fromChain: info.fromChain,
txId: info.txId,
vout: info.vout,
satsAmount: info.satsAmount,
orderDataHex: (0, import_viem3.toHex)(info.orderData),
xlinkPegInAddress: {
address: info.xlinkPegInAddress.address,
scriptPubKeyHex: (0, import_viem3.toHex)(info.xlinkPegInAddress.scriptPubKey)
}
}
});
return { txHex: resp.revealTxHex };
}
// src/bitcoinUtils/createTransaction.ts
var btc3 = __toESM(require("@scure/btc-signer"));
function createTransaction(inputUTXOs, recipients, opReturnData) {
const tx = new btc3.Transaction({
allowUnknownOutputs: true,
allowLegacyWitnessUtxo: true
});
inputUTXOs.forEach((utxo) => {
tx.addInput({
txid: utxo.txId,
index: utxo.index,
witnessUtxo: utxo.scriptPubKey == null ? void 0 : {
script: utxo.scriptPubKey,
amount: utxo.amount
},
tapInternalKey: "tapInternalKey" in utxo ? utxo.tapInternalKey : void 0,
redeemScript: "redeemScript" in utxo ? utxo.redeemScript : void 0,
// Enable RBF
sequence: btc3.DEFAULT_SEQUENCE - 2
});
});
recipients.forEach((recipient) => {
tx.addOutput({
script: recipient.addressScriptPubKey,
amount: recipient.satsAmount
});
});
if (hasAny(opReturnData)) {
opReturnData.forEach((data) => {
tx.addOutput({
script: btc3.Script.encode(["RETURN", data]),
amount: 0n
});
});
}
return tx;
}
// src/bitcoinUtils/peggingHelpers.ts
var import_transactions2 = require("@stacks/transactions");
// src/evmUtils/peggingHelpers.ts
var import_transactions = require("@stacks/transactions");
var import_clarity_codegen2 = require("clarity-codegen");
var import_actions2 = require("viem/actions");
// 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_exports.principalT
})
})),
mode: "readonly"
},
"verify-mined": {
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 })
}
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "readonly"
},
"fee-to-address": { input: codegenImport_exports.noneT, output: codegenImport_exports.principalT, mode: "variable" },
"peg-in-fee": { input: codegenImport_exports.noneT, output: codegenImport_exports.uintT, mode: "variable" },
"peg-in-min-fee": { input: codegenImport_exports.noneT, output: codegenImport_exports.uintT, mode: "variable" },
"peg-in-paused": { input: codegenImport_exports.noneT, output: codegenImport_exports.booleanT, mode: "variable" }
}
});
// generated/smartContract/contract_xlink_btc-peg-out-endpoint-v2-01.ts
var btcPegOutEndpointV201 = (0, codegenImport_exports.defineContract)({
"btc-peg-out-endpoint-v2-01": {
callback: {
input: [
{ name: "sender", type: codegenImport_exports.principalT },
{ name: "payload", type: codegenImport_exports.bufferT }
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"claim-peg-out": {
input: [
{ name: "request-id", type: codegenImport_exports.uintT },
{ name: "fulfilled-by", type: codegenImport_exports.bufferT }
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"finalize-peg-out": {
input: [
{ name: "request-id", type: codegenImport_exports.uintT },
{ 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: "fulfilled-by-idx", type: codegenImport_exports.uintT }
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"pause-peg-out": {
input: [{ name: "paused", type: codegenImport_exports.booleanT }],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"request-peg-out-0": {
input: [
{ name: "peg-out-address", type: codegenImport_exports.bufferT },
{ name: "amount", type: codegenImport_exports.uintT }
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.uintT),
mode: "public"
},
"revoke-peg-out": {
input: [{ name: "request-id", type: codegenImport_exports.uintT }],
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-out-fee": {
input: [{ name: "fee", type: codegenImport_exports.uintT }],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"set-peg-out-min-fee": {
input: [{ name: "fee", type: codegenImport_exports.uintT }],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "public"
},
"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-sent-or-default": {
input: [{ name: "tx", type: codegenImport_exports.bufferT }, { name: "output", type: codegenImport_exports.uintT }],
output: codegenImport_exports.booleanT,
mode: "readonly"
},
"get-peg-out-fee": { input: [], output: codegenImport_exports.uintT, mode: "readonly" },
"get-peg-out-min-fee": { input: [], output: codegenImport_exports.uintT, mode: "readonly" },
"get-request-claim-grace-period": { input: [], output: codegenImport_exports.uintT, mode: "readonly" },
"get-request-or-fail": {
input: [{ name: "request-id", type: codegenImport_exports.uintT }],
output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({
"amount-net": codegenImport_exports.uintT,
claimed: codegenImport_exports.uintT,
"claimed-by": codegenImport_exports.principalT,
fee: codegenImport_exports.uintT,
finalized: codegenImport_exports.booleanT,
"fulfilled-by": codegenImport_exports.bufferT,
"gas-fee": codegenImport_exports.uintT,
"peg-out-address": codegenImport_exports.bufferT,
"requested-at": codegenImport_exports.uintT,
"requested-at-burn-height": codegenImport_exports.uintT,
"requested-by": codegenImport_exports.principalT,
revoked: codegenImport_exports.booleanT
})),
mode: "readonly"
},
"get-request-revoke-grace-period": { input: [], output: codegenImport_exports.uintT, 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-out-paused": { input: [], output: codegenImport_exports.booleanT, mode: "readonly" },
"validate-peg-out-0": {
input: [{ name: "amount", type: codegenImport_exports.uintT }],
output: (0, codegenImport_exports.responseSimpleT)((0, codegenImport_exports.tupleT)({ amount: codegenImport_exports.uintT, fee: codegenImport_exports.uintT, "gas-fee": codegenImport_exports.uintT })),
mode: "readonly"
},
"verify-mined": {
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 })
}
],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "readonly"
},
"fee-to-address": { input: codegenImport_exports.noneT, output: codegenImport_exports.principalT, mode: "variable" },
"peg-out-fee": { input: codegenImport_exports.noneT, output: codegenImport_exports.uintT, mode: "variable" },
"peg-out-min-fee": { input: codegenImport_exports.noneT, output: codegenImport_exports.uintT, mode: "variable" },
"peg-out-paused": { input: codegenImport_exports.noneT, output: codegenImport_exports.booleanT, mode: "variable" }
}
});
// generated/smartContract/contract_xlink_cross-peg-in-endpoint-v2-04.ts
var crossPegInEndpointV204 = (0, codegenImport_exports.defineContract)({
"cross-peg-in-endpoint-v2-04": {
"apply-whitelist": {
input: [{ name: "new-use-whitelist", type: codegenImport_exports.booleanT }],
output: (0, codegenImport_exports.responseSimpleT)(codegenImport_exports.booleanT),
mode: "