@mysten-incubation/hashi 0.0.1 → 0.1.0

package/dist/client.mjs

@@ -9,16 +9,54 @@ import { cancelWithdrawal, requestWithdrawal } from "./contracts/hashi/withdraw.
 import { DUST_RELAY_MIN_VALUE, NETWORK_CONFIG } from "./constants.mjs";
 import { AmountBelowMinimumError, HashiConfigError, HashiFetchError, HashiPausedError, InvalidParamsError } from "./errors.mjs";
 import { arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, generateDepositAddress } from "./bitcoin.mjs";
+import { getTxConfirmations, lookupAllVouts, lookupVout } from "./btc-rpc.mjs";
 import { assertHex32, entry, reverseTxidBytes } from "./util.mjs";
 import { TypeTagSerializer, bcs } from "@mysten/sui/bcs";
-import { deriveDynamicFieldID, fromHex, toHex } from "@mysten/sui/utils";
+import { deriveDynamicFieldID, fromHex } from "@mysten/sui/utils";
+import { base58 } from "@scure/base";
 import { Transaction, coinWithBalance } from "@mysten/sui/transactions";
 
 //#region src/client.ts
+/** ObjectBag dynamic field name type (Wrapper<address> for dynamic_object_field lookups). */
+const OBJECT_BAG_ADDRESS_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field::Wrapper<address>";
 /** Max value of an unsigned 32-bit integer; vout is a u32 on the Bitcoin side. */
 const U32_MAX = 4294967295;
