@mysten-incubation/hashi 0.0.1

package/dist/client.mjs

@@ -0,0 +1,522 @@
+import { Bag } from "./contracts/hashi/deps/sui/bag.mjs";
+import { Hashi } from "./contracts/hashi/hashi.mjs";
+import { UtxoId, utxo, utxoId } from "./contracts/hashi/utxo.mjs";
+import { DepositRequest } from "./contracts/hashi/deposit_queue.mjs";
+import { WithdrawalRequest, WithdrawalTransaction } from "./contracts/hashi/withdrawal_queue.mjs";
+import { BitcoinState, BitcoinStateKey } from "./contracts/hashi/bitcoin_state.mjs";
+import { deposit } from "./contracts/hashi/deposit.mjs";
+import { cancelWithdrawal, requestWithdrawal } from "./contracts/hashi/withdraw.mjs";
+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 { assertHex32, entry, reverseTxidBytes } from "./util.mjs";
+import { TypeTagSerializer, bcs } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID, fromHex, toHex } from "@mysten/sui/utils";
+import { Transaction, coinWithBalance } from "@mysten/sui/transactions";
+
+//#region src/client.ts
+/** 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;
+function hashi({ name = "hashi", ...options }) {
+	return {
+		name,
+		register: (client) => {
+			return new HashiClient({
+				client,
+				...options
+			});
+		}
+	};
+}
+/**
+* User-facing SDK client for the Hashi protocol. Constructed via the
+* `hashi({...})` factory and attached to any Sui client via `$extend`:
+*
+* ```ts
+* const client = new SuiGrpcClient({ ... }).$extend(hashi({ network: "devnet" }));
+* const result = await client.hashi.deposit({ signer, ... });
+* ```
+*
+* **Direct methods (`deposit`, `withdraw`) sign and execute transactions** on
+* behalf of the caller — pass a `Signer` and receive the execution result.
+* For composable flows (bundling into a larger PTB, sponsored transactions,
+* dry-run/simulation), use the `tx.*` builders instead; they return unsigned
+* `Transaction` objects and leave signing to the caller.
+*/
+var HashiClient = class {
+	#client;
+	#hashiObjectId;
+	#packageId;
+	#bitcoinNetwork;
+	constructor({ client, network, hashiObjectId, packageId, bitcoinNetwork }) {
+		this.tx = {
+			deposit: (params) => {
+				const tx = new Transaction();
+				const internalTxid = reverseTxidBytes(params.txid);
+				for (const { vout, amountSats } of params.utxos) {
+					const utxoId$1 = tx.add(utxoId({
+						package: this.#packageId,
+						arguments: {
+							txid: internalTxid,
+							vout
+						}
+					}));
+					const utxo$1 = tx.add(utxo({
+						package: this.#packageId,
+						arguments: {
+							utxoId: utxoId$1,
+							amount: amountSats,
+							derivationPath: params.recipient
+						}
+					}));
+					tx.add(this.call.deposit({ utxo: utxo$1 }));
+				}
+				return tx;
+			},
+			requestWithdrawal: (options) => {
+				const tx = new Transaction();
+				const btcType = `${this.#packageId}::btc::BTC`;
+				const coin = tx.add(coinWithBalance({
+					type: btcType,
+					balance: options.amount,
+					useGasCoin: false
+				}));
+				const [balance] = tx.moveCall({
+					package: "0x2",
+					module: "coin",
+					function: "into_balance",
+					typeArguments: [btcType],
+					arguments: [coin]
+				});
+				tx.add(this.call.requestWithdrawal({
+					btc: balance,
+					bitcoinAddress: Array.from(options.bitcoinAddress)
+				}));
+				return tx;
+			},
+			cancelWithdrawal: (options) => {
+				const tx = new Transaction();
+				const balance = tx.add(this.call.cancelWithdrawal({ requestId: options.requestId }));
+				const [coin] = tx.moveCall({
+					package: "0x2",
+					module: "coin",
+					function: "from_balance",
+					typeArguments: [`${this.#packageId}::btc::BTC`],
+					arguments: [balance]
+				});
+				tx.transferObjects([coin], options.recipient);
+				return tx;
+			}
+		};
+		this.call = {
+			deposit: (options) => deposit({
+				package: this.#packageId,
+				arguments: {
+					hashi: this.#hashiObjectId,
+					utxo: options.utxo
+				}
+			}),
+			requestWithdrawal: (options) => requestWithdrawal({
+				package: this.#packageId,
+				arguments: {
+					hashi: this.#hashiObjectId,
+					btc: options.btc,
+					bitcoinAddress: options.bitcoinAddress
+				}
+			}),
+			cancelWithdrawal: (options) => cancelWithdrawal({
+				package: this.#packageId,
+				arguments: {
+					hashi: this.#hashiObjectId,
+					requestId: options.requestId
+				}
+			})
+		};
+		this.view = {
+			mpcPublicKey: async () => {
+				const result = await Hashi.get({
+					client: this.#client,
+					objectId: this.#hashiObjectId
+				});
+				const mpcKey = new Uint8Array(result.json.committee_set.mpc_public_key);
+				if (mpcKey.length === 0) throw new Error("MPC public key not available on-chain. Has the committee completed DKG?");
+				return arkworksToSec1Compressed(mpcKey);
+			},
+			all: async () => {
+				let result;
+				try {
+					result = await Hashi.get({
+						client: this.#client,
+						objectId: this.#hashiObjectId
+					});
+				} catch (cause) {
+					throw new HashiFetchError(`Failed to fetch Hashi shared object ${this.#hashiObjectId}.`, this.#hashiObjectId, { cause });
+				}
+				const contents = result.json?.config?.config?.contents;
+				if (!Array.isArray(contents)) throw new HashiFetchError(`Hashi object ${this.#hashiObjectId} returned an unexpected shape: config.config.contents is not an array.`, this.#hashiObjectId);
+				return this.#parseConfig(contents);
+			},
+			paused: async () => (await this.view.all()).paused,
+			bitcoinDepositMinimum: async () => (await this.view.all()).bitcoinDepositMinimum,
+			bitcoinWithdrawalMinimum: async () => (await this.view.all()).bitcoinWithdrawalMinimum,
+			bitcoinConfirmationThreshold: async () => (await this.view.all()).bitcoinConfirmationThreshold,
+			withdrawalCancellationCooldownMs: async () => (await this.view.all()).withdrawalCancellationCooldownMs,
+			bitcoinChainId: async () => (await this.view.all()).bitcoinChainId,
+			depositMinimum: async () => (await this.view.all()).depositMinimum,
+			worstCaseNetworkFee: async () => (await this.view.all()).worstCaseNetworkFee,
+			findUsedUtxos: async (utxos) => {
+				if (utxos.length === 0) return [];
+				const btcState = await this.#fetchBitcoinState();
+				const activePoolId = btcState.utxo_pool.utxo_records.id;
+				const spentPoolId = btcState.utxo_pool.spent_utxos.id;
+				const typeTag = TypeTagSerializer.parseFromStr(`${this.#packageId}::utxo::UtxoId`);
+				const fieldIds = [];
+				for (const u of utxos) {
+					const keyBcs = UtxoId.serialize({
+						txid: reverseTxidBytes(u.txid),
+						vout: u.vout
+					}).toBytes();
+					fieldIds.push(deriveDynamicFieldID(activePoolId, typeTag, keyBcs), deriveDynamicFieldID(spentPoolId, typeTag, keyBcs));
+				}
+				const objects = await this.#batchGetObjects(fieldIds);
+				return utxos.map((u, i) => {
+					const inActivePool = !(objects[i * 2] instanceof Error);
+					const inSpentPool = !(objects[i * 2 + 1] instanceof Error);
+					return {
+						utxoId: u,
+						inActivePool,
+						inSpentPool,
+						isUsed: inActivePool || inSpentPool
+					};
+				});
+			},
+			transactionHistory: async (suiAddress) => {
+				const tableId = (await this.#fetchBitcoinState()).user_requests.id;
+				let userBagId;
+				try {
+					const { dynamicField } = await this.#client.core.getDynamicField({
+						parentId: tableId,
+						name: {
+							type: "address",
+							bcs: bcs.Address.serialize(suiAddress).toBytes()
+						}
+					});
+					userBagId = Bag.parse(new Uint8Array(dynamicField.value.bcs)).id;
+				} catch {
+					return [];
+				}
+				const requestIds = [];
+				let cursor = null;
+				do {
+					const page = await this.#client.core.listDynamicFields({
+						parentId: userBagId,
+						cursor: cursor ?? void 0
+					});
+					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 });
+				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
+						});
+					}
+				}
+				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);
+					}
+				}
+				return items;
+			}
+		};
+		const config = NETWORK_CONFIG[network];
+		const resolvedObjectId = hashiObjectId ?? config?.hashiObjectId;
+		const resolvedPackageId = packageId ?? config?.packageId;
+		if (!resolvedObjectId || !resolvedPackageId) throw new Error(`Hashi is not yet supported on Sui ${network}. Provide a custom hashiObjectId and packageId.`);
+		this.#client = client;
+		this.#hashiObjectId = resolvedObjectId;
+		this.#packageId = resolvedPackageId;
+		this.#bitcoinNetwork = bitcoinNetwork ?? config?.bitcoinNetwork ?? "testnet";
+	}
+	/**
+	* Generates a unique Bitcoin P2TR deposit address for a Sui address.
+	*
+	* Fetches the MPC committee public key from on-chain, derives a child key
+	* using the Sui address, and builds a taproot script-path address.
+	*
+	* @example
+	* ```ts
+	* const btcAddress = await client.hashi.generateDepositAddress({
+	*   suiAddress: signer.toSuiAddress(),
+	* });
+	* ```
+	*/
+	async generateDepositAddress({ suiAddress, bitcoinNetwork = this.#bitcoinNetwork }) {
+		return generateDepositAddress(await this.view.mpcPublicKey(), fromHex(suiAddress), bitcoinNetwork);
+	}
+	/**
+	* Submit one or more Bitcoin deposits for committee confirmation, batched
+	* into a single Sui PTB. Signs with `signer` and submits, returning the
+	* execution result (`$kind: "Transaction" | "FailedTransaction"`). The
+	* result includes `effects` and `events` so callers can confirm
+	* `DepositRequestedEvent` without an extra round-trip.
+	*
+	* The method runs three preflight stages before signing:
+	*
+	*   1. **Structural validation** — `txid` and `recipient` must be
+	*      0x-prefixed 32-byte hex; `utxos` must be non-empty; every `vout`
+	*      must be a non-negative u32 and unique within the call. Violations
+	*      throw `InvalidParamsError` without any chain read.
+	*   2. **Pause check** — reads the governance snapshot via `view.all()`
+	*      and throws `HashiPausedError` if `paused` is `true`. Mirrors the
+	*      Move-side `hashi::assert_unpaused`.
+	*   3. **Minimum check** — every UTXO must have `amountSats ≥
+	*      snap.bitcoinDepositMinimum`. All offenders are collected into one
+	*      `AmountBelowMinimumError`, so callers can fix the batch in one
+	*      round-trip. Mirrors `EBelowMinimumDeposit` in `deposit::deposit`.
+	*
+	* Both chain-reading checks (2, 3) read from the same `view.all()`
+	* snapshot, so validation is internally consistent. Chain state can still
+	* drift between the snapshot and execution — the Move side re-asserts
+	* both invariants, so a genuine race simply aborts the tx.
+	*
+	* For composable flows (sponsored tx, dry-run, or bundling into a larger
+	* PTB), use `tx.deposit(params)` instead — it returns the unsigned
+	* `Transaction` and leaves signing to the caller.
+	*/
+	async deposit({ signer, ...params }) {
+		this.#validateDepositParams(params);
+		const snap = await this.view.all();
+		if (snap.paused) throw new HashiPausedError({ operation: "deposit" });
+		const violations = [];
+		for (const { vout, amountSats } of params.utxos) if (amountSats < snap.bitcoinDepositMinimum) violations.push({
+			amount: amountSats,
+			minimum: snap.bitcoinDepositMinimum,
+			vout
+		});
+		if (violations.length > 0) throw new AmountBelowMinimumError({ violations });
+		const transaction = this.tx.deposit(params);
+		return this.#client.core.signAndExecuteTransaction({
+			signer,
+			transaction,
+			include: {
+				effects: true,
+				events: true
+			}
+		});
+	}
+	/**
+	* Submit a BTC withdrawal request for committee processing. Burns `hBTC`
+	* from the signer's balance and enqueues a request for the committee to
+	* send `amountSats` to `bitcoinAddress` on the Bitcoin network. Signs
+	* with `signer` and submits, returning the execution result including
+	* `effects` and `events` (`WithdrawalRequestedEvent`).
+	*
+	* The method runs three preflight stages before signing:
+	*
+	*   1. **Address decoding** — `bitcoinAddress` is decoded as bech32 (v0
+	*      P2WPKH, 20 bytes) or bech32m (v1 P2TR, 32 bytes) via
+	*      `bitcoinAddressToWitnessProgram`. The HRP must match the client's
+	*      configured Bitcoin network. Violations throw
+	*      `InvalidBitcoinAddressError` with a structured `code` so callers
+	*      can distinguish a typo from a wrong-network mistake.
+	*   2. **Pause check** — reads the governance snapshot via `view.all()`
+	*      and throws `HashiPausedError` if `paused` is `true`. Mirrors the
+	*      Move-side `hashi::assert_unpaused` in `request_withdrawal`.
+	*   3. **Minimum check** — `amountSats` must be ≥
+	*      `snap.bitcoinWithdrawalMinimum`. Below-minimum throws
+	*      `AmountBelowMinimumError` with a single violation. Mirrors
+	*      `EBelowMinimumWithdrawal` in `withdraw::request_withdrawal`.
+	*
+	* For composable flows (sponsored tx, dry-run, or bundling into a
+	* larger PTB), use `tx.requestWithdrawal(options)` instead — it returns
+	* the unsigned `Transaction` and leaves signing to the caller.
+	*/
+	async requestWithdrawal({ signer, ...params }) {
+		const { program } = bitcoinAddressToWitnessProgram(params.bitcoinAddress, this.#bitcoinNetwork);
+		const snap = await this.view.all();
+		if (snap.paused) throw new HashiPausedError({ operation: "withdraw" });
+		if (params.amountSats < snap.bitcoinWithdrawalMinimum) throw new AmountBelowMinimumError({ violations: [{
+			amount: params.amountSats,
+			minimum: snap.bitcoinWithdrawalMinimum
+		}] });
+		const transaction = this.tx.requestWithdrawal({
+			amount: params.amountSats,
+			bitcoinAddress: program
+		});
+		return this.#client.core.signAndExecuteTransaction({
+			signer,
+			transaction,
+			include: {
+				effects: true,
+				events: true
+			}
+		});
+	}
+	/**
+	* Cancel a pending withdrawal request and return the locked BTC to the
+	* signer. Signs with `signer` and submits, returning the execution result.
+	*
+	* The only client-side precondition is that `requestId` is 0x-prefixed
+	* 32-byte hex. All other constraints — ownership (only the original
+	* requester can cancel), state window (cancellable only while `Requested`
+	* or `Approved`, not after committee commitment), and the on-chain
+	* `withdrawal_cancellation_cooldown_ms` — are enforced by the Move side
+	* and left to abort at execution. Pre-fetching them would cost an extra
+	* round-trip and still race chain state.
+	*
+	* Unlike `requestWithdrawal`, no pause check is performed: the Move
+	* `cancel_withdrawal` function has no `assert_unpaused`, so users can
+	* always unwind a pending request even when the system is paused.
+	*
+	* For composable flows, use `tx.cancelWithdrawal({ requestId, recipient })`.
+	*/
+	async cancelWithdrawal({ signer, requestId }) {
+		assertHex32(requestId, "requestId");
+		const transaction = this.tx.cancelWithdrawal({
+			requestId,
+			recipient: signer.toSuiAddress()
+		});
+		return this.#client.core.signAndExecuteTransaction({
+			signer,
+			transaction,
+			include: {
+				effects: true,
+				events: true
+			}
+		});
+	}
+	#validateDepositParams(params) {
+		assertHex32(params.txid, "txid");
+		assertHex32(params.recipient, "recipient");
+		if (params.utxos.length === 0) throw new InvalidParamsError({ reason: "`utxos` must contain at least one UTXO" });
+		const seen = /* @__PURE__ */ new Set();
+		for (const { vout } of params.utxos) {
+			if (!Number.isInteger(vout) || vout < 0 || vout > U32_MAX) throw new InvalidParamsError({
+				reason: "`vout` must be a non-negative u32 integer",
+				detail: `got ${JSON.stringify(vout)}`
+			});
+			if (seen.has(vout)) throw new InvalidParamsError({
+				reason: "duplicate `vout` within a single deposit",
+				detail: `vout ${vout} appears more than once (each output of a single txid must be unique)`
+			});
+			seen.add(vout);
+		}
+	}
+	/**
+	* Parses the `Hashi.config.config` VecMap contents into a typed snapshot,
+	* applying the same floors as the Move accessors so the SDK matches
+	* on-chain semantics exactly.
+	*/
+	#parseConfig(contents) {
+		const u64 = (key) => {
+			const v = entry(contents, key, "U64");
+			try {
+				return BigInt(v.U64);
+			} catch (cause) {
+				throw HashiConfigError.malformedPayload(key, "U64", `"${v.U64}" is not a valid integer`, cause);
+			}
+		};
+		const bool = (key) => entry(contents, key, "Bool").Bool;
+		const addr = (key) => entry(contents, key, "Address").Address;
+		const rawDepositMin = u64("bitcoin_deposit_minimum");
+		const rawWithdrawalMin = u64("bitcoin_withdrawal_minimum");
+		const bitcoinDepositMinimum = rawDepositMin < DUST_RELAY_MIN_VALUE ? DUST_RELAY_MIN_VALUE : rawDepositMin;
+		const bitcoinWithdrawalMinimum = rawWithdrawalMin < DUST_RELAY_MIN_VALUE + 1n ? DUST_RELAY_MIN_VALUE + 1n : rawWithdrawalMin;
+		return {
+			paused: bool("paused"),
+			bitcoinChainId: addr("bitcoin_chain_id"),
+			bitcoinDepositMinimum,
+			bitcoinWithdrawalMinimum,
+			bitcoinConfirmationThreshold: u64("bitcoin_confirmation_threshold"),
+			withdrawalCancellationCooldownMs: u64("withdrawal_cancellation_cooldown_ms"),
+			depositMinimum: bitcoinDepositMinimum,
+			worstCaseNetworkFee: bitcoinWithdrawalMinimum - DUST_RELAY_MIN_VALUE
+		};
+	}
+	/**
+	* 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`.
+	*
+	* `BitcoinState` is attached via `df::add` on the Move side (it has
+	* `store` only, not `key`), so the regular-DF accessor is the right tool
+	* — `getDynamicObjectField` would look for a `dynamic_object_field::
+	* Wrapper<BitcoinStateKey>` that doesn't exist and abort with "not
+	* found". The previous `listDynamicFields` workaround filtered for
+	* `$kind === "DynamicObject"` and hit the same dof/df mismatch.
+	*/
+	async #fetchBitcoinState() {
+		const { dynamicField } = await this.#client.core.getDynamicField({
+			parentId: this.#hashiObjectId,
+			name: {
+				type: `${this.#packageId}::bitcoin_state::BitcoinStateKey`,
+				bcs: BitcoinStateKey.serialize({ dummy_field: false }).toBytes()
+			}
+		});
+		return BitcoinState.parse(new Uint8Array(dynamicField.value.bcs));
+	}
+	/**
+	* 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).
+	*/
+	async #batchGetObjects(objectIds, include) {
+		const results = [];
+		for (let i = 0; i < objectIds.length; i += GET_OBJECTS_BATCH) {
+			const batch = objectIds.slice(i, i + GET_OBJECTS_BATCH);
+			const { objects } = await this.#client.core.getObjects({
+				objectIds: batch,
+				include
+			});
+			results.push(...objects);
+		}
+		return results;
+	}
+};
+
+//#endregion
+export { HashiClient, hashi };

