@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/signer-factory-BA7WFJVZ.js

@@ -1,282 +0,0 @@
-import { a as __toESM } from "./rolldown-runtime-OvD0k9op.js";
-import "./_web-crypto-random-bytes-Bo-GTcRS.js";
-import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
-import "./libsodium-wrappers-BhbOA8dQ.js";
-import "./codecs-Dc1Krpbt.js";
-import { t as SecretBox } from "./secret-box-DUR0ACYz.js";
-import { c as require_dist, l as require_src, s as BitcoinNetworkId, t as AddressType } from "./address-B9ntKL8K.js";
-import "./safe-buffer-B_vMqJWU.js";
-import { n as deriveAccountRootKeyPair, r as deriveChildKeyPair, t as ChainType } from "./keyDerivation-D3k9XyHg.js";
-import "./browser-B1eMbDwh.js";
-import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
-import { t as Redacted } from "./redacted-BmE2aXqr.js";
-import { t as AuthenticationCancelledError } from "./types-CJT6XF2c.js";
-import { n as BitcoinNetwork } from "./types-B8uiJn-X.js";
-import { t as signBitcoinTransactionWithSeed } from "./sign-bitcoin-transaction-with-seed-D4z62-jV.js";
-import { from, switchMap, throwError } from "rxjs";
-//#region ../../packages/module/blockchain-bitcoin/src/signing/varint.ts
-var import_dist = /* @__PURE__ */ __toESM(require_dist());
-var import_src = /* @__PURE__ */ __toESM(require_src());
-init__polyfill_buffer_patch();
-/** Encodes a length as a Bitcoin varint. */
-const varint = (length) => {
-	if (length < 253) return import_buffer.Buffer.from([length]);
-	if (length <= 65535) {
-		const buffer = import_buffer.Buffer.alloc(3);
-		buffer[0] = 253;
-		buffer.writeUInt16LE(length, 1);
-		return buffer;
-	}
-	const buffer = import_buffer.Buffer.alloc(5);
-	buffer[0] = 254;
-	buffer.writeUInt32LE(length, 1);
-	return buffer;
-};
-/** Encodes a string as its varint byte length followed by its UTF-8 bytes. */
-const varstr = (text) => {
-	const bytes = import_buffer.Buffer.from(text, "utf8");
-	return import_buffer.Buffer.concat([varint(bytes.length), bytes]);
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/signing/bip137-sign-message.ts
-init__polyfill_buffer_patch();
-const MESSAGE_MAGIC = "Bitcoin Signed Message:\n";
-/**
-* Header base for the compact signature: 27 + 4. The +4 marks a compressed
-* public key, giving the 31-34 header range that Unisat and Electrum emit
-* for segwit addresses. BIP-137's bech32 range (39-42) is deliberately not
-* used because many verifiers reject it.
-*/
-const COMPRESSED_HEADER_BASE = 31;
-/**
-* Computes the Bitcoin signed-message digest:
-* `sha256d(varstr("Bitcoin Signed Message:\n") || varstr(message))`.
-*/
-const magicHash = (message) => import_src.crypto.hash256(import_buffer.Buffer.concat([varstr(MESSAGE_MAGIC), varstr(message)]));
-/**
-* Signs a message using the BIP-137 compact recoverable ECDSA scheme.
-*
-* Signs the magic hash of the message with RFC 6979 deterministic ECDSA and
-* returns the hex-encoded 65-byte compact signature header || r || s, where
-* header = 27 + recoveryId + 4 (compressed public key).
-*/
-const bip137SignMessage = (params, request) => {
-	const digest = magicHash(request.message);
-	const { signature, recoveryId } = import_dist.signRecoverable(new Uint8Array(digest), new Uint8Array(params.privateKey));
-	return { signature: HexBytes(import_buffer.Buffer.concat([import_buffer.Buffer.from([COMPRESSED_HEADER_BASE + recoveryId]), import_buffer.Buffer.from(signature)]).toString("hex")) };
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/signing/bip322-sign-data.ts
-init__polyfill_buffer_patch();
-import_src.initEccLib(import_dist);
-const BIP322_TAG = "BIP0322-signed-message";
-/**
-* Computes the BIP-322 tagged message hash.
-*
-* Uses BIP-340 tagged hashing: SHA256(SHA256(tag) || SHA256(tag) || message).
-*/
-const bip322MessageHash = (message) => {
-	const tagHash = import_src.crypto.sha256(import_buffer.Buffer.from(BIP322_TAG, "utf8"));
-	const prefix = import_buffer.Buffer.concat([tagHash, tagHash]);
-	return import_src.crypto.sha256(import_buffer.Buffer.concat([prefix, import_buffer.Buffer.from(message, "utf8")]));
-};
-/**
-* Builds the BIP-322 virtual "to_spend" transaction.
-*
-* This transaction embeds the message hash in its scriptSig and the
-* signing address's scriptPubKey as its output. It is never broadcast —
-* it exists only to create a spendable output for the "to_sign" transaction.
-*/
-const buildToSpend = (messageHash, outputScript) => {
-	const tx = new import_src.Transaction();
-	tx.version = 0;
-	tx.locktime = 0;
-	tx.addInput(import_buffer.Buffer.alloc(32, 0), 4294967295, 0, import_buffer.Buffer.concat([import_buffer.Buffer.from([0, 32]), messageHash]));
-	tx.addOutput(outputScript, 0);
-	return tx;
-};
-/**
-* Serializes a witness stack into the BIP-322 Simple proof format.
-*
-* Format: varint(item_count) (varint(item_length) item_bytes)*
-* For P2WPKH: 2 items, an ECDSA signature with SIGHASH_ALL and the compressed
-* public key.
-*/
-const serializeWitness = (witness) => {
-	const parts = [varint(witness.length)];
-	for (const item of witness) parts.push(varint(item.length), item);
-	return import_buffer.Buffer.concat(parts);
-};
-/**
-* Signs a message using BIP-322 Generic Signed Message Format (P2WPKH Simple proof).
-*
-* Constructs the virtual to_spend/to_sign transaction pair per BIP-322,
-* signs with the provided key using BIP-143 segwit v0 digest, and returns
-* the serialized witness stack as a hex-encoded string.
-*/
-const bip322SignData = (params, request) => {
-	const { privateKey, publicKey, network } = params;
-	const messageHash = bip322MessageHash(request.message);
-	const outputScript = import_src.address.toOutputScript(request.address, network);
-	const toSpend = buildToSpend(messageHash, outputScript);
-	const psbt = new import_src.Psbt({ network });
-	psbt.setVersion(0);
-	psbt.setLocktime(0);
-	psbt.addInput({
-		hash: toSpend.getHash(),
-		index: 0,
-		sequence: 0,
-		witnessUtxo: {
-			script: outputScript,
-			value: 0
-		}
-	});
-	psbt.addOutput({
-		script: import_buffer.Buffer.from([106]),
-		value: 0
-	});
-	const signer = {
-		publicKey,
-		sign: (hash) => import_buffer.Buffer.from(import_dist.sign(new Uint8Array(hash), new Uint8Array(privateKey)))
-	};
-	psbt.signInput(0, signer);
-	psbt.finalizeInput(0);
-	const witness = psbt.extractTransaction().ins[0].witness;
-	return { signature: HexBytes(serializeWitness(witness).toString("hex")) };
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/signing/bitcoin-in-memory-data-signer.ts
-init__polyfill_buffer_patch();
-/**
-* Signs arbitrary messages using BIP-137 compact recoverable ECDSA (the
-* default) or BIP-322 Generic Signed Message Format, selected by the
-* request's signatureType.
-*
-* Follows the same authentication and key derivation pattern as
-* BitcoinInMemoryTransactionSigner: triggers user authentication,
-* decrypts the root private key, derives the P2WPKH signing key,
-* and produces the requested proof.
-*/
-var BitcoinInMemoryDataSigner = class {
-	#encryptedRootPrivateKey;
-	#auth;
-	#network;
-	#accountIndex;
-	constructor(props) {
-		this.#encryptedRootPrivateKey = props.encryptedRootPrivateKey;
-		this.#auth = props.auth;
-		this.#network = props.network;
-		this.#accountIndex = props.accountIndex;
-	}
-	signData(request) {
-		return this.#auth.authenticate().pipe(switchMap((confirmed) => {
-			if (!confirmed) return throwError(() => new AuthenticationCancelledError());
-			return this.#auth.accessAuthSecret((authSecret) => from(this.#signData(authSecret, request)));
-		}));
-	}
-	async #signData(authSecret, request) {
-		let rootPrivateKey = null;
-		try {
-			const encryptedSeed = import_buffer.Buffer.from(this.#encryptedRootPrivateKey, "hex");
-			const decryptedBytes = await SecretBox.open(encryptedSeed, authSecret);
-			rootPrivateKey = Redacted.make(import_buffer.Buffer.from(decryptedBytes));
-			const childKeyPair = deriveChildKeyPair(deriveAccountRootKeyPair({
-				seed: Redacted.value(rootPrivateKey),
-				addressType: AddressType.NativeSegWit,
-				network: this.#network,
-				account: this.#accountIndex
-			}).pair.privateKey, ChainType.External, 0);
-			const bitcoinJsNetwork = this.#network === BitcoinNetwork.Mainnet ? import_src.networks.bitcoin : import_src.networks.testnet;
-			const derivedAddress = import_src.payments.p2wpkh({
-				pubkey: import_buffer.Buffer.from(childKeyPair.pair.publicKey, "hex"),
-				network: bitcoinJsNetwork
-			}).address;
-			if (derivedAddress !== request.address) throw new Error(`Address mismatch: requested ${request.address} but derived key produces ${derivedAddress}`);
-			const childPrivateKey = import_buffer.Buffer.from(childKeyPair.pair.privateKey, "hex");
-			try {
-				if (request.signatureType === "bip322-simple") return bip322SignData({
-					privateKey: childPrivateKey,
-					publicKey: import_buffer.Buffer.from(childKeyPair.pair.publicKey, "hex"),
-					network: bitcoinJsNetwork
-				}, request);
-				return bip137SignMessage({ privateKey: childPrivateKey }, request);
-			} finally {
-				childPrivateKey.fill(0);
-			}
-		} finally {
-			if (rootPrivateKey) Redacted.unsafeWipe(rootPrivateKey);
-		}
-	}
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/signing/bitcoin-in-memory-transaction-signer.ts
-init__polyfill_buffer_patch();
-/** Signs Bitcoin transactions using an in-memory wallet. */
-var BitcoinInMemoryTransactionSigner = class {
-	#encryptedRootPrivateKey;
-	#auth;
-	constructor(params) {
-		this.#encryptedRootPrivateKey = params.encryptedRootPrivateKey;
-		this.#auth = params.auth;
-	}
-	sign(request) {
-		return this.#auth.authenticate().pipe(switchMap((confirmed) => {
-			if (!confirmed) return throwError(() => new AuthenticationCancelledError());
-			return this.#auth.accessAuthSecret((authSecret) => from(this.#signTransaction(request.serializedTx, this.#encryptedRootPrivateKey, authSecret)));
-		}));
-	}
-	async #signTransaction(serializedTx, encryptedRootPrivateKey, authSecret) {
-		let rootPrivateKey = null;
-		try {
-			const encryptedSeed = import_buffer.Buffer.from(encryptedRootPrivateKey, "hex");
-			const decryptedBytes = await SecretBox.open(encryptedSeed, authSecret);
-			rootPrivateKey = Redacted.make(import_buffer.Buffer.from(decryptedBytes));
-			return signBitcoinTransactionWithSeed(serializedTx, Redacted.value(rootPrivateKey));
-		} finally {
-			if (rootPrivateKey) Redacted.unsafeWipe(rootPrivateKey);
-		}
-	}
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/signing/bitcoin-in-memory-signer-factory.ts
-var BitcoinInMemorySignerFactory = class {
-	canSign(account) {
-		return account.accountType === "InMemory" && account.blockchainName === "Bitcoin";
-	}
-	createTransactionSigner(context) {
-		this.#assertSupported(context);
-		return new BitcoinInMemoryTransactionSigner({
-			encryptedRootPrivateKey: this.#extractEncryptedRootPrivateKey(context),
-			auth: context.auth
-		});
-	}
-	createDataSigner(context) {
-		const account = this.#assertSupported(context);
-		const encryptedRootPrivateKey = this.#extractEncryptedRootPrivateKey(context);
-		const networkId = account.blockchainSpecific.networkId;
-		const network = networkId ? BitcoinNetworkId.getBitcoinNetwork(networkId) : void 0;
-		if (!network) throw new Error(`Cannot resolve Bitcoin network from networkId: ${String(networkId)}`);
-		return new BitcoinInMemoryDataSigner({
-			encryptedRootPrivateKey,
-			auth: context.auth,
-			network,
-			accountIndex: account.blockchainSpecific.accountIndex
-		});
-	}
-	#assertSupported(context) {
-		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
-		if (!account || !this.canSign(account)) throw new Error(`BitcoinInMemorySignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
-		return account;
-	}
-	#extractEncryptedRootPrivateKey(context) {
-		const { wallet } = context;
-		const encryptedRootPrivateKey = wallet.blockchainSpecific.Bitcoin?.encryptedRootPrivateKey;
-		if (!encryptedRootPrivateKey) throw new Error("Wallet is missing Bitcoin encrypted root private key");
-		return encryptedRootPrivateKey;
-	}
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/exposed-modules/signer-factory.ts
-const initSignerFactory = () => new BitcoinInMemorySignerFactory();
-//#endregion
-export { initSignerFactory as default };

package/dist/signer-factory-CORIG4Yl.cjs

@@ -1,130 +0,0 @@
-require("./rolldown-runtime-Br2OG8yv.cjs");
-require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
-const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
-const require_bignum_vo = require("./bignum.vo-hx2kuqlA.cjs");
-const require_types = require("./types-DWbVZpnF.cjs");
-const require_const = require("./const-DLrX5SD9.cjs");
-const require_utils = require("./utils-BfMdr_1w.cjs");
-const require_midnight_wallet = require("./midnight-wallet-XTZc2li7.cjs");
-const require_dist = require("./dist-BtIq4XFn.cjs");
-const require_send_proof_progress = require("./send-proof-progress-dDoqIohG.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;

package/dist/signer-factory-Cd2TwD50.js

@@ -1,129 +0,0 @@
-import "./_polyfill-buffer-patch-yNxN4d5E.js";
-import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
-import { t as BigNumber } from "./bignum.vo-CEXOIew0.js";
-import { t as AuthenticationCancelledError } from "./types-CJT6XF2c.js";
-import { m as defaultTxTtlLength } from "./const-BfEnY8fg.js";
-import { i as fromUnshieldedTokenType } from "./utils-CvAW5Yw7.js";
-import { t as midnightWalletsForRuntime } from "./midnight-wallet-DIsAlSn6.js";
-import { t as beginSendProofProgress } from "./send-proof-progress-DTK3ZuYB.js";
-import { defer, map, switchMap, take, throwError } from "rxjs";
-import { DustAddress, MidnightBech32m, ShieldedAddress, UnshieldedAddress } from "@midnightntwrk/wallet-sdk-address-format";
-import { nativeToken } from "@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(take(1), 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(map(({ signature, verifyingKey }) => ({
-				signature: HexBytes(signature),
-				verifyingKey: 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: fromUnshieldedTokenType(type, networkId),
-			receiverAddress: UnshieldedAddress.codec.decode(networkId, MidnightBech32m.parse(receiverAddress)),
-			amount: BigNumber.valueOf(amount)
-		}))
-	}];
-	return [{
-		type: "shielded",
-		outputs: transfers.map(({ amount, receiverAddress, type }) => ({
-			type,
-			receiverAddress: ShieldedAddress.codec.decode(networkId, MidnightBech32m.parse(receiverAddress)),
-			amount: BigNumber.valueOf(amount)
-		}))
-	}];
-};
-const signWithWallet = (midnightWallet, request, onProgress) => {
-	const txParams = JSON.parse(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() + defaultTxTtlLength);
-	if (request.flowType === "dust-designation") {
-		const dustAddress = DustAddress.codec.decode(midnightWallet.networkId, MidnightBech32m.parse(txParams.transfers[0].receiverAddress));
-		return midnightWallet.state().pipe(take(1), map(({ unshielded: { availableCoins } }) => availableCoins.filter(({ utxo: { type } }) => type === nativeToken().raw)), switchMap((availableNightCoins) => {
-			if (availableNightCoins.some((coin) => coin.meta.registeredForDustGeneration)) return midnightWallet.registerNightUtxosForDustGeneration(availableNightCoins, dustAddress).pipe(switchMap((unprovenTxRecipe) => midnightWallet.balanceUnprovenTransaction(unprovenTxRecipe.transaction, {
-				ttl,
-				tokenKindsToBalance: ["dust"]
-			})));
-			return midnightWallet.registerNightUtxosForDustGeneration(availableNightCoins, dustAddress);
-		}), switchMap((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), map((transaction) => ({ serializedTx: HexBytes.fromByteArray(transaction.serialize()) })));
-	}
-	if (hasUnshieldedTransfer) return midnightWallet.transferTransaction(outputs, { ttl }).pipe(switchMap((recipe) => midnightWallet.signRecipe(recipe)), switchMap((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), map((transaction) => ({ serializedTx: HexBytes.fromByteArray(transaction.serialize()) })));
-	return midnightWallet.transferTransaction(outputs, { ttl }).pipe(switchMap((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), map((transaction) => ({ serializedTx: 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 defer(() => {
-			const onProgress = beginSendProofProgress(this.#accountId);
-			return this.#auth.authenticate().pipe(switchMap((confirmed) => {
-				if (!confirmed) return throwError(() => new AuthenticationCancelledError());
-				return this.#wallets$.pipe(take(1), 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(midnightWalletsForRuntime(runtime));
-//#endregion
-export { initSignerFactory as default };