-/** Max objects per `getObjects` call — Sui transports typically cap at 50. */
-const GET_OBJECTS_BATCH = 50;
+/** Max objects per `getObjects` call. */
+const GET_OBJECTS_BATCH = 500;
+const GRAPHQL_URLS = {
+	devnet: "https://fullnode.devnet.sui.io:443/graphql",
+	testnet: "https://fullnode.testnet.sui.io:443/graphql",
+	mainnet: "https://fullnode.mainnet.sui.io:443/graphql",
+	localnet: "http://127.0.0.1:9000/graphql"
+};
+function defaultGraphqlUrl(network) {
+	return GRAPHQL_URLS[network] ?? GRAPHQL_URLS["mainnet"];
+}
+/**
+* Recognize the per-object errors that mean "the object (or dynamic field)
+* genuinely does not exist" — the only Error shape that `findUsedUtxos` is
+* allowed to treat as a pool miss. Anything else (deleted, displayError,
+* unknown) must propagate so other per-object failures can't be silently
+* downgraded to "not used."
+*
+* Two transports, two shapes:
+* - JSON-RPC returns a typed `ObjectError` whose `.code` is `notExists` or
+*   `dynamicFieldNotFound`. `ObjectError` is not re-exported from
+*   `@mysten/sui/client`, so the guard duck-types the field.
+* - gRPC stringifies the per-object error into `new Error(message)` with no
+*   code (see the `TODO: improve error handling` in `@mysten/sui/grpc/core.ts`).
+*   For now the only signal is the message, which the Sui ledger service
+*   returns as exactly `Object <id> not found` for missing objects.
+*
+* Transport-level failures don't show up here — they reject the whole
+* `getObjects` promise rather than appearing in the result array.
+*/
+const GRPC_NOT_FOUND_MESSAGE_RE = /^Object 0x[0-9a-f]+ not found$/i;
+function isObjectNotFoundError(err) {
+	const code = err.code;
+	if (code === "notExists" || code === "dynamicFieldNotFound") return true;
+	return code === void 0 && GRPC_NOT_FOUND_MESSAGE_RE.test(err.message);
+}
 function hashi({ name = "hashi", ...options }) {
 	return {
 		name,
@@ -50,11 +88,13 @@ var HashiClient = class {
 	#hashiObjectId;
 	#packageId;
 	#bitcoinNetwork;
-	constructor({ client, network, hashiObjectId, packageId, bitcoinNetwork }) {
+	#btcRpcUrl;
+	#graphqlUrl;
+	constructor({ client, network, hashiObjectId, packageId, bitcoinNetwork, btcRpcUrl, graphqlUrl }) {
 		this.tx = {
 			deposit: (params) => {
 				const tx = new Transaction();
-				const internalTxid = reverseTxidBytes(params.txid);
+				const internalTxid = `0x${reverseTxidBytes(params.txid)}`;
 				for (const { vout, amountSats } of params.utxos) {
 					const utxoId$1 = tx.add(utxoId({
 						package: this.#packageId,
@@ -175,12 +215,14 @@ var HashiClient = class {
 				const fieldIds = [];
 				for (const u of utxos) {
 					const keyBcs = UtxoId.serialize({
-						txid: reverseTxidBytes(u.txid),
+						txid: `0x${reverseTxidBytes(u.txid)}`,
 						vout: u.vout
 					}).toBytes();
 					fieldIds.push(deriveDynamicFieldID(activePoolId, typeTag, keyBcs), deriveDynamicFieldID(spentPoolId, typeTag, keyBcs));
 				}
 				const objects = await this.#batchGetObjects(fieldIds);
+				if (objects.length !== fieldIds.length) throw new HashiFetchError(`findUsedUtxos: getObjects returned ${objects.length} results, expected ${fieldIds.length}`, this.#hashiObjectId);
+				for (const result of objects) if (result instanceof Error && !isObjectNotFoundError(result)) throw result;
 				return utxos.map((u, i) => {
 					const inActivePool = !(objects[i * 2] instanceof Error);
 					const inSpentPool = !(objects[i * 2 + 1] instanceof Error);
@@ -192,86 +234,206 @@ var HashiClient = class {
 					};
 				});
 			},
-			transactionHistory: async (suiAddress) => {
-				const tableId = (await this.#fetchBitcoinState()).user_requests.id;
-				let userBagId;
+			balance: async (owner) => {
+				const btcType = `${this.#packageId}::btc::BTC`;
+				const { balance } = await this.#client.core.getBalance({
+					owner,
+					coinType: btcType
+				});
+				let coinObjectCount = 0;
+				let cursor = null;
+				let hasNextPage = true;
+				while (hasNextPage) {
+					const page = await this.#client.core.listCoins({
+						owner,
+						coinType: btcType,
+						cursor: cursor ?? void 0
+					});
+					coinObjectCount += page.objects.length;
+					cursor = page.cursor;
+					hasNextPage = page.hasNextPage;
+				}
+				return {
+					totalBalance: BigInt(balance.balance ?? "0"),
+					coinObjectCount
+				};
+			},
+			depositStatus: async (suiTxDigest) => {
+				const txResult = await this.#client.core.getTransaction({
+					digest: suiTxDigest,
+					include: { events: true }
+				});
+				const txData = txResult.Transaction ?? txResult.FailedTransaction;
+				if (!txData?.events) return null;
+				const depositEvent = txData.events.find((e) => e.eventType.includes("::deposit::DepositRequestedEvent"));
+				if (!depositEvent?.json) return null;
+				const parsed = depositEvent.json;
+				let status = "unknown";
 				try {
-					const { dynamicField } = await this.#client.core.getDynamicField({
-						parentId: tableId,
+					await DepositRequest.get({
+						client: this.#client,
+						objectId: parsed.request_id
+					});
+					const requestsBagId = (await this.#fetchBitcoinState()).deposit_queue.requests.id;
+					status = (await this.#client.core.getDynamicField({
+						parentId: requestsBagId,
 						name: {
-							type: "address",
-							bcs: bcs.Address.serialize(suiAddress).toBytes()
+							type: OBJECT_BAG_ADDRESS_TYPE,
+							bcs: bcs.Address.serialize(parsed.request_id).toBytes()
 						}
+					}).catch(() => null))?.dynamicField ? "pending" : "confirmed";
+				} catch (err) {
+					if (err instanceof Error && isObjectNotFoundError(err)) status = "expired";
+					else throw err;
+				}
+				return {
+					requestId: parsed.request_id,
+					amountSats: BigInt(parsed.amount),
+					recipient: parsed.derivation_path,
+					btcTxid: reverseTxidBytes(parsed.utxo_id.txid),
+					btcVout: parsed.utxo_id.vout,
+					timestampMs: BigInt(parsed.timestamp_ms),
+					status,
+					suiTxDigest
+				};
+			},
+			withdrawalStatus: async (suiTxDigest) => {
+				const txResult = await this.#client.core.getTransaction({
+					digest: suiTxDigest,
+					include: { events: true }
+				});
+				const txData = txResult.Transaction ?? txResult.FailedTransaction;
+				if (!txData?.events) return null;
+				const withdrawEvent = txData.events.find((e) => e.eventType.includes("::withdrawal_queue::WithdrawalRequestedEvent"));
+				if (!withdrawEvent?.json) return null;
+				const parsed = withdrawEvent.json;
+				let status = "Requested";
+				let btcTxid = null;
+				try {
+					const reqObj = await WithdrawalRequest.get({
+						client: this.#client,
+						objectId: parsed.request_id
 					});
-					userBagId = Bag.parse(new Uint8Array(dynamicField.value.bcs)).id;
-				} catch {
-					return [];
+					status = reqObj.json.status.$kind;
+					const withdrawalTxnId = reqObj.json.withdrawal_txn_id;
+					if (withdrawalTxnId && (status === "Processing" || status === "Signed" || status === "Confirmed")) try {
+						btcTxid = reverseTxidBytes((await WithdrawalTransaction.get({
+							client: this.#client,
+							objectId: withdrawalTxnId
+						})).json.txid);
+					} catch {}
+				} catch (err) {
+					if (err instanceof Error && isObjectNotFoundError(err)) status = "cancelled";
+					else throw err;
 				}
-				const requestIds = [];
-				let cursor = null;
-				do {
-					const page = await this.#client.core.listDynamicFields({
-						parentId: userBagId,
-						cursor: cursor ?? void 0
+				return {
+					requestId: parsed.request_id,
+					btcAmountSats: BigInt(parsed.btc_amount),
+					bitcoinAddress: new Uint8Array(parsed.bitcoin_address),
+					sender: parsed.requester_address,
+					timestampMs: BigInt(parsed.timestamp_ms),
+					status,
+					suiTxDigest,
+					btcTxid
+				};
+			},
+			depositGasEstimate: async (sender) => {
+				const dummyAmount = (await this.view.all()).bitcoinDepositMinimum + 1n;
+				const dummyTxid = "0x" + "01".repeat(32);
+				const tx = new Transaction();
+				const utxoId$1 = tx.add(utxoId({
+					package: this.#packageId,
+					arguments: {
+						txid: dummyTxid,
+						vout: 0
+					}
+				}));
+				const utxo$1 = tx.add(utxo({
+					package: this.#packageId,
+					arguments: {
+						utxoId: utxoId$1,
+						amount: dummyAmount,
+						derivationPath: sender
+					}
+				}));
+				tx.add(this.call.deposit({ utxo: utxo$1 }));
+				tx.setSender(sender);
+				return { gasEstimateMist: await this.#estimateGas(tx) };
+			},
+			withdrawalFees: async (sender) => {
+				const snap = await this.view.all();
+				let gasEstimateMist = 0n;
+				if (sender) {
+					const dummyAmount = snap.bitcoinWithdrawalMinimum + 1n;
+					const btcType = `${this.#packageId}::btc::BTC`;
+					const tx = new Transaction();
+					const coin = tx.add(coinWithBalance({
+						type: btcType,
+						balance: dummyAmount,
+						useGasCoin: false
+					}));
+					const [balance] = tx.moveCall({
+						package: "0x2",
+						module: "coin",
+						function: "into_balance",
+						typeArguments: [btcType],
+						arguments: [coin]
 					});
-					for (const df of page.dynamicFields) requestIds.push(bcs.Address.parse(new Uint8Array(df.name.bcs)));
-					cursor = page.hasNextPage ? page.cursor : null;
-				} while (cursor);
-				if (requestIds.length === 0) return [];
-				const objects = await this.#batchGetObjects(requestIds, { content: true });
+					tx.add(this.call.requestWithdrawal({
+						btc: balance,
+						bitcoinAddress: Array(20).fill(0)
+					}));
+					tx.setSender(sender);
+					gasEstimateMist = await this.#estimateGas(tx);
+				}
+				return {
+					worstCaseNetworkFeeSats: snap.worstCaseNetworkFee,
+					withdrawalMinimumSats: snap.bitcoinWithdrawalMinimum,
+					gasEstimateMist
+				};
+			},
+			transactionHistory: async (suiAddress) => {
+				const btcState = await this.#fetchBitcoinState();
+				const confirmedIds = /* @__PURE__ */ new Set();
 				const items = [];
-				const withdrawalTxnLookups = [];
-				for (const obj of objects) {
-					if (obj instanceof Error) continue;
-					if (obj.type.includes("::deposit_queue::DepositRequest")) {
-						const parsed = DepositRequest.parse(obj.content);
-						items.push({
-							kind: "deposit",
-							requestId: parsed.id,
-							sender: parsed.sender,
-							timestampMs: BigInt(parsed.timestamp_ms),
-							suiTxDigest: `0x${toHex(new Uint8Array(parsed.sui_tx_digest))}`,
-							amountSats: BigInt(parsed.utxo.amount),
-							btcTxid: reverseTxidBytes(parsed.utxo.id.txid),
-							btcVout: parsed.utxo.id.vout,
-							approved: parsed.approval_cert !== null,
-							approvalTimestampMs: parsed.approval_timestamp_ms !== null ? BigInt(parsed.approval_timestamp_ms) : null
-						});
-					} else if (obj.type.includes("::withdrawal_queue::WithdrawalRequest")) {
-						const parsed = WithdrawalRequest.parse(obj.content);
-						const txnId = parsed.withdrawal_txn_id ?? null;
-						items.push({
-							kind: "withdrawal",
-							requestId: parsed.id,
-							sender: parsed.sender,
-							btcAmountSats: BigInt(parsed.btc_amount),
-							bitcoinAddress: new Uint8Array(parsed.bitcoin_address),
-							timestampMs: BigInt(parsed.timestamp_ms),
-							suiTxDigest: `0x${toHex(new Uint8Array(parsed.sui_tx_digest))}`,
-							status: parsed.status.$kind,
-							withdrawalTxnId: txnId,
-							btcTxid: null
-						});
-						if (txnId) withdrawalTxnLookups.push({
-							itemIndex: items.length - 1,
-							txnId
-						});
+				const userBagId = await this.#fetchUserRequestsBagId(btcState.user_requests.id, suiAddress);
+				if (userBagId !== null) {
+					const requestIds = await this.#listAllDynamicFieldAddressKeys(userBagId);
+					if (requestIds.length > 0) {
+						const objects = await this.#batchGetObjects(requestIds, { content: true });
+						const classified = this.#classifyRequestObjects(objects);
+						items.push(...classified.items);
+						await this.#populateWithdrawalBtcTxids(items, classified.withdrawalTxnLookups);
+						for (const id of requestIds) confirmedIds.add(id);
 					}
 				}
-				if (withdrawalTxnLookups.length > 0) {
-					const txnIds = withdrawalTxnLookups.map((l) => l.txnId);
-					const txnObjects = await this.#batchGetObjects(txnIds, { content: true });
-					for (let i = 0; i < withdrawalTxnLookups.length; i++) {
-						const txnObj = txnObjects[i];
-						if (txnObj instanceof Error) continue;
-						const parsed = WithdrawalTransaction.parse(txnObj.content);
-						const item = items[withdrawalTxnLookups[i].itemIndex];
-						item.btcTxid = reverseTxidBytes(parsed.txid);
+				try {
+					const depositEventType = `${this.#packageId}::deposit::DepositRequestedEvent`;
+					const pendingIds = (await this.#queryEventRequestIds(suiAddress, depositEventType)).filter((id) => !confirmedIds.has(id));
+					if (pendingIds.length > 0) {
+						const objects = await this.#batchGetObjects(pendingIds, { content: true });
+						const classified = this.#classifyRequestObjects(objects);
+						items.push(...classified.items);
 					}
-				}
+				} catch {}
+				items.sort((a, b) => Number(b.timestampMs - a.timestampMs));
 				return items;
 			}
 		};
+		this.bitcoin = {
+			lookupVout: async (txid, depositAddress) => {
+				this.#requireBtcRpc();
+				return lookupVout(this.#btcRpcUrl, txid, depositAddress);
+			},
+			lookupAllVouts: async (txid, depositAddress) => {
+				this.#requireBtcRpc();
+				return lookupAllVouts(this.#btcRpcUrl, txid, depositAddress);
+			},
+			confirmations: async (txid) => {
+				this.#requireBtcRpc();
+				return getTxConfirmations(this.#btcRpcUrl, txid);
+			}
+		};
 		const config = NETWORK_CONFIG[network];
 		const resolvedObjectId = hashiObjectId ?? config?.hashiObjectId;
 		const resolvedPackageId = packageId ?? config?.packageId;
@@ -280,6 +442,8 @@ var HashiClient = class {
 		this.#hashiObjectId = resolvedObjectId;
 		this.#packageId = resolvedPackageId;
 		this.#bitcoinNetwork = bitcoinNetwork ?? config?.bitcoinNetwork ?? "testnet";
+		this.#btcRpcUrl = btcRpcUrl;
+		this.#graphqlUrl = graphqlUrl ?? defaultGraphqlUrl(network);
 	}
 	/**
 	* Generates a unique Bitcoin P2TR deposit address for a Sui address.
@@ -478,6 +642,52 @@ var HashiClient = class {
 		};
 	}
 	/**
+	* Poll deposit status until it reaches a terminal state (confirmed or expired).
+	*/
+	async waitForDeposit(suiTxDigest, options) {
+		const intervalMs = options?.intervalMs ?? 15e3;
+		const signal = options?.signal;
+		while (!signal?.aborted) {
+			const info = await this.view.depositStatus(suiTxDigest);
+			if (!info) throw new Error(`Deposit not found for digest: ${suiTxDigest}`);
+			if (info.status === "confirmed" || info.status === "expired") return info;
+			await sleep(intervalMs, signal);
+		}
+		throw new Error("Polling aborted");
+	}
+	/**
+	* Poll withdrawal status until it reaches a terminal state (confirmed or cancelled).
+	*/
+	async waitForWithdrawal(suiTxDigest, options) {
+		const intervalMs = options?.intervalMs ?? 15e3;
+		const signal = options?.signal;
+		while (!signal?.aborted) {
+			const info = await this.view.withdrawalStatus(suiTxDigest);
+			if (!info) throw new Error(`Withdrawal not found for digest: ${suiTxDigest}`);
+			if (info.status === "Confirmed" || info.status === "cancelled") return info;
+			await sleep(intervalMs, signal);
+		}
+		throw new Error("Polling aborted");
+	}
+	#requireBtcRpc() {
+		if (!this.#btcRpcUrl) throw new Error("btcRpcUrl is required for Bitcoin RPC operations. Pass it in HashiClientOptions.");
+	}
+	async #estimateGas(tx) {
+		try {
+			const result = await this.#client.core.simulateTransaction({
+				transaction: tx,
+				include: { effects: true }
+			});
+			const simTx = result.Transaction ?? result.FailedTransaction;
+			if (simTx?.effects?.gasUsed) {
+				const gas = simTx.effects.gasUsed;
+				const total = BigInt(gas.computationCost) + BigInt(gas.storageCost) - BigInt(gas.storageRebate);
+				return total > 0n ? total * 120n / 100n : 0n;
+			}
+		} catch {}
+		return 0n;
+	}
+	/**
 	* Fetches the `BitcoinState` dynamic field from the Hashi shared object.
 	* Returns the BCS-parsed struct whose nested Bag/Table IDs are used by
 	* `findUsedUtxos` and `transactionHistory`.
@@ -500,6 +710,41 @@ var HashiClient = class {
 		return BitcoinState.parse(new Uint8Array(dynamicField.value.bcs));
 	}
 	/**
+	* Resolve the Bag id holding a user's request IDs from `user_requests`,
+	* or `null` if the user has never had a request.
+	*/
+	async #fetchUserRequestsBagId(tableId, suiAddress) {
+		try {
+			const { dynamicField } = await this.#client.core.getDynamicField({
+				parentId: tableId,
+				name: {
+					type: "address",
+					bcs: bcs.Address.serialize(suiAddress).toBytes()
+				}
+			});
+			return Bag.parse(new Uint8Array(dynamicField.value.bcs)).id;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Enumerate every `address`-keyed dynamic field on `parentId`, paginating
+	* through `listDynamicFields` until exhausted.
+	*/
+	async #listAllDynamicFieldAddressKeys(parentId) {
+		const keys = [];
+		let cursor = null;
+		do {
+			const page = await this.#client.core.listDynamicFields({
+				parentId,
+				cursor: cursor ?? void 0
+			});
+			for (const df of page.dynamicFields) keys.push(bcs.Address.parse(new Uint8Array(df.name.bcs)));
+			cursor = page.hasNextPage ? page.cursor : null;
+		} while (cursor);
+		return keys;
+	}
+	/**
 	* Batch-fetches objects in chunks of `GET_OBJECTS_BATCH`, concatenating
 	* the results. Each element is either an object or an `Error` (for
 	* missing / deleted objects).
@@ -516,7 +761,131 @@ var HashiClient = class {
 		}
 		return results;
 	}
+	/**
+	* Query the Sui GraphQL endpoint for events of a given type emitted by
+	* a sender. Returns the `request_id` from each event's JSON payload,
+	* paginating through all results.
+	*/
+	async #queryEventRequestIds(sender, eventType) {
+		const ids = [];
+		let cursor = null;
+		let hasMore = true;
+		while (hasMore) {
+			const query = `{
+                events(
+                    filter: { sender: "${sender}", type: "${eventType}" }
+                    first: 50${cursor ? `, after: "${cursor}"` : ""}
+                ) {
+                    nodes { contents { json } }
+                    pageInfo { hasNextPage endCursor }
+                }
+            }`;
+			const res = await fetch(this.#graphqlUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ query })
+			});
+			if (!res.ok) throw new Error(`GraphQL request failed: ${res.status}`);
+			const body = await res.json();
+			if (body.errors?.length) throw new Error(`GraphQL error: ${body.errors[0].message}`);
+			const events = body.data?.events;
+			if (!events) break;
+			for (const node of events.nodes) ids.push(node.contents.json.request_id);
+			hasMore = events.pageInfo.hasNextPage;
+			cursor = events.pageInfo.endCursor ?? null;
+		}
+		return ids;
+	}
+	/**
+	* Classify a batch of request objects into deposit / withdrawal history
+	* items. Errors in the batch are skipped (the request object may have
+	* been deleted between the bag enumeration and the fetch). Returns the
+	* items plus the indices that need a follow-up `WithdrawalTransaction`
+	* fetch to populate `btcTxid`.
+	*/
+	#classifyRequestObjects(objects) {
+		const items = [];
+		const withdrawalTxnLookups = [];
+		const depositRequestType = `${this.#packageId}::deposit_queue::DepositRequest`;
+		const withdrawalRequestType = `${this.#packageId}::withdrawal_queue::WithdrawalRequest`;
+		for (const obj of objects) {
+			if (obj instanceof Error) continue;
+			if (obj.type === depositRequestType) items.push(parseDepositHistoryItem(obj.content));
+			else if (obj.type === withdrawalRequestType) {
+				const item = parseWithdrawalHistoryItem(obj.content);
+				items.push(item);
+				if (item.withdrawalTxnId) withdrawalTxnLookups.push({
+					itemIndex: items.length - 1,
+					txnId: item.withdrawalTxnId
+				});
+			}
+		}
+		return {
+			items,
+			withdrawalTxnLookups
+		};
+	}
+	/**
+	* Batch-fetch `WithdrawalTransaction` objects for the withdrawal items
+	* that have a linked txn and overwrite their `btcTxid` in place. Errors
+	* in the batch leave `btcTxid` at the initial `null`.
+	*/
+	async #populateWithdrawalBtcTxids(items, lookups) {
+		if (lookups.length === 0) return;
+		const txnIds = lookups.map((l) => l.txnId);
+		const txnObjects = await this.#batchGetObjects(txnIds, { content: true });
+		for (let i = 0; i < lookups.length; i++) {
+			const txnObj = txnObjects[i];
+			if (txnObj instanceof Error) continue;
+			const parsed = WithdrawalTransaction.parse(txnObj.content);
+			const item = items[lookups[i].itemIndex];
+			item.btcTxid = reverseTxidBytes(parsed.txid);
+		}
+	}
 };