package/dist/constants.mjs

@@ -0,0 +1,60 @@
+//#region src/constants.ts
+const NETWORK_HRP = {
+	mainnet: "bc",
+	testnet: "tb",
+	signet: "tb",
+	regtest: "bcrt"
+};
+/**
+* BIP-341 Nothing-Up-My-Sleeve (NUMS) internal key.
+* Has no known private key, which forces all taproot spends through the script path.
+*/
+const NUMS_KEY = new Uint8Array([
+	80,
+	146,
+	155,
+	116,
+	193,
+	160,
+	73,
+	84,
+	183,
+	139,
+	75,
+	96,
+	53,
+	233,
+	122,
+	94,
+	7,
+	138,
+	90,
+	15,
+	40,
+	236,
+	150,
+	213,
+	71,
+	191,
+	238,
+	154,
+	206,
+	128,
+	58,
+	192
+]);
+/**
+* The Move side uses this as a floor on `bitcoin_deposit_minimum` and
+* `bitcoin_withdrawal_minimum`; the SDK replicates the same floors so `view.*`
+* matches on-chain semantics. Mirrors `DUST_RELAY_MIN_VALUE` in
+* `hashi::btc_config`.
+*/
+const DUST_RELAY_MIN_VALUE = 546n;
+const NETWORK_CONFIG = { devnet: {
+	hashiObjectId: "0x61f1acbf8dd79d284cb312853389747a55a158b1b12a68554afcade05dec5f40",
+	packageId: "0xc377616c626d73556cae080706acf37e862d24d26c690cc7be5a957f53fadf17",
+	bitcoinNetwork: "signet"
+} };
+
+//#endregion
+export { DUST_RELAY_MIN_VALUE, NETWORK_CONFIG, NETWORK_HRP, NUMS_KEY };

