@chainflip/bitcoin 1.2.2 → 1.2.3

package/dist/index.cjs

@@ -1,6 +1,288 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); }// src/index.ts
-var _addresscjs = require('./address.cjs'); _createStarExport(_addresscjs);
-var _depositcjs = require('./deposit.cjs');
+'use strict';
 
+var assertion = require('@chainflip/utils/assertion');
+var bytes = require('@chainflip/utils/bytes');
+var bitcoin = require('bitcoinjs-lib');
+var base58 = require('@chainflip/utils/base58');
+var chainflip = require('@chainflip/utils/chainflip');
+var consts = require('@chainflip/utils/consts');
+var ss58 = require('@chainflip/utils/ss58');
+var BigNumber = require('bignumber.js');
+var url = require('@chainflip/utils/url');
+var zod = require('zod');
+var scaleTs = require('scale-ts');
 
-exports.findVaultSwapData = _depositcjs.findVaultSwapData;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
+var base58__namespace = /*#__PURE__*/_interopNamespace(base58);
+var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
+var BigNumber__default = /*#__PURE__*/_interopDefault(BigNumber);
+
+// src/address.ts
+
+// src/consts.ts
+var networkMap = {
+  mainnet: "mainnet",
+  perseverance: "testnet",
+  sisyphos: "testnet",
+  testnet: "testnet",
+  backspin: "regtest",
+  regtest: "regtest"
+};
+
+// src/address.ts
+var p2pkhAddressVersion = {
+  mainnet: 0,
+  testnet: 111,
+  regtest: 111
+};
+var p2shAddressVersion = {
+  mainnet: 5,
+  testnet: 196,
+  regtest: 196
+};
+var networkHrp = {
+  mainnet: "bc",
+  testnet: "tb",
+  regtest: "bcrt"
+};
+var segwitVersions = {
+  P2WPKH: 0,
+  P2WSH: 0,
+  Taproot: 1
+};
+var byteLikeToUint8Array = (data) => typeof data === "string" ? bytes.hexToBytes(data) : new Uint8Array(data);
+var encodeAddress = (data, kind, cfOrBtcnetwork) => {
+  const btcNetwork = networkMap[cfOrBtcnetwork];
+  assertion.assert(btcNetwork, `Invalid network: ${cfOrBtcnetwork}`);
+  assertion.assert(data.length % 2 === 0, "bytes must have an even number of characters");
+  assertion.assert(
+    typeof data !== "string" || /^(0x)?[0-9a-f]*$/.test(data),
+    "bytes are not a valid hex string"
+  );
+  const bytes = byteLikeToUint8Array(data);
+  switch (kind) {
+    case "P2PKH":
+    case "P2SH": {
+      const version = (kind === "P2SH" ? p2shAddressVersion : p2pkhAddressVersion)[btcNetwork];
+      return bitcoin__namespace.address.toBase58Check(bytes, version);
+    }
+    case "P2WPKH":
+    case "P2WSH":
+    case "Taproot":
+      return bitcoin__namespace.address.toBech32(bytes, segwitVersions[kind], networkHrp[btcNetwork]);
+    default:
+      throw new Error(`Invalid address type: ${kind}`);
+  }
+};
+var decodeAddress = (address2, cfOrBtcNetwork) => {
+  const network = networkMap[cfOrBtcNetwork];
+  if (/^[13mn2]/.test(address2)) {
+    const { hash, version } = bitcoin__namespace.address.fromBase58Check(address2);
+    if (version === p2pkhAddressVersion[network]) {
+      return { type: "P2PKH", data: hash, version };
+    }
+    if (version === p2shAddressVersion[network]) {
+      return { type: "P2SH", data: hash, version };
+    }
+    throw new TypeError(`Invalid version: ${version}`);
+  }
+  if (/^(bc|tb|bcrt)1/.test(address2)) {
+    const { data, prefix, version } = bitcoin__namespace.address.fromBech32(address2);
+    assertion.assert(prefix === networkHrp[network], `Invalid prefix: ${prefix}`);
+    let type;
+    if (version === 0 && data.length === 20) {
+      type = "P2WPKH";
+    } else if (version === 0) {
+      type = "P2WSH";
+    } else if (version === 1) {
+      type = "Taproot";
+    } else {
+      throw new TypeError(`Invalid version: ${version}`);
+    }
+    return { hrp: prefix, data, type, version };
+  }
+  throw new TypeError(`Invalid address "${address2}" for network "${network}"`);
+};
+var isValidAddressForNetwork = (address2, cfOrBtcNetwork) => {
+  try {
+    decodeAddress(address2, cfOrBtcNetwork);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hexString = zod.z.string().regex(/^([0-9a-f]{2})+$/, { message: "expected hex string" });
+var vout = zod.z.object({
+  value: zod.z.number().transform((n) => BigInt(new BigNumber__default.default(n).shiftedBy(8).toFixed(0))),
+  n: zod.z.number()
+});
+var nulldataVout = zod.z.object({
+  scriptPubKey: zod.z.object({
+    type: zod.z.literal("nulldata"),
+    // remove OP_RETURN and PUSH_BYTES_XX
+    hex: hexString.transform((x) => bytes.hexToBytes(`0x${x.slice(4)}`))
+  })
+}).and(vout);
+var addressVout = zod.z.object({
+  scriptPubKey: zod.z.object({
+    type: zod.z.enum([
+      "witness_v1_taproot",
+      "witness_v0_scripthash",
+      "witness_v0_keyhash",
+      "pubkeyhash",
+      "scripthash"
+    ]),
+    address: zod.z.string()
+  })
+}).and(vout);
+var txSchema = zod.z.object({
+  vout: zod.z.tuple([addressVout, nulldataVout, addressVout]),
+  blockhash: hexString.nullish()
+});
+var blockSchema = zod.z.object({
+  height: zod.z.number()
+});
+var responseSchemas = {
+  getrawtransaction: txSchema,
+  getblock: blockSchema
+};
+var rpcResponse = zod.z.union([
+  zod.z.object({ result: zod.z.null(), error: zod.z.object({ code: zod.z.number(), message: zod.z.string() }) }),
+  zod.z.object({ result: zod.z.unknown(), error: zod.z.null() })
+]);
+var makeRequest = async (rpcUrl, method, params) => {
+  const { url: url$1, headers } = url.parseUrlWithBasicAuth(rpcUrl);
+  const res = await fetch(url$1, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      params
+    })
+  });
+  const json = await res.json();
+  const result = rpcResponse.parse(json);
+  if (result.error) {
+    if (result.error.code === -5) return null;
+    throw new Error(`RPC error [${result.error.code}]: ${result.error.message}`);
+  }
+  const parseResult = responseSchemas[method].safeParse(result.result);
+  if (!parseResult.success) {
+    if (method === "getrawtransaction") return null;
+    throw parseResult.error;
+  }
+  return parseResult.data;
+};
+var addressByteLengths = {
+  Bitcoin: void 0,
+  Arbitrum: 20,
+  Ethereum: 20,
+  Solana: 32,
+  Polkadot: 32
+};
+var createSwapDataCodec = (asset) => scaleTs.Struct({
+  version: scaleTs.u8,
+  destinationAsset: scaleTs.u8,
+  destinationAddress: scaleTs.Bytes(addressByteLengths[chainflip.assetConstants[asset].chain]),
+  parameters: scaleTs.Struct({
+    retryDuration: scaleTs.u16,
+    minOutputAmount: scaleTs.u128,
+    numberOfChunks: scaleTs.u16,
+    chunkInterval: scaleTs.u16,
+    boostFee: scaleTs.u8,
+    brokerFee: scaleTs.u8,
+    affiliates: scaleTs.Vector(scaleTs.Struct({ accountIndex: scaleTs.u8, commissionBps: scaleTs.u8 }))
+  })
+});
+
+// src/deposit.ts
+var encodeChainAddress = (data, asset) => {
+  switch (chainflip.assetConstants[asset].chain) {
+    case "Solana":
+      return base58__namespace.encode(data);
+    case "Polkadot":
+      return ss58__namespace.encode({ data, ss58Format: consts.POLKADOT_SS58_PREFIX });
+    case "Ethereum":
+    case "Arbitrum":
+      return bytes.bytesToHex(data);
+    case "Bitcoin":
+      return new TextDecoder().decode(data);
+  }
+};
+var contractIdToInternalAsset = Object.fromEntries(
+  Object.entries(chainflip.assetContractId).map(([asset, id]) => [id, asset])
+);
+var parseVaultSwapData = (data) => {
+  const version = data[0];
+  assertion.assert(version === 0, "unsupported version");
+  const contractId = data[1];
+  const outputAsset = contractIdToInternalAsset[contractId];
+  assertion.assert(outputAsset, "unknown asset contract id");
+  const { destinationAddress, parameters } = createSwapDataCodec(outputAsset).dec(data);
+  return {
+    ...parameters,
+    outputAsset,
+    destinationAddress: encodeChainAddress(destinationAddress, outputAsset)
+  };
+};
+var getX128PriceFromAmounts = (depositAmount, minOutputAmount) => BigInt(
+  new BigNumber.BigNumber(minOutputAmount.toString()).div(depositAmount.toString()).multipliedBy(new BigNumber.BigNumber(2).pow(128)).toFixed(0, BigNumber.BigNumber.ROUND_FLOOR)
+);
+var findVaultSwapData = async (url, txId) => {
+  const tx = await makeRequest(url, "getrawtransaction", [txId, true]);
+  if (!tx) return null;
+  const data = parseVaultSwapData(tx.vout[1].scriptPubKey.hex);
+  const amount = tx.vout[0].value;
+  const block = tx.blockhash ? await makeRequest(url, "getblock", [tx.blockhash, true]).catch(() => null) : null;
+  return {
+    inputAsset: "Btc",
+    amount,
+    depositAddress: tx.vout[0].scriptPubKey.address,
+    refundParams: {
+      refundAddress: tx.vout[2].scriptPubKey.address,
+      retryDuration: data.retryDuration,
+      minPrice: getX128PriceFromAmounts(amount, data.minOutputAmount)
+    },
+    destinationAddress: data.destinationAddress,
+    outputAsset: data.outputAsset,
+    brokerFee: { account: null, commissionBps: data.brokerFee },
+    affiliateFees: data.affiliates,
+    ccmDepositMetadata: null,
+    maxBoostFee: data.boostFee,
+    dcaParams: data.numberOfChunks > 0 && data.chunkInterval > 0 ? {
+      chunkInterval: data.chunkInterval,
+      numberOfChunks: data.numberOfChunks
+    } : null,
+    depositChainBlockHeight: block && block.height
+  };
+};
+
+exports.decodeAddress = decodeAddress;
+exports.encodeAddress = encodeAddress;
+exports.findVaultSwapData = findVaultSwapData;
+exports.isValidAddressForNetwork = isValidAddressForNetwork;