+function parseDepositHistoryItem(content) {
+	const parsed = DepositRequest.parse(content);
+	return {
+		kind: "deposit",
+		requestId: parsed.id,
+		sender: parsed.sender,
+		timestampMs: BigInt(parsed.timestamp_ms),
+		suiTxDigest: base58.encode(new Uint8Array(parsed.sui_tx_digest)),
+		amountSats: BigInt(parsed.utxo.amount),
+		btcTxid: reverseTxidBytes(parsed.utxo.id.txid),
+		btcVout: parsed.utxo.id.vout,
+		approved: parsed.approval_cert !== null,
+		approvalTimestampMs: parsed.approval_timestamp_ms === null ? null : BigInt(parsed.approval_timestamp_ms)
+	};
+}
+function parseWithdrawalHistoryItem(content) {
+	const parsed = WithdrawalRequest.parse(content);
+	return {
+		kind: "withdrawal",
+		requestId: parsed.id,
+		sender: parsed.sender,
+		btcAmountSats: BigInt(parsed.btc_amount),
+		bitcoinAddress: new Uint8Array(parsed.bitcoin_address),
+		timestampMs: BigInt(parsed.timestamp_ms),
+		suiTxDigest: base58.encode(new Uint8Array(parsed.sui_tx_digest)),
+		status: parsed.status.$kind,
+		withdrawalTxnId: parsed.withdrawal_txn_id ?? null,
+		btcTxid: null
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("Aborted"));
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("Aborted"));
+		}, { once: true });
+	});
+}
 
 //#endregion
 export { HashiClient, hashi };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { BitcoinNetwork, CancelWithdrawalParams, DepositHistoryItem, DepositParams, GovernanceConfig, HashiClientOptions, NetworkConfig, SuiNetwork, TransactionHistoryItem, UtxoId, UtxoOutput, UtxoUsageResult, WithdrawalHistoryItem, WithdrawalParams, WithdrawalStatus } from "./types.mjs";
