@chainflip/bitcoin 1.2.7 → 2.1.0-beta.1

package/dist/rpc.d.mts

@@ -0,0 +1,167 @@
+import { z } from "zod";
+
+//#region src/rpc.d.ts
+type RpcRequest = {
+  getrawtransaction: [txId: string, enhanced?: boolean];
+  getblock: [blockHash: string, enhanced?: boolean];
+};
+declare const responseSchemas: {
+  readonly getrawtransaction: z.ZodObject<{
+    vout: z.ZodTuple<[z.ZodIntersection<z.ZodObject<{
+      scriptPubKey: z.ZodObject<{
+        type: z.ZodEnum<["witness_v1_taproot", "witness_v0_scripthash", "witness_v0_keyhash", "pubkeyhash", "scripthash"]>;
+        address: z.ZodString;
+      }, "strip", z.ZodTypeAny, {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      }, {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      }>;
+    }, "strip", z.ZodTypeAny, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    }, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    }>, z.ZodObject<{
+      value: z.ZodEffects<z.ZodNumber, bigint, number>;
+      n: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+      value: bigint;
+      n: number;
+    }, {
+      value: number;
+      n: number;
+    }>>, z.ZodIntersection<z.ZodObject<{
+      scriptPubKey: z.ZodObject<{
+        type: z.ZodLiteral<"nulldata">;
+        hex: z.ZodEffects<z.ZodString, Uint8Array<ArrayBufferLike>, string>;
+      }, "strip", z.ZodTypeAny, {
+        type: "nulldata";
+        hex: Uint8Array<ArrayBufferLike>;
+      }, {
+        type: "nulldata";
+        hex: string;
+      }>;
+    }, "strip", z.ZodTypeAny, {
+      scriptPubKey: {
+        type: "nulldata";
+        hex: Uint8Array<ArrayBufferLike>;
+      };
+    }, {
+      scriptPubKey: {
+        type: "nulldata";
+        hex: string;
+      };
+    }>, z.ZodObject<{
+      value: z.ZodEffects<z.ZodNumber, bigint, number>;
+      n: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+      value: bigint;
+      n: number;
+    }, {
+      value: number;
+      n: number;
+    }>>, z.ZodIntersection<z.ZodObject<{
+      scriptPubKey: z.ZodObject<{
+        type: z.ZodEnum<["witness_v1_taproot", "witness_v0_scripthash", "witness_v0_keyhash", "pubkeyhash", "scripthash"]>;
+        address: z.ZodString;
+      }, "strip", z.ZodTypeAny, {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      }, {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      }>;
+    }, "strip", z.ZodTypeAny, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    }, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    }>, z.ZodObject<{
+      value: z.ZodEffects<z.ZodNumber, bigint, number>;
+      n: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+      value: bigint;
+      n: number;
+    }, {
+      value: number;
+      n: number;
+    }>>], null>;
+    blockhash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, "strip", z.ZodTypeAny, {
+    vout: [{
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    } & {
+      value: bigint;
+      n: number;
+    }, {
+      scriptPubKey: {
+        type: "nulldata";
+        hex: Uint8Array<ArrayBufferLike>;
+      };
+    } & {
+      value: bigint;
+      n: number;
+    }, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    } & {
+      value: bigint;
+      n: number;
+    }];
+    blockhash?: string | null | undefined;
+  }, {
+    vout: [{
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    } & {
+      value: number;
+      n: number;
+    }, {
+      scriptPubKey: {
+        type: "nulldata";
+        hex: string;
+      };
+    } & {
+      value: number;
+      n: number;
+    }, {
+      scriptPubKey: {
+        type: "witness_v1_taproot" | "witness_v0_scripthash" | "witness_v0_keyhash" | "pubkeyhash" | "scripthash";
+        address: string;
+      };
+    } & {
+      value: number;
+      n: number;
+    }];
+    blockhash?: string | null | undefined;
+  }>;
+  readonly getblock: z.ZodObject<{
+    height: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    height: number;
+  }, {
+    height: number;
+  }>;
+};
+declare const makeRequest: <T extends keyof RpcRequest & keyof typeof responseSchemas>(rpcUrl: string, method: T, params: RpcRequest[T]) => Promise<z.output<(typeof responseSchemas)[T]> | null>;
+//#endregion
+export { makeRequest };

package/dist/rpc.mjs

