@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/signer-factory-DhZiE03y.cjs

@@ -0,0 +1,149 @@
+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-BsnjG2_Q.cjs");
+const require_utils = require("./utils-IXxR-Djh.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-vmsaSfbz.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, { accountId, onProgress }) => {
+	onProgress({
+		type: "phase",
+		phase: "transaction-preparing",
+		status: "started"
+	});
+	const serialize = (transaction) => {
+		const txId = transaction.identifiers().at(-1);
+		if (txId) require_send_proof_progress.trackSendSubmission(accountId, txId, onProgress);
+		return { serializedTx: require_bytes_vo.HexBytes.fromByteArray(transaction.serialize()) };
+	};
+	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)(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)(serialize));
+	return midnightWallet.transferTransaction(outputs, { ttl }).pipe((0, rxjs.switchMap)((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), (0, rxjs.map)(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, {
+						accountId: this.#accountId,
+						onProgress
+					});
+				}));
+			}), (0, rxjs.tap)({ error: () => {
+				onProgress({
+					type: "phase",
+					phase: "transaction-failed",
+					status: "failed"
+				});
+			} }));
+		});
+	}
+};
+//#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-BWGUmnvm.cjs → signer-factory-Ds6G2AZk.cjs}

@@ -1,7 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-require("./_polyfill-buffer-patch-BnPVerlG.cjs");
-require("./util-CGzqQ8IV.cjs");
-const require_guarded_transaction_signer = require("./guarded-transaction-signer-Bxl6_XNd.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+require("./util-Bu4W5lF4.cjs");
+const require_guarded_transaction_signer = require("./guarded-transaction-signer-MFpPg98D.cjs");
 let rxjs = require("rxjs");
 //#region ../../packages/module/blockchain-cardano/src/signing/cardano-in-memory-signer-factory.ts
 /**

package/dist/signer-factory-hzSRaIw2.js

@@ -0,0 +1,148 @@
+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-D0CbQlo4.js";
+import { i as fromUnshieldedTokenType } from "./utils-DFwzEvbv.js";
+import { t as midnightWalletsForRuntime } from "./midnight-wallet-DIsAlSn6.js";
+import { r as trackSendSubmission, t as beginSendProofProgress } from "./send-proof-progress-C-ljq1x5.js";
+import { defer, map, switchMap, take, tap, 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, { accountId, onProgress }) => {
+	onProgress({
+		type: "phase",
+		phase: "transaction-preparing",
+		status: "started"
+	});
+	const serialize = (transaction) => {
+		const txId = transaction.identifiers().at(-1);
+		if (txId) trackSendSubmission(accountId, txId, onProgress);
+		return { serializedTx: HexBytes.fromByteArray(transaction.serialize()) };
+	};
+	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(serialize));
+	}
+	if (hasUnshieldedTransfer) return midnightWallet.transferTransaction(outputs, { ttl }).pipe(switchMap((recipe) => midnightWallet.signRecipe(recipe)), switchMap((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), map(serialize));
+	return midnightWallet.transferTransaction(outputs, { ttl }).pipe(switchMap((signedRecipe) => midnightWallet.finalizeRecipe(signedRecipe, onProgress)), map(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, {
+						accountId: this.#accountId,
+						onProgress
+					});
+				}));
+			}), tap({ error: () => {
+				onProgress({
+					type: "phase",
+					phase: "transaction-failed",
+					status: "failed"
+				});
+			} }));
+		});
+	}
+};
+//#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 };

package/dist/{slice-CuHUaPZx.cjs → slice-7G2xxYKJ.cjs}

@@ -1,7 +1,7 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util_selector = require("./util-selector-BcAncU4L.cjs");
-const require_reselect = require("./reselect-CRDqmQY9.cjs");
-const require_lace_context = require("./lace-context-fJTDghdp.cjs");
+const require_util_selector = require("./util-selector-BWPH68_l.cjs");
+const require_reselect = require("./reselect-Bd94u0K-.cjs");
+const require_lace_context = require("./lace-context-DgR6vLli.cjs");
 let _reduxjs_toolkit = require("@reduxjs/toolkit");
 let lodash_isEqual = require("lodash/isEqual.js");
 lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);

package/dist/{slice-DZmQJNV8.cjs → slice-B4CdYoPu.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util_selector = require("./util-selector-BcAncU4L.cjs");
-const require_reselect = require("./reselect-CRDqmQY9.cjs");
+const require_util_selector = require("./util-selector-BWPH68_l.cjs");
+const require_reselect = require("./reselect-Bd94u0K-.cjs");
 //#region ../../packages/contract/failures/src/store/slice.ts
 const slice = (0, require("@reduxjs/toolkit").createSlice)({
 	name: "failures",