@mysten-incubation/hashi 0.0.1

package/dist/contracts/hashi/withdrawal_queue.mjs

@@ -0,0 +1,131 @@
+import { MoveEnum, MoveStruct } from "../utils/index.mjs";
+import { ObjectBag } from "./deps/sui/object_bag.mjs";
+import { Utxo, UtxoId } from "./utxo.mjs";
+import { Balance } from "./deps/sui/balance.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/hashi/withdrawal_queue.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+const $moduleName = "@local-pkg/hashi::withdrawal_queue";
+const WithdrawalRequestQueue = new MoveStruct({
+	name: `${$moduleName}::WithdrawalRequestQueue`,
+	fields: {
+		requests: ObjectBag,
+		processed: ObjectBag,
+		withdrawal_txns: ObjectBag,
+		confirmed_txns: ObjectBag
+	}
+});
+const OutputUtxo = new MoveStruct({
+	name: `${$moduleName}::OutputUtxo`,
+	fields: {
+		amount: bcs.u64(),
+		bitcoin_address: bcs.vector(bcs.u8())
+	}
+});
+const WithdrawalStatus = new MoveEnum({
+	name: `${$moduleName}::WithdrawalStatus`,
+	fields: {
+		Requested: null,
+		Approved: null,
+		Processing: null,
+		Signed: null,
+		Confirmed: null
+	}
+});
+const WithdrawalRequest = new MoveStruct({
+	name: `${$moduleName}::WithdrawalRequest`,
+	fields: {
+		id: bcs.Address,
+		sender: bcs.Address,
+		btc_amount: bcs.u64(),
+		bitcoin_address: bcs.vector(bcs.u8()),
+		timestamp_ms: bcs.u64(),
+		status: WithdrawalStatus,
+		withdrawal_txn_id: bcs.option(bcs.Address),
+		sui_tx_digest: bcs.vector(bcs.u8()),
+		btc: Balance
+	}
+});
+const WithdrawalTransaction = new MoveStruct({
+	name: `${$moduleName}::WithdrawalTransaction`,
+	fields: {
+		id: bcs.Address,
+		txid: bcs.Address,
+		request_ids: bcs.vector(bcs.Address),
+		inputs: bcs.vector(Utxo),
+		withdrawal_outputs: bcs.vector(OutputUtxo),
+		change_output: bcs.option(OutputUtxo),
+		timestamp_ms: bcs.u64(),
+		randomness: bcs.vector(bcs.u8()),
+		signatures: bcs.option(bcs.vector(bcs.vector(bcs.u8()))),
+		presig_start_index: bcs.u64(),
+		epoch: bcs.u64()
+	}
+});
+const CommittedRequestInfo = new MoveStruct({
+	name: `${$moduleName}::CommittedRequestInfo`,
+	fields: {
+		btc_amount: bcs.u64(),
+		bitcoin_address: bcs.vector(bcs.u8())
+	}
+});
+const WithdrawalRequestedEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalRequestedEvent`,
+	fields: {
+		request_id: bcs.Address,
+		btc_amount: bcs.u64(),
+		bitcoin_address: bcs.vector(bcs.u8()),
+		timestamp_ms: bcs.u64(),
+		requester_address: bcs.Address,
+		sui_tx_digest: bcs.vector(bcs.u8())
+	}
+});
+const WithdrawalApprovedEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalApprovedEvent`,
+	fields: { request_id: bcs.Address }
+});
+const WithdrawalPickedForProcessingEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalPickedForProcessingEvent`,
+	fields: {
+		withdrawal_txn_id: bcs.Address,
+		txid: bcs.Address,
+		request_ids: bcs.vector(bcs.Address),
+		inputs: bcs.vector(Utxo),
+		withdrawal_outputs: bcs.vector(OutputUtxo),
+		change_output: bcs.option(OutputUtxo),
+		timestamp_ms: bcs.u64(),
+		randomness: bcs.vector(bcs.u8())
+	}
+});
+const WithdrawalSignedEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalSignedEvent`,
+	fields: {
+		withdrawal_txn_id: bcs.Address,
+		request_ids: bcs.vector(bcs.Address),
+		signatures: bcs.vector(bcs.vector(bcs.u8()))
+	}
+});
+const WithdrawalConfirmedEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalConfirmedEvent`,
+	fields: {
+		withdrawal_txn_id: bcs.Address,
+		txid: bcs.Address,
+		change_utxo_id: bcs.option(UtxoId),
+		request_ids: bcs.vector(bcs.Address),
+		change_utxo_amount: bcs.option(bcs.u64())
+	}
+});
+const WithdrawalCancelledEvent = new MoveStruct({
+	name: `${$moduleName}::WithdrawalCancelledEvent`,
+	fields: {
+		request_id: bcs.Address,
+		requester_address: bcs.Address,
+		btc_amount: bcs.u64()
+	}
+});
+
+//#endregion
+export { OutputUtxo, WithdrawalRequest, WithdrawalRequestQueue, WithdrawalTransaction };

package/dist/contracts/utils/index.d.mts

@@ -0,0 +1,8 @@
+import { BcsEnum, BcsStruct } from "@mysten/sui/bcs";
+import { TransactionArgument } from "@mysten/sui/transactions";
+import { ClientWithCoreApi, SuiClientTypes } from "@mysten/sui/client";
+
+//#region src/contracts/utils/index.d.ts
+type RawTransactionArgument<T> = T | TransactionArgument;
+//#endregion
+export { RawTransactionArgument };

package/dist/contracts/utils/index.mjs

@@ -0,0 +1,118 @@
+import { BcsEnum, BcsStruct, TypeTagSerializer, bcs } from "@mysten/sui/bcs";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+import { isArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/utils/index.ts
+const MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
+const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
+function getPureBcsSchema(typeTag) {
+	const parsedTag = typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+	if ("u8" in parsedTag) return bcs.U8;
+	else if ("u16" in parsedTag) return bcs.U16;
+	else if ("u32" in parsedTag) return bcs.U32;
+	else if ("u64" in parsedTag) return bcs.U64;
+	else if ("u128" in parsedTag) return bcs.U128;
+	else if ("u256" in parsedTag) return bcs.U256;
+	else if ("address" in parsedTag) return bcs.Address;
+	else if ("bool" in parsedTag) return bcs.Bool;
+	else if ("vector" in parsedTag) {
+		const type = getPureBcsSchema(parsedTag.vector);
+		return type ? bcs.vector(type) : null;
+	} else if ("struct" in parsedTag) {
+		const structTag = parsedTag.struct;
+		const pkg = normalizeSuiAddress(structTag.address);
+		if (pkg === MOVE_STDLIB_ADDRESS) {
+			if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") return bcs.String;
+			if (structTag.module === "option" && structTag.name === "Option") {
+				const type = getPureBcsSchema(structTag.typeParams[0]);
+				return type ? bcs.option(type) : null;
+			}
+		}
+		if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === "object" && (structTag.name === "ID" || structTag.name === "UID")) return bcs.Address;
+	}
+	return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+	const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+	if (parameterNames && argLen !== parameterNames.length) throw new Error(`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`);
+	const normalizedArgs = [];
+	let index = 0;
+	for (const [i, argType] of argTypes.entries()) {
+		if (argType === "0x2::clock::Clock") {
+			normalizedArgs.push((tx) => tx.object.clock());
+			continue;
+		}
+		if (argType === "0x2::random::Random") {
+			normalizedArgs.push((tx) => tx.object.random());
+			continue;
+		}
+		if (argType === "0x2::deny_list::DenyList") {
+			normalizedArgs.push((tx) => tx.object.denyList());
+			continue;
+		}
+		if (argType === "0x3::sui_system::SuiSystemState") {
+			normalizedArgs.push((tx) => tx.object.system());
+			continue;
+		}
+		let arg;
+		if (Array.isArray(args)) {
+			if (index >= args.length) throw new Error(`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`);
+			arg = args[index];
+		} else {
+			if (!parameterNames) throw new Error(`Expected arguments to be passed as an array`);
+			const name = parameterNames[index];
+			arg = args[name];
+			if (arg === void 0) throw new Error(`Parameter ${name} is required`);
+		}
+		index += 1;
+		if (typeof arg === "function" || isArgument(arg)) {
+			normalizedArgs.push(arg);
+			continue;
+		}
+		const type = argTypes[i];
+		const bcsType = type === null ? null : getPureBcsSchema(type);
+		if (bcsType) {
+			const bytes = bcsType.serialize(arg);
+			normalizedArgs.push((tx) => tx.pure(bytes));
+			continue;
+		} else if (typeof arg === "string") {
+			normalizedArgs.push((tx) => tx.object(arg));
+			continue;
+		}
+		throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+	}
+	return normalizedArgs;
+}
+var MoveStruct = class extends BcsStruct {
+	async get({ objectId, ...options }) {
+		const [res] = await this.getMany({
+			...options,
+			objectIds: [objectId]
+		});
+		return res;
+	}
+	async getMany({ client, ...options }) {
+		return (await client.core.getObjects({
+			...options,
+			include: {
+				...options.include,
+				content: true
+			}
+		})).objects.map((obj) => {
+			if (obj instanceof Error) throw obj;
+			return {
+				...obj,
+				json: this.parse(obj.content)
+			};
+		});
+	}
+};
+var MoveEnum = class extends BcsEnum {};
+function stringify(val) {
+	if (typeof val === "object") return JSON.stringify(val, (val$1) => val$1);
+	if (typeof val === "bigint") return val.toString();
+	return val;
+}
+
+//#endregion
+export { MoveEnum, MoveStruct, normalizeMoveArguments };

package/dist/errors.d.mts

@@ -0,0 +1,118 @@
+//#region src/errors.d.ts
+/**
+ * Custom error classes thrown by the Hashi SDK. Consumers can `instanceof`-check
+ * these to distinguish SDK-structured failures (missing/malformed on-chain data,
+ * chain-fetch failures) from generic runtime errors.
+ */
+/**
+ * Thrown when a governance config entry on-chain is missing, has an unexpected
+ * variant, or has a payload that cannot be decoded to the expected type.
+ * Carries the offending `key` and `expectedVariant` as structured fields so
+ * callers can react programmatically without string-parsing the message.
+ */
+declare class HashiConfigError extends Error {
+  readonly key: string;
+  readonly expectedVariant: string;
+  readonly actualVariant?: string;
+  constructor(message: string, details: {
+    key: string;
+    expectedVariant: string;
+    actualVariant?: string;
+  }, options?: {
+    cause?: unknown;
+  });
+  static missing(key: string, expectedVariant: string): HashiConfigError;
+  static wrongVariant(key: string, expectedVariant: string, actualVariant: string): HashiConfigError;
+  static malformedPayload(key: string, expectedVariant: string, detail: string, cause?: unknown): HashiConfigError;
+}
+/**
+ * Thrown when fetching the Hashi shared object fails or returns an
+ * unexpectedly shaped response. Wraps the underlying Sui-client error via
+ * `cause` so callers can still access the network-layer detail.
+ */
+declare class HashiFetchError extends Error {
+  readonly hashiObjectId: string;
+  constructor(message: string, hashiObjectId: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * One amount that failed a client-side minimum check. `vout` is present for
+ * deposit-UTXO violations (so callers can map each offender back to a Bitcoin
+ * output) and absent for withdrawal violations, where there is a single
+ * top-level amount and no output index.
+ */
+interface AmountViolation {
+  readonly amount: bigint;
+  readonly minimum: bigint;
+  readonly vout?: number;
+}
+/**
+ * Thrown by `HashiClient.deposit()` and `HashiClient.requestWithdrawal()` when
+ * one or more amounts are below the live on-chain minimum. Deposits may carry
+ * multiple violations (one per offending UTXO) so callers can fix the whole
+ * batch in one round-trip; withdrawals always carry exactly one. Raised after
+ * the governance snapshot is fetched but before any PTB is built — mirrors
+ * the Move-side `EBelowMinimumDeposit` / `EBelowMinimumWithdrawal` aborts.
+ */
+declare class AmountBelowMinimumError extends Error {
+  readonly violations: readonly AmountViolation[];
+  constructor(details: {
+    violations: readonly AmountViolation[];
+  });
+}
+/**
+ * Thrown by user-facing entry points when `paused` is `true` in the governance
+ * config snapshot. Mirrors the Move-side `ESystemPaused` abort in
+ * `hashi::assert_unpaused` so the SDK can fail early with a typed error
+ * instead of a gas-burning on-chain abort.
+ */
+declare class HashiPausedError extends Error {
+  readonly operation?: string;
+  constructor(details?: {
+    operation?: string;
+  }, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Thrown by `HashiClient` direct methods when the caller-supplied params
+ * don't meet structural preconditions (empty `utxos`, duplicate `vout`,
+ * malformed hex). Raised before any chain read so even a paused or
+ * unreachable protocol surfaces the client-side bug first.
+ */
+declare class InvalidParamsError extends Error {
+  readonly reason: string;
+  readonly detail?: string;
+  constructor(details: {
+    reason: string;
+    detail?: string;
+  }, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * Stable discriminator for `InvalidBitcoinAddressError`. Callers can switch on
+ * `code` to surface targeted UX (e.g. "wrong network" → prompt the user to
+ * switch, "bad-checksum" → flag a typo) without string-parsing the message.
+ */
+type InvalidBitcoinAddressCode = "malformed" | "bad-checksum" | "wrong-network" | "unsupported-version" | "bad-program-length";
+/**
+ * Thrown when a user-supplied Bitcoin address cannot be decoded into a
+ * witness program that the Hashi withdrawal path accepts. `code` is a stable
+ * discriminator suitable for programmatic handling; `address` echoes the
+ * offending input back so callers can display it.
+ */
+declare class InvalidBitcoinAddressError extends Error {
+  readonly address: string;
+  readonly code: InvalidBitcoinAddressCode;
+  constructor(details: {
+    address: string;
+    code: InvalidBitcoinAddressCode;
+    message: string;
+  }, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { AmountBelowMinimumError, AmountViolation, HashiConfigError, HashiFetchError, HashiPausedError, InvalidBitcoinAddressCode, InvalidBitcoinAddressError, InvalidParamsError };

package/dist/errors.mjs

@@ -0,0 +1,118 @@
+//#region src/errors.ts
+/**
+* Custom error classes thrown by the Hashi SDK. Consumers can `instanceof`-check
+* these to distinguish SDK-structured failures (missing/malformed on-chain data,
+* chain-fetch failures) from generic runtime errors.
+*/
+/**
+* Thrown when a governance config entry on-chain is missing, has an unexpected
+* variant, or has a payload that cannot be decoded to the expected type.
+* Carries the offending `key` and `expectedVariant` as structured fields so
+* callers can react programmatically without string-parsing the message.
+*/
+var HashiConfigError = class HashiConfigError extends Error {
+	constructor(message, details, options) {
+		super(message, options);
+		this.name = "HashiConfigError";
+		this.key = details.key;
+		this.expectedVariant = details.expectedVariant;
+		this.actualVariant = details.actualVariant;
+	}
+	static missing(key, expectedVariant) {
+		return new HashiConfigError(`Config key "${key}" not found on-chain.`, {
+			key,
+			expectedVariant
+		});
+	}
+	static wrongVariant(key, expectedVariant, actualVariant) {
+		return new HashiConfigError(`Config key "${key}" is ${actualVariant}, expected ${expectedVariant}.`, {
+			key,
+			expectedVariant,
+			actualVariant
+		});
+	}
+	static malformedPayload(key, expectedVariant, detail, cause) {
+		return new HashiConfigError(`Config key "${key}" ${expectedVariant} payload is malformed: ${detail}.`, {
+			key,
+			expectedVariant,
+			actualVariant: expectedVariant
+		}, { cause });
+	}
+};
+/**
+* Thrown when fetching the Hashi shared object fails or returns an
+* unexpectedly shaped response. Wraps the underlying Sui-client error via
+* `cause` so callers can still access the network-layer detail.
+*/
+var HashiFetchError = class extends Error {
+	constructor(message, hashiObjectId, options) {
+		super(message, options);
+		this.name = "HashiFetchError";
+		this.hashiObjectId = hashiObjectId;
+	}
+};
+/**
+* Thrown by `HashiClient.deposit()` and `HashiClient.requestWithdrawal()` when
+* one or more amounts are below the live on-chain minimum. Deposits may carry
+* multiple violations (one per offending UTXO) so callers can fix the whole
+* batch in one round-trip; withdrawals always carry exactly one. Raised after
+* the governance snapshot is fetched but before any PTB is built — mirrors
+* the Move-side `EBelowMinimumDeposit` / `EBelowMinimumWithdrawal` aborts.
+*/
+var AmountBelowMinimumError = class extends Error {
+	constructor(details) {
+		const { violations } = details;
+		const head = violations[0];
+		let summary;
+		if (violations.length === 1) summary = head.vout === void 0 ? `Amount ${head.amount} sats is below the protocol minimum of ${head.minimum} sats.` : `UTXO at vout ${head.vout} has amount ${head.amount} sats, below the protocol minimum of ${head.minimum} sats.`;
+		else summary = `${violations.length} UTXOs are below the protocol minimum (${head.minimum} sats): ${violations.map((v) => v.vout === void 0 ? `${v.amount} sats` : `vout ${v.vout} = ${v.amount} sats`).join(", ")}.`;
+		super(summary);
+		this.name = "AmountBelowMinimumError";
+		this.violations = violations;
+	}
+};
+/**
+* Thrown by user-facing entry points when `paused` is `true` in the governance
+* config snapshot. Mirrors the Move-side `ESystemPaused` abort in
+* `hashi::assert_unpaused` so the SDK can fail early with a typed error
+* instead of a gas-burning on-chain abort.
+*/
+var HashiPausedError = class extends Error {
+	constructor(details, options) {
+		const op = details?.operation;
+		super(op ? `Hashi protocol is currently paused; cannot ${op}.` : "Hashi protocol is currently paused.", options);
+		this.name = "HashiPausedError";
+		this.operation = op;
+	}
+};
+/**
+* Thrown by `HashiClient` direct methods when the caller-supplied params
+* don't meet structural preconditions (empty `utxos`, duplicate `vout`,
+* malformed hex). Raised before any chain read so even a paused or
+* unreachable protocol surfaces the client-side bug first.
+*/
+var InvalidParamsError = class extends Error {
+	constructor(details, options) {
+		super(details.detail ? `${details.reason}: ${details.detail}` : details.reason, options);
+		this.name = "InvalidParamsError";
+		this.reason = details.reason;
+		this.detail = details.detail;
+	}
+};
+/**
+* Thrown when a user-supplied Bitcoin address cannot be decoded into a
+* witness program that the Hashi withdrawal path accepts. `code` is a stable
+* discriminator suitable for programmatic handling; `address` echoes the
+* offending input back so callers can display it.
+*/
+var InvalidBitcoinAddressError = class extends Error {
+	constructor(details, options) {
+		super(details.message, options);
+		this.name = "InvalidBitcoinAddressError";
+		this.address = details.address;
+		this.code = details.code;
+	}
+};
+
+//#endregion
+export { AmountBelowMinimumError, HashiConfigError, HashiFetchError, HashiPausedError, InvalidBitcoinAddressError, InvalidParamsError };

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { BitcoinNetwork, CancelWithdrawalParams, DepositHistoryItem, DepositParams, GovernanceConfig, HashiClientOptions, NetworkConfig, SuiNetwork, TransactionHistoryItem, UtxoId, UtxoOutput, UtxoUsageResult, WithdrawalHistoryItem, WithdrawalParams, WithdrawalStatus } from "./types.mjs";
+import { HashiClient, hashi } from "./client.mjs";
+import { AmountBelowMinimumError, AmountViolation, HashiConfigError, HashiFetchError, HashiPausedError, InvalidBitcoinAddressCode, InvalidBitcoinAddressError, InvalidParamsError } from "./errors.mjs";
+import { arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, taprootScriptPathAddress } from "./bitcoin.mjs";
+export { AmountBelowMinimumError, type AmountViolation, type BitcoinNetwork, type CancelWithdrawalParams, type DepositHistoryItem, type DepositParams, type GovernanceConfig, HashiClient, type HashiClientOptions, HashiConfigError, HashiFetchError, HashiPausedError, type InvalidBitcoinAddressCode, InvalidBitcoinAddressError, InvalidParamsError, type NetworkConfig, type SuiNetwork, type TransactionHistoryItem, type UtxoId, type UtxoOutput, type UtxoUsageResult, type WithdrawalHistoryItem, type WithdrawalParams, type WithdrawalStatus, arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, hashi, taprootScriptPathAddress };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { AmountBelowMinimumError, HashiConfigError, HashiFetchError, HashiPausedError, InvalidBitcoinAddressError, InvalidParamsError } from "./errors.mjs";
+import { arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, taprootScriptPathAddress } from "./bitcoin.mjs";
+import { HashiClient, hashi } from "./client.mjs";
+
+export { AmountBelowMinimumError, HashiClient, HashiConfigError, HashiFetchError, HashiPausedError, InvalidBitcoinAddressError, InvalidParamsError, arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, hashi, taprootScriptPathAddress };

package/dist/types.d.mts

@@ -0,0 +1,137 @@
+//#region src/types.d.ts
+type BitcoinNetwork = "mainnet" | "testnet" | "signet" | "regtest";
+type SuiNetwork = "devnet" | "testnet" | "mainnet" | "localnet";
+interface NetworkConfig {
+  hashiObjectId: string;
+  packageId: string;
+  bitcoinNetwork: BitcoinNetwork;
+}
+interface HashiClientOptions<Name = "HashiClient"> {
+  name?: Name;
+  /** Sui network — determines Hashi object IDs and default Bitcoin network. */
+  network: SuiNetwork;
+  /** Override the auto-resolved Hashi shared object ID (for custom/local deployments). */
+  hashiObjectId?: string;
+  /** Override the auto-resolved Hashi package ID (for custom/local deployments). */
+  packageId?: string;
+  /** Override the auto-resolved Bitcoin network for address encoding. */
+  bitcoinNetwork?: BitcoinNetwork;
+}
+/**
+ * Frozen snapshot of every governance-controlled protocol parameter, returned
+ * by `HashiClient.view.all()`. Fields are `readonly` because the snapshot is
+ * a point-in-time read from chain — mutating it locally cannot change on-chain
+ * state. `depositMinimum` is a Move-side alias of `bitcoinDepositMinimum`;
+ * `worstCaseNetworkFee` is derived as `bitcoinWithdrawalMinimum - 546` (the
+ * dust relay floor) and is always ≥ 1.
+ */
+interface GovernanceConfig {
+  readonly paused: boolean;
+  readonly bitcoinChainId: string;
+  readonly bitcoinDepositMinimum: bigint;
+  readonly bitcoinWithdrawalMinimum: bigint;
+  readonly bitcoinConfirmationThreshold: bigint;
+  readonly withdrawalCancellationCooldownMs: bigint;
+  readonly depositMinimum: bigint;
+  readonly worstCaseNetworkFee: bigint;
+}
+/**
+ * A single UTXO output within a Bitcoin transaction used to fund a deposit.
+ * `vout` is the output index (Bitcoin u32); `amountSats` must be ≥ the
+ * on-chain deposit minimum (enforced at deposit time).
+ */
+interface UtxoOutput {
+  readonly vout: number;
+  readonly amountSats: bigint;
+}
+/** Parameters for `HashiClient.deposit()` — one Bitcoin txid, one or more outputs paying the deposit address. */
+interface DepositParams {
+  /**
+   * 0x-prefixed 32-byte Bitcoin txid of the funding transaction, in
+   * **display byte order** — the form mempool.space, blockstream.info,
+   * and `bitcoin-cli` show. The SDK reverses to internal byte order
+   * before recording on-chain (see `reverseTxidBytes` in `util.ts`).
+   */
+  readonly txid: string;
+  /** UTXOs from `txid` that paid the deposit address (one per output to the address). */
+  readonly utxos: readonly UtxoOutput[];
+  /**
+   * Sui address that derived the deposit address and will receive the minted
+   * hBTC. Becomes the `derivation_path` of every `Utxo` built in the PTB.
+   */
+  readonly recipient: string;
+}
+/** Parameters for `HashiClient.requestWithdrawal()`. */
+interface WithdrawalParams {
+  /** Amount in satoshis to withdraw. Must be ≥ the on-chain withdrawal minimum. */
+  readonly amountSats: bigint;
+  /**
+   * Recipient Bitcoin address. Bech32 for P2WPKH (`bc1q…`, `tb1q…`) or
+   * bech32m for P2TR (`bc1p…`, `tb1p…`). Decoded client-side into a witness
+   * program and must match the client's configured Bitcoin network.
+   */
+  readonly bitcoinAddress: string;
+}
+/** Parameters for `HashiClient.cancelWithdrawal()`. */
+interface CancelWithdrawalParams {
+  /** 0x-prefixed 32-byte object ID of the pending withdrawal request. */
+  readonly requestId: string;
+}
+/**
+ * Identifies a single Bitcoin UTXO by its funding transaction and output
+ * index. `txid` is in **display byte order** — the form mempool.space,
+ * blockstream.info, and `bitcoin-cli` show.
+ */
+interface UtxoId {
+  /** 0x-prefixed 32-byte Bitcoin txid in display byte order. */
+  readonly txid: string;
+  /** Output index within the Bitcoin transaction (u32). */
+  readonly vout: number;
+}
+/**
+ * Result of checking a single UTXO against the on-chain `UtxoPool` bags.
+ * `inActivePool` means the UTXO is live (confirmed deposit, not yet
+ * consumed by a withdrawal); `inSpentPool` means it was consumed.
+ */
+interface UtxoUsageResult {
+  readonly utxoId: UtxoId;
+  readonly inActivePool: boolean;
+  readonly inSpentPool: boolean;
+  /** Convenience: `inActivePool || inSpentPool`. */
+  readonly isUsed: boolean;
+}
+/** Discriminated union of deposit and withdrawal history entries. */
+type TransactionHistoryItem = DepositHistoryItem | WithdrawalHistoryItem;
+interface DepositHistoryItem {
+  readonly kind: "deposit";
+  readonly requestId: string;
+  readonly sender: string;
+  readonly timestampMs: bigint;
+  readonly suiTxDigest: string;
+  readonly amountSats: bigint;
+  /** Bitcoin txid of the funding transaction, in display byte order. */
+  readonly btcTxid: string;
+  /** Output index within the funding transaction. */
+  readonly btcVout: number;
+  /** `true` once the committee has approved the deposit. */
+  readonly approved: boolean;
+  readonly approvalTimestampMs: bigint | null;
+}
+type WithdrawalStatus = "Requested" | "Approved" | "Processing" | "Signed" | "Confirmed";
+interface WithdrawalHistoryItem {
+  readonly kind: "withdrawal";
+  readonly requestId: string;
+  readonly sender: string;
+  readonly btcAmountSats: bigint;
+  /** Raw witness program bytes of the destination Bitcoin address. */
+  readonly bitcoinAddress: Uint8Array;
+  readonly timestampMs: bigint;
+  readonly suiTxDigest: string;
+  readonly status: WithdrawalStatus;
+  /** Object ID of the linked `WithdrawalTransaction`, if one exists. */
+  readonly withdrawalTxnId: string | null;
+  /** Bitcoin txid from the `WithdrawalTransaction`, in display byte order. `null` until the committee commits. */
+  readonly btcTxid: string | null;
+}
+//#endregion
+export { BitcoinNetwork, CancelWithdrawalParams, DepositHistoryItem, DepositParams, GovernanceConfig, HashiClientOptions, NetworkConfig, SuiNetwork, TransactionHistoryItem, UtxoId, UtxoOutput, UtxoUsageResult, WithdrawalHistoryItem, WithdrawalParams, WithdrawalStatus };