@@ -0,0 +1,84 @@
+import { hexToBytes } from "@chainflip/utils/bytes";
+import BigNumber from "bignumber.js";
+import { parseUrlWithBasicAuth } from "@chainflip/utils/url";
+import { z } from "zod";
+
+//#region src/rpc.ts
+const hexString = z.string().regex(/^([0-9a-f]{2})+$/, { message: "expected hex string" });
+const vout = z.object({
+	value: z.number().transform((n) => BigInt(new BigNumber(n).shiftedBy(8).toFixed(0))),
+	n: z.number()
+});
+const nulldataVout = z.object({ scriptPubKey: z.object({
+	type: z.literal("nulldata"),
+	hex: hexString.transform((x) => hexToBytes(`0x${x.slice(4)}`))
+}) }).and(vout);
+const 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);
+const responseSchemas = {
+	getrawtransaction: z.object({
+		vout: z.tuple([
+			addressVout,
+			nulldataVout,
+			addressVout
+		]),
+		blockhash: hexString.nullish()
+	}),
+	getblock: z.object({ height: z.number() })
+};
+const 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()
+})]);
+const 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 text = await res.text();
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		if (res.status !== 200) throw new Error(`HTTP error [${res.status}]: ${text || res.statusText}`);
+		throw new Error(`Invalid JSON response: ${text}`);
+	}
+	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;
+};
+
+//#endregion
+export { makeRequest };

package/dist/scale.cjs

@@ -0,0 +1,52 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _chainflip_utils_chainflip = require("@chainflip/utils/chainflip");
+let scale_ts = require("scale-ts");
+
+//#region src/scale.ts
+const addressByteLengths = {
+	Bitcoin: void 0,
+	Arbitrum: 20,
+	Ethereum: 20,
+	Solana: 32,
+	Polkadot: 32,
+	Assethub: 32
+};
+const createSwapDataCodecV0 = (asset) => (0, scale_ts.Struct)({
+	version: scale_ts.u8,
+	destinationAsset: scale_ts.u8,
+	destinationAddress: (0, scale_ts.Bytes)(addressByteLengths[_chainflip_utils_chainflip.assetConstants[asset].chain]),
+	parameters: (0, scale_ts.Struct)({
+		retryDuration: scale_ts.u16,
+		minOutputAmount: scale_ts.u128,
+		numberOfChunks: scale_ts.u16,
+		chunkInterval: scale_ts.u16,
+		boostFee: scale_ts.u8,
+		brokerFee: scale_ts.u8,
+		affiliates: (0, scale_ts.Vector)((0, scale_ts.Struct)({
+			accountIndex: scale_ts.u8,
+			commissionBps: scale_ts.u8
+		}))
+	})
+});
+const createSwapDataCodecV1 = (asset) => (0, scale_ts.Struct)({
+	version: scale_ts.u8,
+	destinationAsset: scale_ts.u8,
+	destinationAddress: (0, scale_ts.Bytes)(addressByteLengths[_chainflip_utils_chainflip.assetConstants[asset].chain]),
+	parameters: (0, scale_ts.Struct)({
+		retryDuration: scale_ts.u16,
+		minOutputAmount: scale_ts.u128,
+		maxOraclePriceSlippage: scale_ts.u8,
+		numberOfChunks: scale_ts.u16,
+		chunkInterval: scale_ts.u16,
+		boostFee: scale_ts.u8,
+		brokerFee: scale_ts.u8,
+		affiliates: (0, scale_ts.Vector)((0, scale_ts.Struct)({
+			accountIndex: scale_ts.u8,
+			commissionBps: scale_ts.u8
+		}))
+	})
+});
+
+//#endregion
+exports.createSwapDataCodecV0 = createSwapDataCodecV0;
+exports.createSwapDataCodecV1 = createSwapDataCodecV1;

package/dist/scale.d.cts

@@ -0,0 +1,44 @@
+import { ChainflipAsset } from "@chainflip/utils/chainflip";
+import * as scale_ts0 from "scale-ts";
+import { CodecType } from "scale-ts";
+
+//#region src/scale.d.ts
+declare const createSwapDataCodecV0: (asset: ChainflipAsset) => scale_ts0.Codec<{
+  version: number;
+  destinationAsset: number;
+  destinationAddress: Uint8Array<ArrayBufferLike>;
+  parameters: {
+    retryDuration: number;
+    minOutputAmount: bigint;
+    numberOfChunks: number;
+    chunkInterval: number;
+    boostFee: number;
+    brokerFee: number;
+    affiliates: {
+      accountIndex: number;
+      commissionBps: number;
+    }[];
+  };
+}>;
+declare const createSwapDataCodecV1: (asset: ChainflipAsset) => scale_ts0.Codec<{
+  version: number;
+  destinationAsset: number;
+  destinationAddress: Uint8Array<ArrayBufferLike>;
+  parameters: {
+    retryDuration: number;
+    minOutputAmount: bigint;
+    maxOraclePriceSlippage: number;
+    numberOfChunks: number;
+    chunkInterval: number;
+    boostFee: number;
+    brokerFee: number;
+    affiliates: {
+      accountIndex: number;
+      commissionBps: number;
+    }[];
+  };
+}>;
+type UtxoDataV0 = CodecType<ReturnType<typeof createSwapDataCodecV0>>['parameters'];
+type UtxoDataV1 = CodecType<ReturnType<typeof createSwapDataCodecV1>>['parameters'];
+//#endregion
+export { UtxoDataV0, UtxoDataV1, createSwapDataCodecV0, createSwapDataCodecV1 };

