@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/sign-bitcoin-transaction-with-seed-C7vq9om8.js

@@ -0,0 +1,147 @@
+import { a as __toESM } from "./chunk-D6g4UhsZ.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { c as require_dist, o as tweakTaprootPrivateKey, t as AddressType, u as require_src } from "./address-OxwXIwbF.js";
+import { n as deriveAccountRootKeyPair, r as deriveChildKeyPair } from "./keyDerivation-QGesIMbS.js";
+import { n as HexBytes } from "./bytes.vo-CziaOsba.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-Ds1dwzan.cjs

@@ -0,0 +1,158 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_address = require("./address-lECYBd9-.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_keyDerivation = require("./keyDerivation-DcKRUCVh.cjs");
+//#region ../../packages/module/blockchain-bitcoin/src/common/transaction.ts
+var import_src = /* @__PURE__ */ require_chunk.__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_chunk.__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--2I6poMD.js

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

package/dist/signer-CX21Ups_.cjs

@@ -0,0 +1,121 @@
+const require_acc_module = require("./acc-module-NL_8mEHH.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-Cnn9q9oY.js

@@ -0,0 +1,92 @@
+import { a as pureCircuits } from "./acc-module-ur8CkBd1.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-DbSxjk0F.cjs

@@ -0,0 +1,7 @@
+require("./chunk-9hOWP6kD.cjs");
+const require_signer = require("./signer-CX21Ups_.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-factory-B5oFuUZ-.cjs

@@ -0,0 +1,130 @@
+require("./chunk-9hOWP6kD.cjs");
+require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_bignum_vo = require("./bignum.vo-Du-bpvar.cjs");
+const require_types = require("./types-BhzypKMS.cjs");
+const require_const = require("./const-DgBzKfz6.cjs");
+const require_utils = require("./utils-Du0YXRcU.cjs");
+const require_midnight_wallet = require("./midnight-wallet-BOdFD6SX.cjs");
+const require_dist = require("./dist-Br0OVXKt.cjs");
+const require_send_proof_progress = require("./send-proof-progress-DtAcrMP6.cjs");
+let rxjs = require("rxjs");
+let _midnight_ntwrk_ledger_v8 = require("@midnight-ntwrk/ledger-v8");
+//#region ../../packages/module/midnight-sync/src/signing/midnight-in-memory-data-signer.ts
+/** Signs arbitrary data using the Midnight unshielded key. No per-request auth needed —
+*  the wallet SDK manages key lifecycle via AccountKeyManager idle timeout. */
+var MidnightInMemoryDataSigner = class {
+	#accountId;
+	#wallets$;
+	constructor(accountId, wallets$) {
+		this.#accountId = accountId;
+		this.#wallets$ = wallets$;
+	}
+	signData(request) {
+		return this.#wallets$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)((wallets) => {
+			const wallet = wallets[this.#accountId];
+			if (!wallet) throw new Error(`Could not load midnight wallet for account ${this.#accountId}`);
+			return wallet.signData(request.data).pipe((0, rxjs.map)(({ signature, verifyingKey }) => ({
+				signature: require_bytes_vo.HexBytes(signature),
+				verifyingKey: require_bytes_vo.HexBytes(verifyingKey)
+			})));
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/signing/midnight-in-memory-transaction-signer.ts
+/**
+* Maps the serialized transfers into the facade's combined-transfer shape.
+* Every transfer shares one kind — mixed selections are rejected at build
+* time by flattenTransfers — so exactly one CombinedTokenTransfer entry is
+* built, holding all outputs; the SDK covers them in a single transaction.
+*/
+const toOutputs = ({ transfers }, networkId) => {
+	if (transfers[0].tokenKind === "unshielded") return [{
+		type: "unshielded",
+		outputs: transfers.map(({ amount, receiverAddress, type }) => ({
+			type: require_utils.fromUnshieldedTokenType(type, networkId),
+			receiverAddress: require_dist.UnshieldedAddress.codec.decode(networkId, require_dist.MidnightBech32m.parse(receiverAddress)),
+			amount: require_bignum_vo.BigNumber.valueOf(amount)
+		}))
+	}];
+	return [{
+		type: "shielded",
+		outputs: transfers.map(({ amount, receiverAddress, type }) => ({
+			type,
+			receiverAddress: require_dist.ShieldedAddress.codec.decode(networkId, require_dist.MidnightBech32m.parse(receiverAddress)),
+			amount: require_bignum_vo.BigNumber.valueOf(amount)
+		}))
+	}];
+};
+const signWithWallet = (midnightWallet, request, onProgress) => {
+	const txParams = JSON.parse(require_bytes_vo.HexBytes.toUTF8(request.serializedTx));
+	const outputs = request.flowType === "dust-designation" ? [] : toOutputs(txParams, midnightWallet.networkId);
+	const hasUnshieldedTransfer = txParams.transfers[0].tokenKind === "unshielded";
+	const ttl = new Date(Date.now() + require_const.defaultTxTtlLength);
+	if (request.flowType === "dust-designation") {
+		const dustAddress = require_dist.DustAddress.codec.decode(midnightWallet.networkId, require_dist.MidnightBech32m.parse(txParams.transfers[0].receiverAddress));
+		return midnightWallet.state().pipe((0, rxjs.take)(1), (0, rxjs.map)(({ unshielded: { availableCoins } }) => availableCoins.filter(({ utxo: { type } }) => type === (0, _midnight_ntwrk_ledger_v8.nativeToken)().raw)), (0, rxjs.switchMap)((availableNightCoins) => {
+			if (availableNightCoins.some((coin) => coin.meta.registeredForDustGeneration)) return midnightWallet.registerNightUtxosForDustGeneration(availableNightCoins, dustAddress).pipe((0, rxjs.switchMap)((unprovenTxRecipe) => midnightWallet.balanceUnprovenTransaction(unprovenTxRecipe.transaction, {
+				ttl,
+				tokenKindsToBalance: ["dust"]
+			})));
+			return midnightWallet.registerNightUtxosForDustGeneration(availableNightCoins, dustAddress);
+		}), (0, rxjs.switchMap)((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), (0, rxjs.map)((transaction) => ({ serializedTx: require_bytes_vo.HexBytes.fromByteArray(transaction.serialize()) })));
+	}
+	if (hasUnshieldedTransfer) return midnightWallet.transferTransaction(outputs, { ttl }).pipe((0, rxjs.switchMap)((recipe) => midnightWallet.signRecipe(recipe)), (0, rxjs.switchMap)((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), (0, rxjs.map)((transaction) => ({ serializedTx: require_bytes_vo.HexBytes.fromByteArray(transaction.serialize()) })));
+	return midnightWallet.transferTransaction(outputs, { ttl }).pipe((0, rxjs.switchMap)((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), (0, rxjs.map)((transaction) => ({ serializedTx: require_bytes_vo.HexBytes.fromByteArray(transaction.serialize()) })));
+};
+/** Signs Midnight transactions using the wallet SDK after user authentication. */
+var MidnightInMemoryTransactionSigner = class {
+	#accountId;
+	#auth;
+	#wallets$;
+	constructor(params) {
+		this.#accountId = params.accountId;
+		this.#auth = params.auth;
+		this.#wallets$ = params.wallets$;
+	}
+	sign(request) {
+		return (0, rxjs.defer)(() => {
+			const onProgress = require_send_proof_progress.beginSendProofProgress(this.#accountId);
+			return this.#auth.authenticate().pipe((0, rxjs.switchMap)((confirmed) => {
+				if (!confirmed) return (0, rxjs.throwError)(() => new require_types.AuthenticationCancelledError());
+				return this.#wallets$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)((wallets) => {
+					const midnightWallet = wallets[this.#accountId];
+					if (!midnightWallet) throw new Error(`Could not load midnight wallet for account ${this.#accountId}`);
+					return signWithWallet(midnightWallet, request, onProgress);
+				}));
+			}));
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/signing/midnight-in-memory-signer-factory.ts
+var MidnightInMemorySignerFactory = class {
+	constructor(wallets$) {
+		this.wallets$ = wallets$;
+	}
+	canSign(account) {
+		return account.accountType === "InMemory" && account.blockchainName === "Midnight";
+	}
+	createTransactionSigner(context) {
+		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
+		if (!account || !this.canSign(account)) throw new Error(`MidnightInMemorySignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
+		return new MidnightInMemoryTransactionSigner({
+			accountId: context.accountId,
+			auth: context.auth,
+			wallets$: this.wallets$
+		});
+	}
+	createDataSigner(context) {
+		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
+		if (!account || !this.canSign(account)) throw new Error(`MidnightInMemorySignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
+		return new MidnightInMemoryDataSigner(context.accountId, this.wallets$);
+	}
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/exported-modules/signer-factory.ts
+const initSignerFactory = ({ runtime }) => new MidnightInMemorySignerFactory(require_midnight_wallet.midnightWalletsForRuntime(runtime));
+//#endregion
+exports.default = initSignerFactory;