package/dist/index.d.cts

@@ -1,5 +1,36 @@
-export { Base58AddressType, Bytelike, DecodedBase58Address, DecodedSegwitAddress, HRP, SegwitAddressType, decodeAddress, encodeAddress, isValidAddressForNetwork } from './address.cjs';
-export { BitcoinNetwork, ChainflipNetwork } from './consts.cjs';
-export { BitcoinVaultSwapData, findVaultSwapData } from './deposit.cjs';
-import '@chainflip/utils/chainflip';
-import '@chainflip/utils/types';
+import { ChainflipNetwork as ChainflipNetwork$1 } from '@chainflip/utils/chainflip';
+import { VaultSwapData } from '@chainflip/utils/types';
+
+type ChainflipNetwork = 'mainnet' | 'perseverance' | 'sisyphos' | 'backspin';
+type BitcoinNetwork = 'mainnet' | 'testnet' | 'regtest';
+
+type Bytelike = Uint8Array | number[] | `0x${string}`;
+declare const networkHrp: {
+    readonly mainnet: "bc";
+    readonly testnet: "tb";
+    readonly regtest: "bcrt";
+};
+type HRP = (typeof networkHrp)[keyof typeof networkHrp];
+type Base58AddressType = 'P2SH' | 'P2PKH';
+type DecodedBase58Address = {
+    type: Base58AddressType;
+    data: Uint8Array;
+    version: number;
+};
+type DecodedSegwitAddress = {
+    hrp: HRP;
+    data: Uint8Array;
+    type: SegwitAddressType;
+    version: number;
+};
+type SegwitAddressType = 'P2WPKH' | 'P2WSH' | 'Taproot';
+declare const encodeAddress: (data: Bytelike, kind: Base58AddressType | SegwitAddressType, cfOrBtcnetwork: BitcoinNetwork | ChainflipNetwork$1) => string;
+declare const decodeAddress: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork$1) => DecodedBase58Address | DecodedSegwitAddress;
+declare const isValidAddressForNetwork: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork$1) => boolean;
+
+type BitcoinVaultSwapData = VaultSwapData<null> & {
+    depositAddress: string;
+};
+declare const findVaultSwapData: (url: string, txId: string) => Promise<BitcoinVaultSwapData | null>;
+
+export { type Base58AddressType, type BitcoinNetwork, type BitcoinVaultSwapData, type Bytelike, type ChainflipNetwork, type DecodedBase58Address, type DecodedSegwitAddress, type HRP, type SegwitAddressType, decodeAddress, encodeAddress, findVaultSwapData, isValidAddressForNetwork };

