@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/sign-bitcoin-transaction-with-seed-D4z62-jV.js

@@ -0,0 +1,147 @@
+import { a as __toESM } from "./rolldown-runtime-OvD0k9op.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import { c as require_dist, l as require_src, o as tweakTaprootPrivateKey, t as AddressType } from "./address-B9ntKL8K.js";
+import { n as deriveAccountRootKeyPair, r as deriveChildKeyPair } from "./keyDerivation-D3k9XyHg.js";
+import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
+//#region ../../packages/module/blockchain-bitcoin/src/common/transaction.ts
+var import_src = /* @__PURE__ */ __toESM(require_src());
+/**
+* Converts the transaction into a hex-encoded string.
+*/
+const encodeUnsignedTxToString = (tx) => {
+	const dto = {
+		...tx,
+		context: tx.context.toHex()
+	};
+	return HexBytes.fromUTF8(JSON.stringify(dto));
+};
+/**
+* Converts the hex-encoded string back into the usable UnsignedTransaction object.
+*/
+const decodeUnsignedTxFromString = (encodedString) => {
+	const jsonString = HexBytes.toUTF8(encodedString);
+	const dto = JSON.parse(jsonString);
+	return {
+		...dto,
+		context: import_src.Psbt.fromHex(dto.context)
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/wallet/BitcoinSigner.ts
+init__polyfill_buffer_patch();
+var import_dist = /* @__PURE__ */ __toESM(require_dist());
+var BitcoinSigner = class {
+	publicKey;
+	/**
+	* Creates a new CustomSigner instance.
+	* @param keyPair - The key pair to use for signing.
+	*/
+	constructor(keyPair) {
+		this.keyPair = keyPair;
+		if (!keyPair.privateKey) throw new Error("Private key is required to sign transactions.");
+		this.publicKey = keyPair.publicKey;
+	}
+	/**
+	* Signs a hash using tiny-secp256k1's sign function.
+	* @param hash - The hash to sign (must be 32 bytes).
+	* @param _lowR - Optional flag for lowR signatures (ignored here).
+	* @returns The signature as a buffer.
+	*/
+	sign(hash, _lowR = false) {
+		if (hash.length !== 32) throw new Error("Hash must be 32 bytes.");
+		const signature = import_dist.sign(new Uint8Array(hash), new Uint8Array(this.keyPair.privateKey));
+		return import_buffer.Buffer.from(signature);
+	}
+	/**
+	* Returns the public key.
+	* @returns The public key as a buffer.
+	*/
+	getPublicKey() {
+		return this.publicKey;
+	}
+	/**
+	* Clears the private key from memory.
+	*
+	* This is a security measure to prevent the private key from being exposed in memory.
+	*/
+	clearSecrets() {
+		this.keyPair.privateKey.fill(0);
+	}
+};
+/**
+* Signs a PSBT transaction with multiple Bitcoin signers, each corresponding to a specific input.
+*
+* @param unsignedTx - The PSBT transaction to sign.
+* @param signers - An array of BitcoinSigner instances, where each signer is used for the respective input.
+* @returns The signed transaction containing the signed PSBT and its hexadecimal representation.
+*/
+const signTx = (unsignedTx, signers) => {
+	const psbt = unsignedTx.context;
+	signers.forEach((signer, index) => {
+		psbt.signInput(index, signer);
+	});
+	psbt.finalizeAllInputs();
+	return {
+		context: psbt,
+		hex: psbt.extractTransaction().toHex()
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/signing/sign-bitcoin-transaction-with-seed.ts
+init__polyfill_buffer_patch();
+/**
+* Signs a serialized unsigned Bitcoin transaction with keys derived from a
+* BIP-39 seed, one key per entry in the transaction's signers list. Taproot
+* signers use the tweaked private key.
+*
+* The signer private keys and the Taproot tweak buffers are zeroed whether
+* signing succeeds or throws. The caller owns the seed: it is read but never
+* mutated or wiped, so the caller must wipe it once signing is done.
+*
+* @param serializedTx - The unsigned transaction as produced by the transaction builder.
+* @param seed - The 64-byte BIP-39 seed of the wallet that owns the inputs.
+* @returns The signed transaction, serialized with its network.
+*/
+const signBitcoinTransactionWithSeed = (serializedTx, seed) => {
+	const seedView = import_buffer.Buffer.from(seed.buffer, seed.byteOffset, seed.byteLength);
+	const tx = decodeUnsignedTxFromString(serializedTx);
+	const signers = [];
+	try {
+		for (const signingKey of tx.signers) {
+			const keyPair = deriveChildKeyPair(deriveAccountRootKeyPair({
+				seed: seedView,
+				addressType: signingKey.addressType,
+				network: signingKey.network,
+				account: signingKey.account
+			}).pair.privateKey, signingKey.chain, signingKey.index);
+			let finalKeyPair = keyPair.pair;
+			if (signingKey.addressType === AddressType.Taproot) {
+				const internalXOnlyPubKey = keyPair.pair.publicKey.slice(1);
+				const childPrivateKey = import_buffer.Buffer.from(keyPair.pair.privateKey, "hex");
+				try {
+					const tweakedPrivateKey = tweakTaprootPrivateKey(childPrivateKey, import_buffer.Buffer.from(internalXOnlyPubKey, "hex"));
+					finalKeyPair = {
+						publicKey: keyPair.pair.publicKey,
+						privateKey: tweakedPrivateKey.toString("hex")
+					};
+					tweakedPrivateKey.fill(0);
+				} finally {
+					childPrivateKey.fill(0);
+				}
+			}
+			signers.push(new BitcoinSigner({
+				publicKey: import_buffer.Buffer.from(finalKeyPair.publicKey, "hex"),
+				privateKey: import_buffer.Buffer.from(finalKeyPair.privateKey, "hex")
+			}));
+		}
+		const signedTx = signTx(tx, signers);
+		return { serializedTx: HexBytes.fromUTF8(JSON.stringify({
+			network: tx.network,
+			hex: signedTx.hex
+		})) };
+	} finally {
+		for (const signer of signers) signer.clearSecrets();
+	}
+};
+//#endregion
+export { encodeUnsignedTxToString as n, signBitcoinTransactionWithSeed as t };

package/dist/sign-bitcoin-transaction-with-seed-DsLYXnCY.cjs

@@ -0,0 +1,158 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+const require_address = require("./address-BXp-mY8H.cjs");
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_keyDerivation = require("./keyDerivation-u0nBA93T.cjs");
+//#region ../../packages/module/blockchain-bitcoin/src/common/transaction.ts
+var import_src = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_address.require_src());
+/**
+* Converts the transaction into a hex-encoded string.
+*/
+const encodeUnsignedTxToString = (tx) => {
+	const dto = {
+		...tx,
+		context: tx.context.toHex()
+	};
+	return require_bytes_vo.HexBytes.fromUTF8(JSON.stringify(dto));
+};
+/**
+* Converts the hex-encoded string back into the usable UnsignedTransaction object.
+*/
+const decodeUnsignedTxFromString = (encodedString) => {
+	const jsonString = require_bytes_vo.HexBytes.toUTF8(encodedString);
+	const dto = JSON.parse(jsonString);
+	return {
+		...dto,
+		context: import_src.Psbt.fromHex(dto.context)
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/wallet/BitcoinSigner.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_dist = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_address.require_dist());
+var BitcoinSigner = class {
+	publicKey;
+	/**
+	* Creates a new CustomSigner instance.
+	* @param keyPair - The key pair to use for signing.
+	*/
+	constructor(keyPair) {
+		this.keyPair = keyPair;
+		if (!keyPair.privateKey) throw new Error("Private key is required to sign transactions.");
+		this.publicKey = keyPair.publicKey;
+	}
+	/**
+	* Signs a hash using tiny-secp256k1's sign function.
+	* @param hash - The hash to sign (must be 32 bytes).
+	* @param _lowR - Optional flag for lowR signatures (ignored here).
+	* @returns The signature as a buffer.
+	*/
+	sign(hash, _lowR = false) {
+		if (hash.length !== 32) throw new Error("Hash must be 32 bytes.");
+		const signature = import_dist.sign(new Uint8Array(hash), new Uint8Array(this.keyPair.privateKey));
+		return require__polyfill_buffer_patch.import_buffer.Buffer.from(signature);
+	}
+	/**
+	* Returns the public key.
+	* @returns The public key as a buffer.
+	*/
+	getPublicKey() {
+		return this.publicKey;
+	}
+	/**
+	* Clears the private key from memory.
+	*
+	* This is a security measure to prevent the private key from being exposed in memory.
+	*/
+	clearSecrets() {
+		this.keyPair.privateKey.fill(0);
+	}
+};
+/**
+* Signs a PSBT transaction with multiple Bitcoin signers, each corresponding to a specific input.
+*
+* @param unsignedTx - The PSBT transaction to sign.
+* @param signers - An array of BitcoinSigner instances, where each signer is used for the respective input.
+* @returns The signed transaction containing the signed PSBT and its hexadecimal representation.
+*/
+const signTx = (unsignedTx, signers) => {
+	const psbt = unsignedTx.context;
+	signers.forEach((signer, index) => {
+		psbt.signInput(index, signer);
+	});
+	psbt.finalizeAllInputs();
+	return {
+		context: psbt,
+		hex: psbt.extractTransaction().toHex()
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/signing/sign-bitcoin-transaction-with-seed.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+/**
+* Signs a serialized unsigned Bitcoin transaction with keys derived from a
+* BIP-39 seed, one key per entry in the transaction's signers list. Taproot
+* signers use the tweaked private key.
+*
+* The signer private keys and the Taproot tweak buffers are zeroed whether
+* signing succeeds or throws. The caller owns the seed: it is read but never
+* mutated or wiped, so the caller must wipe it once signing is done.
+*
+* @param serializedTx - The unsigned transaction as produced by the transaction builder.
+* @param seed - The 64-byte BIP-39 seed of the wallet that owns the inputs.
+* @returns The signed transaction, serialized with its network.
+*/
+const signBitcoinTransactionWithSeed = (serializedTx, seed) => {
+	const seedView = require__polyfill_buffer_patch.import_buffer.Buffer.from(seed.buffer, seed.byteOffset, seed.byteLength);
+	const tx = decodeUnsignedTxFromString(serializedTx);
+	const signers = [];
+	try {
+		for (const signingKey of tx.signers) {
+			const keyPair = require_keyDerivation.deriveChildKeyPair(require_keyDerivation.deriveAccountRootKeyPair({
+				seed: seedView,
+				addressType: signingKey.addressType,
+				network: signingKey.network,
+				account: signingKey.account
+			}).pair.privateKey, signingKey.chain, signingKey.index);
+			let finalKeyPair = keyPair.pair;
+			if (signingKey.addressType === require_address.AddressType.Taproot) {
+				const internalXOnlyPubKey = keyPair.pair.publicKey.slice(1);
+				const childPrivateKey = require__polyfill_buffer_patch.import_buffer.Buffer.from(keyPair.pair.privateKey, "hex");
+				try {
+					const tweakedPrivateKey = require_address.tweakTaprootPrivateKey(childPrivateKey, require__polyfill_buffer_patch.import_buffer.Buffer.from(internalXOnlyPubKey, "hex"));
+					finalKeyPair = {
+						publicKey: keyPair.pair.publicKey,
+						privateKey: tweakedPrivateKey.toString("hex")
+					};
+					tweakedPrivateKey.fill(0);
+				} finally {
+					childPrivateKey.fill(0);
+				}
+			}
+			signers.push(new BitcoinSigner({
+				publicKey: require__polyfill_buffer_patch.import_buffer.Buffer.from(finalKeyPair.publicKey, "hex"),
+				privateKey: require__polyfill_buffer_patch.import_buffer.Buffer.from(finalKeyPair.privateKey, "hex")
+			}));
+		}
+		const signedTx = signTx(tx, signers);
+		return { serializedTx: require_bytes_vo.HexBytes.fromUTF8(JSON.stringify({
+			network: tx.network,
+			hex: signedTx.hex
+		})) };
+	} finally {
+		for (const signer of signers) signer.clearSecrets();
+	}
+};
+//#endregion
+Object.defineProperty(exports, "encodeUnsignedTxToString", {
+	enumerable: true,
+	get: function() {
+		return encodeUnsignedTxToString;
+	}
+});
+Object.defineProperty(exports, "signBitcoinTransactionWithSeed", {
+	enumerable: true,
+	get: function() {
+		return signBitcoinTransactionWithSeed;
+	}
+});

package/dist/signer-3fk8lZtE.cjs

@@ -0,0 +1,7 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_signer = require("./signer-CsL28DrK.cjs");
+exports.JUBJUB_R = require_signer.JUBJUB_R;
+exports.JubjubDevice = require_signer.JubjubDevice;
+exports.authArgs = require_signer.authArgs;
+exports.bytesToBigIntLE = require_signer.bytesToBigIntLE;
+exports.randomJubjubScalar = require_signer.randomJubjubScalar;

package/dist/signer-CsL28DrK.cjs

@@ -0,0 +1,121 @@
+const require_acc_module = require("./acc-module-4iIUv6My.cjs");
+//#region ../../packages/module/passport-account/src/acc/signer.ts
+/** Order of the JubJub prime-order subgroup, the Schnorr scalar field. */
+const JUBJUB_R = BigInt("0x0e7db4ea6533afa906673b0101343b00a6682093ccc81082d0970e5ed6f72cb7");
+/** Uniform scalar in [1, JUBJUB_R), by rejection sampling. */
+const randomJubjubScalar = () => {
+	for (;;) {
+		const candidate = [...crypto.getRandomValues(new Uint8Array(32))].reduce((value, byte) => value << 8n | BigInt(byte), 0n);
+		if (candidate > 0n && candidate < JUBJUB_R) return candidate;
+	}
+};
+/**
+* Little-endian integer interpretation of a hash, the reading the Account
+* Custody Contract applies when it compares a ground challenge against
+* JUBJUB_R.
+*/
+const bytesToBigIntLE = (bytes) => {
+	let result = 0n;
+	for (let index = bytes.length - 1; index >= 0; index--) result = result << 8n | BigInt(bytes[index]);
+	return result;
+};
+/**
+* A JubJub Schnorr device key for the Account Custody Contract's jubjub
+* authorisation arm. The key is an independent scalar, never derived from
+* a seed shared with any other device. All curve and hash operations go
+* through the contract's own exported pure circuits, so the device
+* inherits the compiler's field-aligned encoding bit-exactly.
+*/
+var JubjubDevice = class JubjubDevice {
+	pk;
+	constructor(sk) {
+		this.sk = sk;
+		this.pk = require_acc_module.pureCircuits.compute_public_point_with_jubjub(sk);
+	}
+	static generate() {
+		return new JubjubDevice(randomJubjubScalar());
+	}
+	/** The device's rolling entry at a given account, epoch, and counter. */
+	entryAt(contractAddress, epoch, counter) {
+		return require_acc_module.pureCircuits.derive_device_entry_with_jubjub({ bytes: contractAddress }, this.pk, epoch, counter);
+	}
+	/** The boot commitment binding this device's key to a boot salt. */
+	bootCommitment(salt) {
+		return require_acc_module.pureCircuits.derive_boot_commitment_with_jubjub(salt, this.pk);
+	}
+	/**
+	* Schnorr-signs the call the builder describes. Computes the
+	* announcement R = nonce * G, grinds the challenge hash by incrementing
+	* the grind nonce until its little-endian value falls below JUBJUB_R,
+	* then closes with s = nonce + challenge * sk mod JUBJUB_R.
+	*
+	* `useCounter` is carried alongside for the contract's anti-replay entry
+	* consumption; it is bound by the consumed entry, not the challenge.
+	* `nonce` defaults to a fresh uniform scalar and must never repeat
+	* across signatures, or the secret key leaks.
+	*/
+	sign(challenge, useCounter, nonce = randomJubjubScalar()) {
+		const sigR = require_acc_module.pureCircuits.compute_public_point_with_jubjub(nonce);
+		let grindNonce = 0n;
+		let challengeScalar;
+		for (;;) {
+			const hash = bytesToBigIntLE(challenge(sigR, grindNonce));
+			if (hash < JUBJUB_R) {
+				challengeScalar = hash;
+				break;
+			}
+			grindNonce++;
+		}
+		const sigS = (nonce + challengeScalar % JUBJUB_R * (this.sk % JUBJUB_R) % JUBJUB_R) % JUBJUB_R;
+		return {
+			scheme: "jubjub-schnorr",
+			pk: this.pk,
+			useCounter,
+			sigR,
+			sigS,
+			grindNonce
+		};
+	}
+};
+/**
+* The trailing circuit arguments an Authorisation expands to, in the order
+* the jubjub-gated circuits declare them after their own arguments.
+*/
+const authArgs = (authorisation) => [
+	authorisation.pk,
+	authorisation.useCounter,
+	authorisation.sigR,
+	authorisation.sigS,
+	authorisation.grindNonce
+];
+//#endregion
+Object.defineProperty(exports, "JUBJUB_R", {
+	enumerable: true,
+	get: function() {
+		return JUBJUB_R;
+	}
+});
+Object.defineProperty(exports, "JubjubDevice", {
+	enumerable: true,
+	get: function() {
+		return JubjubDevice;
+	}
+});
+Object.defineProperty(exports, "authArgs", {
+	enumerable: true,
+	get: function() {
+		return authArgs;
+	}
+});
+Object.defineProperty(exports, "bytesToBigIntLE", {
+	enumerable: true,
+	get: function() {
+		return bytesToBigIntLE;
+	}
+});
+Object.defineProperty(exports, "randomJubjubScalar", {
+	enumerable: true,
+	get: function() {
+		return randomJubjubScalar;
+	}
+});

package/dist/signer-DGluibtn.js

@@ -0,0 +1,92 @@
+import { a as pureCircuits } from "./acc-module-Cmj8EsIb.js";
+//#region ../../packages/module/passport-account/src/acc/signer.ts
+/** Order of the JubJub prime-order subgroup, the Schnorr scalar field. */
+const JUBJUB_R = BigInt("0x0e7db4ea6533afa906673b0101343b00a6682093ccc81082d0970e5ed6f72cb7");
+/** Uniform scalar in [1, JUBJUB_R), by rejection sampling. */
+const randomJubjubScalar = () => {
+	for (;;) {
+		const candidate = [...crypto.getRandomValues(new Uint8Array(32))].reduce((value, byte) => value << 8n | BigInt(byte), 0n);
+		if (candidate > 0n && candidate < JUBJUB_R) return candidate;
+	}
+};
+/**
+* Little-endian integer interpretation of a hash, the reading the Account
+* Custody Contract applies when it compares a ground challenge against
+* JUBJUB_R.
+*/
+const bytesToBigIntLE = (bytes) => {
+	let result = 0n;
+	for (let index = bytes.length - 1; index >= 0; index--) result = result << 8n | BigInt(bytes[index]);
+	return result;
+};
+/**
+* A JubJub Schnorr device key for the Account Custody Contract's jubjub
+* authorisation arm. The key is an independent scalar, never derived from
+* a seed shared with any other device. All curve and hash operations go
+* through the contract's own exported pure circuits, so the device
+* inherits the compiler's field-aligned encoding bit-exactly.
+*/
+var JubjubDevice = class JubjubDevice {
+	pk;
+	constructor(sk) {
+		this.sk = sk;
+		this.pk = pureCircuits.compute_public_point_with_jubjub(sk);
+	}
+	static generate() {
+		return new JubjubDevice(randomJubjubScalar());
+	}
+	/** The device's rolling entry at a given account, epoch, and counter. */
+	entryAt(contractAddress, epoch, counter) {
+		return pureCircuits.derive_device_entry_with_jubjub({ bytes: contractAddress }, this.pk, epoch, counter);
+	}
+	/** The boot commitment binding this device's key to a boot salt. */
+	bootCommitment(salt) {
+		return pureCircuits.derive_boot_commitment_with_jubjub(salt, this.pk);
+	}
+	/**
+	* Schnorr-signs the call the builder describes. Computes the
+	* announcement R = nonce * G, grinds the challenge hash by incrementing
+	* the grind nonce until its little-endian value falls below JUBJUB_R,
+	* then closes with s = nonce + challenge * sk mod JUBJUB_R.
+	*
+	* `useCounter` is carried alongside for the contract's anti-replay entry
+	* consumption; it is bound by the consumed entry, not the challenge.
+	* `nonce` defaults to a fresh uniform scalar and must never repeat
+	* across signatures, or the secret key leaks.
+	*/
+	sign(challenge, useCounter, nonce = randomJubjubScalar()) {
+		const sigR = pureCircuits.compute_public_point_with_jubjub(nonce);
+		let grindNonce = 0n;
+		let challengeScalar;
+		for (;;) {
+			const hash = bytesToBigIntLE(challenge(sigR, grindNonce));
+			if (hash < JUBJUB_R) {
+				challengeScalar = hash;
+				break;
+			}
+			grindNonce++;
+		}
+		const sigS = (nonce + challengeScalar % JUBJUB_R * (this.sk % JUBJUB_R) % JUBJUB_R) % JUBJUB_R;
+		return {
+			scheme: "jubjub-schnorr",
+			pk: this.pk,
+			useCounter,
+			sigR,
+			sigS,
+			grindNonce
+		};
+	}
+};
+/**
+* The trailing circuit arguments an Authorisation expands to, in the order
+* the jubjub-gated circuits declare them after their own arguments.
+*/
+const authArgs = (authorisation) => [
+	authorisation.pk,
+	authorisation.useCounter,
+	authorisation.sigR,
+	authorisation.sigS,
+	authorisation.grindNonce
+];
+//#endregion
+export { randomJubjubScalar as a, bytesToBigIntLE as i, JubjubDevice as n, authArgs as r, JUBJUB_R as t };

package/dist/signer-RqB5pu3K.js

@@ -0,0 +1,2 @@
+import { a as randomJubjubScalar, i as bytesToBigIntLE, n as JubjubDevice, r as authArgs, t as JUBJUB_R } from "./signer-DGluibtn.js";
+export { JUBJUB_R, JubjubDevice, authArgs, bytesToBigIntLE, randomJubjubScalar };