package/dist/contracts/hashi/bitcoin_state.mjs

@@ -0,0 +1,28 @@
+import { MoveStruct } from "../utils/index.mjs";
+import { DepositRequestQueue } from "./deposit_queue.mjs";
+import { WithdrawalRequestQueue } from "./withdrawal_queue.mjs";
+import { UtxoPool } from "./utxo_pool.mjs";
+import { Table } from "./deps/sui/table.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/hashi/bitcoin_state.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+const $moduleName = "@local-pkg/hashi::bitcoin_state";
+const BitcoinStateKey = new MoveStruct({
+	name: `${$moduleName}::BitcoinStateKey`,
+	fields: { dummy_field: bcs.bool() }
+});
+const BitcoinState = new MoveStruct({
+	name: `${$moduleName}::BitcoinState`,
+	fields: {
+		deposit_queue: DepositRequestQueue,
+		withdrawal_queue: WithdrawalRequestQueue,
+		utxo_pool: UtxoPool,
+		user_requests: Table
+	}
+});
+
+//#endregion
+export { BitcoinState, BitcoinStateKey };

package/dist/contracts/hashi/committee.mjs

@@ -0,0 +1,40 @@
+import { MoveStruct } from "../utils/index.mjs";
+import { Element } from "./deps/sui/group_ops.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/hashi/committee.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+const $moduleName = "@local-pkg/hashi::committee";
+const CommitteeMember = new MoveStruct({
+	name: `${$moduleName}::CommitteeMember`,
+	fields: {
+		validator_address: bcs.Address,
+		public_key: Element,
+		encryption_public_key: bcs.vector(bcs.u8()),
+		weight: bcs.u64()
+	}
+});
+const Committee = new MoveStruct({
+	name: `${$moduleName}::Committee`,
+	fields: {
+		epoch: bcs.u64(),
+		members: bcs.vector(CommitteeMember),
+		total_weight: bcs.u64(),
+		mpc_threshold_in_basis_points: bcs.u64(),
+		mpc_weight_reduction_allowed_delta: bcs.u64(),
+		mpc_max_faulty_in_basis_points: bcs.u64()
+	}
+});
+const CommitteeSignature = new MoveStruct({
+	name: `${$moduleName}::CommitteeSignature`,
+	fields: {
+		epoch: bcs.u64(),
+		signature: bcs.vector(bcs.u8()),
+		signers_bitmap: bcs.vector(bcs.u8())
+	}
+});
+
+//#endregion
+export { CommitteeSignature };

package/dist/contracts/hashi/committee_set.mjs

@@ -0,0 +1,34 @@
+import { MoveStruct } from "../utils/index.mjs";
+import { Bag } from "./deps/sui/bag.mjs";
+import { Element } from "./deps/sui/group_ops.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/hashi/committee_set.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+const $moduleName = "@local-pkg/hashi::committee_set";
+const CommitteeSet = new MoveStruct({
+	name: `${$moduleName}::CommitteeSet`,
+	fields: {
+		members: Bag,
+		epoch: bcs.u64(),
+		committees: Bag,
+		pending_epoch_change: bcs.option(bcs.u64()),
+		mpc_public_key: bcs.vector(bcs.u8())
+	}
+});
+const MemberInfo = new MoveStruct({
+	name: `${$moduleName}::MemberInfo`,
+	fields: {
+		validator_address: bcs.Address,
+		operator_address: bcs.Address,
+		next_epoch_public_key: Element,
+		endpoint_url: bcs.string(),
+		tls_public_key: bcs.vector(bcs.u8()),
+		next_epoch_encryption_public_key: bcs.vector(bcs.u8())
+	}
+});
+
+//#endregion
+export { CommitteeSet };