package/dist/scale.d.mts

@@ -0,0 +1,44 @@
+import { ChainflipAsset } from "@chainflip/utils/chainflip";
+import * as scale_ts0 from "scale-ts";
+import { CodecType } from "scale-ts";
+
+//#region src/scale.d.ts
+declare const createSwapDataCodecV0: (asset: ChainflipAsset) => scale_ts0.Codec<{
+  version: number;
+  destinationAsset: number;
+  destinationAddress: Uint8Array<ArrayBufferLike>;
+  parameters: {
+    retryDuration: number;
+    minOutputAmount: bigint;
+    numberOfChunks: number;
+    chunkInterval: number;
+    boostFee: number;
+    brokerFee: number;
+    affiliates: {
+      accountIndex: number;
+      commissionBps: number;
+    }[];
+  };
+}>;
+declare const createSwapDataCodecV1: (asset: ChainflipAsset) => scale_ts0.Codec<{
+  version: number;
+  destinationAsset: number;
+  destinationAddress: Uint8Array<ArrayBufferLike>;
+  parameters: {
+    retryDuration: number;
+    minOutputAmount: bigint;
+    maxOraclePriceSlippage: number;
+    numberOfChunks: number;
+    chunkInterval: number;
+    boostFee: number;
+    brokerFee: number;
+    affiliates: {
+      accountIndex: number;
+      commissionBps: number;
+    }[];
+  };
+}>;
+type UtxoDataV0 = CodecType<ReturnType<typeof createSwapDataCodecV0>>['parameters'];
+type UtxoDataV1 = CodecType<ReturnType<typeof createSwapDataCodecV1>>['parameters'];
+//#endregion
+export { UtxoDataV0, UtxoDataV1, createSwapDataCodecV0, createSwapDataCodecV1 };

package/dist/scale.mjs

@@ -0,0 +1,50 @@
+import { assetConstants } from "@chainflip/utils/chainflip";
+import { Bytes, Struct, Vector, u128, u16, u8 } from "scale-ts";
+
+//#region src/scale.ts
+const addressByteLengths = {
+	Bitcoin: void 0,
+	Arbitrum: 20,
+	Ethereum: 20,
+	Solana: 32,
+	Polkadot: 32,
+	Assethub: 32
+};
+const createSwapDataCodecV0 = (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
+		}))
+	})
+});
+const createSwapDataCodecV1 = (asset) => Struct({
+	version: u8,
+	destinationAsset: u8,
+	destinationAddress: Bytes(addressByteLengths[assetConstants[asset].chain]),
+	parameters: Struct({
+		retryDuration: u16,
+		minOutputAmount: u128,
+		maxOraclePriceSlippage: u8,
+		numberOfChunks: u16,
+		chunkInterval: u16,
+		boostFee: u8,
+		brokerFee: u8,
+		affiliates: Vector(Struct({
+			accountIndex: u8,
+			commissionBps: u8
+		}))
+	})
+});
+
+//#endregion
+export { createSwapDataCodecV0, createSwapDataCodecV1 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainflip/bitcoin",
-  "version": "1.2.7",
+  "version": "2.1.0-beta.1",
   "type": "module",
   "repository": "https://github.com/chainflip-io/chainflip-product-toolkit.git",
   "publishConfig": {
@@ -18,15 +18,15 @@
         "default": "./dist/index.cjs"
       },
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       }
     }
   },
   "dependencies": {
     "@chainflip/utils": "0.8.18",
     "bignumber.js": "^9.3.1",
-    "bitcoinjs-lib": "7.0.0-rc.0",
+    "bitcoinjs-lib": "7.0.1",
     "scale-ts": "^1.6.1",
     "zod": "^3.25.75"
   },
@@ -37,8 +37,7 @@
     "prettier:write": "pnpm prettier:base --write",
     "prepublish": "pnpm build && pnpm test run",
     "clean": "rm -rf dist",
-    "tsup:build": "tsup ./src/index.ts --format esm,cjs --dts --treeshake",
-    "build": "pnpm clean && pnpm tsup:build",
+    "build": "pnpm clean && pnpm tsdown",
     "test:ci": "CI=1 pnpm t run",
     "test": "vitest"
   }

package/dist/index.d.ts

@@ -1,35 +0,0 @@
-import { ChainflipNetwork } from '@chainflip/utils/chainflip';
-import { VaultSwapData } from '@chainflip/utils/types';
-
-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) => string;
-declare const decodeAddress: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork) => DecodedBase58Address | DecodedSegwitAddress;
-declare const isValidAddressForNetwork: (address: string, cfOrBtcNetwork: BitcoinNetwork | ChainflipNetwork) => 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 DecodedBase58Address, type DecodedSegwitAddress, type HRP, type SegwitAddressType, decodeAddress, encodeAddress, findVaultSwapData, isValidAddressForNetwork };