+import { BitcoinNetwork, CancelWithdrawalParams, DepositFees, DepositHistoryItem, DepositInfo, DepositParams, DepositStatus, GovernanceConfig, HashiClientOptions, HbtcBalance, NetworkConfig, SuiNetwork, TransactionHistoryItem, UtxoId, UtxoLookupResult, UtxoOutput, UtxoUsageResult, WaitOptions, WithdrawalFees, WithdrawalHistoryItem, WithdrawalInfo, 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 };
+import { arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, taprootScriptPathAddress, witnessProgramToAddress } from "./bitcoin.mjs";
+export { AmountBelowMinimumError, type AmountViolation, type BitcoinNetwork, type CancelWithdrawalParams, type DepositFees, type DepositHistoryItem, type DepositInfo, type DepositParams, type DepositStatus, type GovernanceConfig, HashiClient, type HashiClientOptions, HashiConfigError, HashiFetchError, HashiPausedError, type HbtcBalance, type InvalidBitcoinAddressCode, InvalidBitcoinAddressError, InvalidParamsError, type NetworkConfig, type SuiNetwork, type TransactionHistoryItem, type UtxoId, type UtxoLookupResult, type UtxoOutput, type UtxoUsageResult, type WaitOptions, type WithdrawalFees, type WithdrawalHistoryItem, type WithdrawalInfo, type WithdrawalParams, type WithdrawalStatus, arkworksToSec1Compressed, bitcoinAddressToWitnessProgram, deriveChildPubkey, generateDepositAddress, hashi, taprootScriptPathAddress, witnessProgramToAddress };

package/dist/index.mjs

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