package/dist/index.d.ts

@@ -1,5 +1,36 @@
-export { Base58AddressType, Bytelike, DecodedBase58Address, DecodedSegwitAddress, HRP, SegwitAddressType, decodeAddress, encodeAddress, isValidAddressForNetwork } from './address.js';
-export { BitcoinNetwork, ChainflipNetwork } from './consts.js';
-export { BitcoinVaultSwapData, findVaultSwapData } from './deposit.js';
-import '@chainflip/utils/chainflip';
-import '@chainflip/utils/types';
+import { ChainflipNetwork as ChainflipNetwork$1 } from '@chainflip/utils/chainflip';
+import { VaultSwapData } from '@chainflip/utils/types';
+
+type ChainflipNetwork = 'mainnet' | 'perseverance' | 'sisyphos' | 'backspin';
+type BitcoinNetwork = 'mainnet' | 'testnet' | 'regtest';
+
+type Bytelike = Uint8Array | number[] | `0x${string}`;
+declare const networkHrp: {
+    readonly mainnet: "bc";
+    readonly testnet: "tb";
+    readonly regtest: "bcrt";
+};
+type HRP = (typeof networkHrp)[keyof typeof networkHrp];
+type Base58AddressType = 'P2SH' | 'P2PKH';
+type DecodedBase58Address = {
+    type: Base58AddressType;
+    data: Uint8Array;
+    version: number;
+};
+type DecodedSegwitAddress = {
+    hrp: HRP;
+    data: Uint8Array;
+    type: SegwitAddressType;
+    version: number;
+};
+type SegwitAddressType = 'P2WPKH' | 'P2WSH' | 'Taproot';
+declare const encodeAddress: (data: Bytelike, kind: Base58AddressType | SegwitAddressType, cfOrBtcnetwork: BitcoinNetwork | ChainflipNetwork$1) => string;
+declare const decodeAddress: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork$1) => DecodedBase58Address | DecodedSegwitAddress;
+declare const isValidAddressForNetwork: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork$1) => boolean;
+
+type BitcoinVaultSwapData = VaultSwapData<null> & {
+    depositAddress: string;
+};
+declare const findVaultSwapData: (url: string, txId: string) => Promise<BitcoinVaultSwapData | null>;
+
+export { type Base58AddressType, type BitcoinNetwork, type BitcoinVaultSwapData, type Bytelike, type ChainflipNetwork, type DecodedBase58Address, type DecodedSegwitAddress, type HRP, type SegwitAddressType, decodeAddress, encodeAddress, findVaultSwapData, isValidAddressForNetwork };

package/dist/index.js

@@ -0,0 +1,258 @@
+import { assert } from '@chainflip/utils/assertion';
+import { hexToBytes, bytesToHex } from '@chainflip/utils/bytes';
+import * as bitcoin from 'bitcoinjs-lib';
+import * as base58 from '@chainflip/utils/base58';
+import { assetContractId, assetConstants } from '@chainflip/utils/chainflip';
+import { POLKADOT_SS58_PREFIX } from '@chainflip/utils/consts';
+import * as ss58 from '@chainflip/utils/ss58';
+import BigNumber, { BigNumber as BigNumber$1 } from 'bignumber.js';
+import { parseUrlWithBasicAuth } from '@chainflip/utils/url';
+import { z } from 'zod';
+import { Struct, Bytes, u8, Vector, u16, u128 } from 'scale-ts';
+
+// src/address.ts
+
+// src/consts.ts
+var networkMap = {
+  mainnet: "mainnet",
+  perseverance: "testnet",
+  sisyphos: "testnet",
+  testnet: "testnet",
+  backspin: "regtest",
+  regtest: "regtest"
+};
+
+// src/address.ts
+var p2pkhAddressVersion = {
+  mainnet: 0,
+  testnet: 111,
+  regtest: 111
+};
+var p2shAddressVersion = {
+  mainnet: 5,
+  testnet: 196,
+  regtest: 196
+};
+var networkHrp = {
+  mainnet: "bc",
+  testnet: "tb",
+  regtest: "bcrt"
+};
+var segwitVersions = {
+  P2WPKH: 0,
+  P2WSH: 0,
+  Taproot: 1
+};
+var byteLikeToUint8Array = (data) => typeof data === "string" ? hexToBytes(data) : new Uint8Array(data);
+var encodeAddress = (data, kind, cfOrBtcnetwork) => {
+  const btcNetwork = networkMap[cfOrBtcnetwork];
+  assert(btcNetwork, `Invalid network: ${cfOrBtcnetwork}`);
+  assert(data.length % 2 === 0, "bytes must have an even number of characters");
+  assert(
+    typeof data !== "string" || /^(0x)?[0-9a-f]*$/.test(data),
+    "bytes are not a valid hex string"
+  );
+  const bytes = byteLikeToUint8Array(data);
+  switch (kind) {
+    case "P2PKH":
+    case "P2SH": {
+      const version = (kind === "P2SH" ? p2shAddressVersion : p2pkhAddressVersion)[btcNetwork];
+      return bitcoin.address.toBase58Check(bytes, version);
+    }
+    case "P2WPKH":
+    case "P2WSH":
+    case "Taproot":
+      return bitcoin.address.toBech32(bytes, segwitVersions[kind], networkHrp[btcNetwork]);
+    default:
+      throw new Error(`Invalid address type: ${kind}`);
+  }
+};
+var decodeAddress = (address2, cfOrBtcNetwork) => {
+  const network = networkMap[cfOrBtcNetwork];
+  if (/^[13mn2]/.test(address2)) {
+    const { hash, version } = bitcoin.address.fromBase58Check(address2);
+    if (version === p2pkhAddressVersion[network]) {
+      return { type: "P2PKH", data: hash, version };
+    }
+    if (version === p2shAddressVersion[network]) {
+      return { type: "P2SH", data: hash, version };
+    }
+    throw new TypeError(`Invalid version: ${version}`);
+  }
+  if (/^(bc|tb|bcrt)1/.test(address2)) {
+    const { data, prefix, version } = bitcoin.address.fromBech32(address2);
+    assert(prefix === networkHrp[network], `Invalid prefix: ${prefix}`);
+    let type;
+    if (version === 0 && data.length === 20) {
+      type = "P2WPKH";
+    } else if (version === 0) {
+      type = "P2WSH";
+    } else if (version === 1) {
+      type = "Taproot";
+    } else {
+      throw new TypeError(`Invalid version: ${version}`);
+    }
+    return { hrp: prefix, data, type, version };
+  }
+  throw new TypeError(`Invalid address "${address2}" for network "${network}"`);
+};
+var isValidAddressForNetwork = (address2, cfOrBtcNetwork) => {
+  try {
+    decodeAddress(address2, cfOrBtcNetwork);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hexString = z.string().regex(/^([0-9a-f]{2})+$/, { message: "expected hex string" });
+var vout = z.object({
+  value: z.number().transform((n) => BigInt(new BigNumber(n).shiftedBy(8).toFixed(0))),
+  n: z.number()
+});
+var nulldataVout = z.object({
+  scriptPubKey: z.object({
+    type: z.literal("nulldata"),
+    // remove OP_RETURN and PUSH_BYTES_XX
+    hex: hexString.transform((x) => hexToBytes(`0x${x.slice(4)}`))
+  })
+}).and(vout);
+var addressVout = z.object({
+  scriptPubKey: z.object({
+    type: z.enum([
+      "witness_v1_taproot",
+      "witness_v0_scripthash",
+      "witness_v0_keyhash",
+      "pubkeyhash",
+      "scripthash"
+    ]),
+    address: z.string()
+  })
+}).and(vout);
+var txSchema = z.object({
+  vout: z.tuple([addressVout, nulldataVout, addressVout]),
+  blockhash: hexString.nullish()
+});
+var blockSchema = z.object({
+  height: z.number()
+});
+var responseSchemas = {
+  getrawtransaction: txSchema,
+  getblock: blockSchema
+};
+var rpcResponse = z.union([
+  z.object({ result: z.null(), error: z.object({ code: z.number(), message: z.string() }) }),
+  z.object({ result: z.unknown(), error: z.null() })
+]);
+var makeRequest = async (rpcUrl, method, params) => {
+  const { url, headers } = parseUrlWithBasicAuth(rpcUrl);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      params
+    })
+  });
+  const json = await res.json();
+  const result = rpcResponse.parse(json);
+  if (result.error) {
+    if (result.error.code === -5) return null;
+    throw new Error(`RPC error [${result.error.code}]: ${result.error.message}`);
+  }
+  const parseResult = responseSchemas[method].safeParse(result.result);
+  if (!parseResult.success) {
+    if (method === "getrawtransaction") return null;
+    throw parseResult.error;
+  }
+  return parseResult.data;
+};
+var addressByteLengths = {
+  Bitcoin: void 0,
+  Arbitrum: 20,
+  Ethereum: 20,
+  Solana: 32,
+  Polkadot: 32
+};
+var createSwapDataCodec = (asset) => Struct({
+  version: u8,
+  destinationAsset: u8,
+  destinationAddress: Bytes(addressByteLengths[assetConstants[asset].chain]),
+  parameters: Struct({
+    retryDuration: u16,
+    minOutputAmount: u128,
+    numberOfChunks: u16,
+    chunkInterval: u16,
+    boostFee: u8,
+    brokerFee: u8,
+    affiliates: Vector(Struct({ accountIndex: u8, commissionBps: u8 }))
+  })
+});
+
+// src/deposit.ts
+var encodeChainAddress = (data, asset) => {
+  switch (assetConstants[asset].chain) {
+    case "Solana":
+      return base58.encode(data);
+    case "Polkadot":
+      return ss58.encode({ data, ss58Format: POLKADOT_SS58_PREFIX });
+    case "Ethereum":
+    case "Arbitrum":
+      return bytesToHex(data);
+    case "Bitcoin":
+      return new TextDecoder().decode(data);
+  }
+};
+var contractIdToInternalAsset = Object.fromEntries(
+  Object.entries(assetContractId).map(([asset, id]) => [id, asset])
+);
+var parseVaultSwapData = (data) => {
+  const version = data[0];
+  assert(version === 0, "unsupported version");
+  const contractId = data[1];
+  const outputAsset = contractIdToInternalAsset[contractId];
+  assert(outputAsset, "unknown asset contract id");
+  const { destinationAddress, parameters } = createSwapDataCodec(outputAsset).dec(data);
+  return {
+    ...parameters,
+    outputAsset,
+    destinationAddress: encodeChainAddress(destinationAddress, outputAsset)
+  };
+};
+var getX128PriceFromAmounts = (depositAmount, minOutputAmount) => BigInt(
+  new BigNumber$1(minOutputAmount.toString()).div(depositAmount.toString()).multipliedBy(new BigNumber$1(2).pow(128)).toFixed(0, BigNumber$1.ROUND_FLOOR)
+);
+var findVaultSwapData = async (url, txId) => {
+  const tx = await makeRequest(url, "getrawtransaction", [txId, true]);
+  if (!tx) return null;
+  const data = parseVaultSwapData(tx.vout[1].scriptPubKey.hex);
+  const amount = tx.vout[0].value;
+  const block = tx.blockhash ? await makeRequest(url, "getblock", [tx.blockhash, true]).catch(() => null) : null;
+  return {
+    inputAsset: "Btc",
+    amount,
+    depositAddress: tx.vout[0].scriptPubKey.address,
+    refundParams: {
+      refundAddress: tx.vout[2].scriptPubKey.address,
+      retryDuration: data.retryDuration,
+      minPrice: getX128PriceFromAmounts(amount, data.minOutputAmount)
+    },
+    destinationAddress: data.destinationAddress,
+    outputAsset: data.outputAsset,
+    brokerFee: { account: null, commissionBps: data.brokerFee },
+    affiliateFees: data.affiliates,
+    ccmDepositMetadata: null,
+    maxBoostFee: data.boostFee,
+    dcaParams: data.numberOfChunks > 0 && data.chunkInterval > 0 ? {
+      chunkInterval: data.chunkInterval,
+      numberOfChunks: data.numberOfChunks
+    } : null,
+    depositChainBlockHeight: block && block.height
+  };
+};
+
+export { decodeAddress, encodeAddress, findVaultSwapData, isValidAddressForNetwork };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainflip/bitcoin",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "type": "module",
   "repository": "https://github.com/chainflip-io/chainflip-product-toolkit.git",
   "publishConfig": {
@@ -11,20 +11,10 @@
     "dist",
     "README.md"
   ],
-  "exports": {
-    ".": {
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      },
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.mjs"
-      }
-    }
-  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "dependencies": {
-    "@chainflip/utils": "0.7.1",
+    "@chainflip/utils": "0.7.2",
     "bignumber.js": "^9.1.2",
     "bitcoinjs-lib": "^7.0.0-rc.0",
     "scale-ts": "^1.6.1",
@@ -37,7 +27,7 @@
     "prettier:write": "pnpm prettier:base --write",
     "prepublish": "pnpm build && pnpm test run",
     "clean": "rm -rf dist",
-    "tsup:build": "tsup --config tsup.config.mts",
+    "tsup:build": "tsup ./src/index.ts --format esm,cjs --dts --treeshake",
     "build": "pnpm clean && pnpm tsup:build",
     "test:ci": "CI=1 pnpm t run",
     "test": "vitest"