@midnightntwrk/wallet-sdk-facade 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { type DefaultProvingConfiguration, type ProvingService, type UnboundTran
 import { type DefaultDustConfiguration, type DustWalletAPI, type DustWalletState } from '@midnightntwrk/wallet-sdk-dust-wallet';
 import { type AnyTransaction, type CoinsAndBalances as DustCoinsAndBalances } from '@midnightntwrk/wallet-sdk-dust-wallet/v1';
 import { type DefaultShieldedConfiguration, type ShieldedWalletAPI, type ShieldedWalletState } from '@midnightntwrk/wallet-sdk-shielded';
-import type { DefaultUnshieldedConfiguration, UnshieldedWalletAPI } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
+import type { DefaultUnshieldedConfiguration, SignSegment, UnshieldedWalletAPI } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
 import { type UnshieldedWalletState } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
 import { Clock } from '@midnightntwrk/wallet-sdk-utilities';
 import { Schema } from 'effect';
@@ -14,10 +14,33 @@ import { type DefaultPendingTransactionsServiceConfiguration, PendingTransaction
 import { type BlockData, type BlockDataFetcher, type ValidateTxOptions, ValidationFetchError, type ValidationService, WellFormedError, type WellFormedStrictnessFlags } from '@midnightntwrk/wallet-sdk-capabilities/validation';
 import { type DustAddress, type ShieldedAddress, type UnshieldedAddress } from '@midnightntwrk/wallet-sdk-address-format';
 /**
- * Full entry schema for transaction history — common fields + all wallet sections. Pass this to
- * `InMemoryTransactionHistoryStorage` to enable serialize/restore.
+ * Full entry schema for transaction history. The common entry data and wallet-specific sections (`shielded`,
+ * `unshielded`, `dust`) live on every entry regardless of lifecycle; the `lifecycle` field is the only discriminator.
+ * Pass this to `InMemoryTransactionHistoryStorage` to enable serialize/restore.
  */
-export declare const WalletEntrySchema: Schema.Struct<{
+export declare const WalletEntrySchema: Schema.Struct<Readonly<{
+    hash: typeof Schema.String;
+    identifiers: Schema.Array$<typeof Schema.String>;
+    protocolVersion: Schema.optional<typeof Schema.Number>;
+    status: Schema.optional<Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>>;
+    timestamp: Schema.optional<typeof Schema.Date>;
+    fees: Schema.optional<Schema.NullOr<typeof Schema.BigInt>>;
+    lifecycle: Schema.Union<[Schema.Struct<{
+        status: Schema.Literal<["pending"]>;
+        submittedAt: typeof Schema.Date;
+    }>, Schema.Struct<{
+        status: Schema.Literal<["finalized"]>;
+        finalizedBlock: Schema.Struct<{
+            hash: typeof Schema.String;
+            height: typeof Schema.Number;
+            timestamp: typeof Schema.Date;
+        }>;
+    }>, Schema.Struct<{
+        status: Schema.Literal<["rejected"]>;
+        rejectedAt: typeof Schema.Date;
+        reason: Schema.optional<typeof Schema.String>;
+    }>]>;
+}> & {
     shielded: Schema.optional<Schema.Struct<{
         receivedCoins: Schema.Array$<Schema.Struct<{
             type: typeof Schema.String;
@@ -65,15 +88,19 @@ export declare const WalletEntrySchema: Schema.Struct<{
             mtIndex: typeof Schema.BigInt;
         }>>;
     }>>;
-    hash: typeof Schema.String;
-    protocolVersion: typeof Schema.Number;
-    status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
-    identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    timestamp: Schema.optional<typeof Schema.Date>;
-    fees: Schema.optional<Schema.NullOr<typeof Schema.BigInt>>;
 }>;
 export type WalletEntry = Schema.Schema.Type<typeof WalletEntrySchema>;
-export declare const mergeWalletEntries: (existing: WalletEntry, incoming: WalletEntry) => WalletEntry;
+/** A `WalletEntry` whose lifecycle is `pending`. */
+export type PendingWalletEntry = WalletEntry & {
+    readonly lifecycle: TransactionHistoryStorage.PendingLifecycle;
+};
+/** A `WalletEntry` whose lifecycle is `finalized`. */
+export type FinalizedWalletEntry = WalletEntry & {
+    readonly lifecycle: TransactionHistoryStorage.FinalizedLifecycle;
+};
+export declare const isPendingWalletEntry: (entry: WalletEntry) => entry is PendingWalletEntry;
+export declare const isFinalizedWalletEntry: (entry: WalletEntry) => entry is FinalizedWalletEntry;
+export declare function mergeWalletEntries(existing: WalletEntry, incoming: WalletEntry): WalletEntry;
 type TokenKind = 'dust' | 'shielded' | 'unshielded';
 type TokenKindsToBalance = 'all' | TokenKind[];
 declare const TokenKindsToBalance: {
@@ -152,6 +179,11 @@ export declare class FacadeState {
  * without a circular dependency.
  */
 export { Clock };
+/**
+ * The asynchronous signer callback used by every signing entry point. A `Promise`-returning callback so out-of-process
+ * signers (MPC, HSM) can be plugged in directly; an in-process keystore resolves immediately.
+ */
+export type { SignSegment };
 /**
  * The Terms and Conditions returned by the indexer, containing a URL for display and a SHA-256 hash for content
  * verification.
@@ -381,9 +413,9 @@ export declare class WalletFacade {
         tokenKindsToBalance?: TokenKindsToBalance;
     }): Promise<UnprovenTransactionRecipe>;
     finalizeRecipe(recipe: BalancingRecipe): Promise<ledger.FinalizedTransaction>;
-    signRecipe(recipe: BalancingRecipe, signSegment: (data: Uint8Array) => ledger.Signature): Promise<BalancingRecipe>;
-    signUnprovenTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
-    signUnboundTransaction(tx: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
+    signRecipe(recipe: BalancingRecipe, signSegment: SignSegment): Promise<BalancingRecipe>;
+    signUnprovenTransaction(tx: ledger.UnprovenTransaction, signSegment: SignSegment): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(tx: UnboundTransaction, signSegment: SignSegment): Promise<UnboundTransaction>;
     finalizeTransaction(tx: ledger.UnprovenTransaction): Promise<ledger.FinalizedTransaction>;
     /** Estimates the fee for the given transaction only. This lacks the fees of the balancing transaction. */
     calculateTransactionFee(tx: AnyTransaction): Promise<bigint>;
@@ -417,7 +449,7 @@ export declare class WalletFacade {
         ttl: Date;
         payFees?: boolean;
     }): Promise<UnprovenTransactionRecipe>;
-    registerNightUtxosForDustGeneration(nightUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature, dustReceiverAddress?: DustAddress): Promise<UnprovenTransactionRecipe>;
+    registerNightUtxosForDustGeneration(nightUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: SignSegment, dustReceiverAddress?: DustAddress): Promise<UnprovenTransactionRecipe>;
     /**
      * Waits until the dust projected to be generated by the given Night UTxOs reaches `requiredAmount`, re-checking every
      * second. Pair with {@link estimateRegistration} to pick `requiredAmount`, then call before
@@ -431,7 +463,7 @@ export declare class WalletFacade {
     waitForGeneratedDust(nightUtxos: readonly UtxoWithMeta[], requiredAmount: bigint, opts?: {
         timeoutMs?: number;
     }): Promise<void>;
-    deregisterFromDustGeneration(nightUtxos: UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature): Promise<UnprovenTransactionRecipe>;
+    deregisterFromDustGeneration(nightUtxos: UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: SignSegment): Promise<UnprovenTransactionRecipe>;
     revert(txOrRecipe: AnyTransaction | BalancingRecipe): Promise<void>;
     revertTransaction(tx: AnyTransaction): Promise<void>;
     start(shieldedSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey): Promise<void>;

package/dist/index.js

@@ -14,7 +14,7 @@ import * as ledger from '@midnightntwrk/ledger-v9';
 import { makeDefaultSubmissionService, } from '@midnightntwrk/wallet-sdk-capabilities';
 import { makeDefaultProvingService, } from '@midnightntwrk/wallet-sdk-capabilities/proving';
 import { ShieldedSectionSchema, mergeShieldedSections, } from '@midnightntwrk/wallet-sdk-shielded';
-import { UnshieldedSectionSchema } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
+import { UnshieldedSectionSchema, mergeUnshieldedSections, } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
 import { DustSectionSchema, mergeDustSections } from '@midnightntwrk/wallet-sdk-dust-wallet';
 import { Clock } from '@midnightntwrk/wallet-sdk-utilities';
 import { FetchTermsAndConditions as FetchTermsAndConditionsQuery } from '@midnightntwrk/wallet-sdk-indexer-client';
@@ -24,31 +24,81 @@ import { TransactionHistoryStorage } from '@midnightntwrk/wallet-sdk-abstraction
 import { combineLatest, map, firstValueFrom, concatMap } from 'rxjs';
 import { PendingTransactions, PendingTransactionsServiceImpl, } from '@midnightntwrk/wallet-sdk-capabilities';
 import { makeDefaultBlockDataFetcher, makeDefaultValidationService, ValidationFetchError, WellFormedError, } from '@midnightntwrk/wallet-sdk-capabilities/validation';
-import { finalizedTransactionTrait } from './transaction.js';
+import { finalizedTransactionTrait, txHistoryHash } from './transaction.js';
 /**
- * Full entry schema for transaction history — common fields + all wallet sections. Pass this to
- * `InMemoryTransactionHistoryStorage` to enable serialize/restore.
+ * Full entry schema for transaction history. The common entry data and wallet-specific sections (`shielded`,
+ * `unshielded`, `dust`) live on every entry regardless of lifecycle; the `lifecycle` field is the only discriminator.
+ * Pass this to `InMemoryTransactionHistoryStorage` to enable serialize/restore.
  */
-export const WalletEntrySchema = Schema.Struct({
-    ...TransactionHistoryStorage.TransactionHistoryCommonSchema.fields,
+export const WalletEntrySchema = TransactionHistoryStorage.extendEntrySchema({
     shielded: Schema.optional(ShieldedSectionSchema),
     unshielded: Schema.optional(UnshieldedSectionSchema),
     dust: Schema.optional(DustSectionSchema),
 });
-export const mergeWalletEntries = (existing, incoming) => ({
-    ...existing,
-    ...incoming,
-    ...(existing.shielded !== undefined && incoming.shielded !== undefined
-        ? { shielded: mergeShieldedSections(existing.shielded, incoming.shielded) }
-        : {}),
-    ...(existing.unshielded !== undefined && incoming.unshielded !== undefined
-        ? { unshielded: { ...existing.unshielded, ...incoming.unshielded } }
-        : {}),
-    ...(existing.dust !== undefined && incoming.dust !== undefined
-        ? { dust: mergeDustSections(existing.dust, incoming.dust) }
-        : {}),
+export const isPendingWalletEntry = (entry) => entry.lifecycle.status === 'pending';
+export const isFinalizedWalletEntry = (entry) => entry.lifecycle.status === 'finalized';
+/**
+ * Merge two wallet entries arriving under the same hash. Treats the entry as `T × lifecycle` per the storage model:
+ *
+ * - **Shared scalar facts about the tx** (`protocolVersion`, `status`, `timestamp`, `fees`) — first writer wins. Once any
+ *   wallet has set the value, later writes are no-ops for these fields. This is correct because the value is the same
+ *   across all wallets (it's a property of the on-chain tx, not the wallet's view of it).
+ * - **`identifiers`** — unioned (each wallet may surface a different identifier subset).
+ * - **`lifecycle`** — incoming wins (this is how `pending → finalized` transitions are recorded).
+ * - **Wallet sections** (`shielded`, `unshielded`, `dust`) — combined via per-section merge when both sides have them;
+ *   otherwise whichever side is present is used.
+ */
+/**
+ * Combine two optional values under a merge function: if both sides have it, delegate to `merge`; otherwise return
+ * whichever side is present (or `undefined` if neither). Encapsulates the four-way pattern used for every wallet
+ * section in {@link mergeWalletEntries}.
+ */
+const mergeOptionalSection = (existing, incoming, merge) => {
+    if (existing !== undefined && incoming !== undefined)
+        return merge(existing, incoming);
+    return existing ?? incoming;
+};
+export function mergeWalletEntries(existing, incoming) {
+    // identifiers: each wallet may surface a different subset, so union them
+    const identifiers = Array.from(new Set([...existing.identifiers, ...incoming.identifiers]));
+    // wallet sections: per-section merge when both sides have it; whichever side is present otherwise
+    const shielded = mergeOptionalSection(existing.shielded, incoming.shielded, mergeShieldedSections);
+    const unshielded = mergeOptionalSection(existing.unshielded, incoming.unshielded, mergeUnshieldedSections);
+    const dust = mergeOptionalSection(existing.dust, incoming.dust, mergeDustSections);
+    return {
+        hash: existing.hash,
+        identifiers,
+        // shared scalar facts about the on-chain tx — first writer wins (same value across all wallets)
+        protocolVersion: existing.protocolVersion ?? incoming.protocolVersion,
+        status: existing.status ?? incoming.status,
+        timestamp: existing.timestamp ?? incoming.timestamp,
+        fees: existing.fees ?? incoming.fees,
+        // lifecycle: incoming wins — this is how pending → finalized/rejected transitions are recorded
+        lifecycle: incoming.lifecycle,
+        ...(shielded !== undefined ? { shielded } : {}),
+        ...(unshielded !== undefined ? { unshielded } : {}),
+        ...(dust !== undefined ? { dust } : {}),
+    };
+}
+/**
+ * Storage key for a tx we're about to submit (record as pending). The hash comes from {@link txHistoryHash}, which the
+ * revert side uses too — so a tx keyed here while pending resolves to the same key when later confirmed or reverted.
+ */
+const submitTxHistoryKey = (tx) => ({
+    hash: txHistoryHash(tx),
+    identifiers: tx.identifiers(),
 });
-const isWalletEntry = Schema.is(WalletEntrySchema);
+/**
+ * Storage key for a tx we're about to revert (record as rejected). Shares {@link txHistoryHash} with the submit side so
+ * the rejected entry lands on the pending entry in place. Returns `undefined` only when the tx has no identifiers at
+ * all (nothing to revert).
+ */
+const revertTxHistoryKey = (tx) => {
+    const identifiers = tx.identifiers();
+    if (identifiers.length === 0)
+        return undefined;
+    return { hash: txHistoryHash(tx), identifiers };
+};
 const TokenKindsToBalance = new (class {
     allTokenKinds = ['shielded', 'unshielded', 'dust'];
     toFlags = (tokenKinds) => {
@@ -391,10 +441,15 @@ export class WalletFacade {
      * @throws {@link WellFormedError} — call {@link validateTransaction} first to get this error early.
      */
     async submitTransaction(tx) {
+        const identifiers = tx.identifiers();
         try {
             await this.pendingTransactionsService.addPendingTransaction(tx);
+            // Insert before awaiting submission so the entry exists while the tx is in flight — the per-wallet sync
+            // handlers' gotFinalized call clears the pending entry on confirmation.
+            const key = submitTxHistoryKey(tx);
+            await this.#txHistoryStorage.gotPending({ ...key, submittedAt: this.clock.now() });
             await this.submissionService.submitTransaction(tx, 'Finalized');
-            return tx.identifiers().at(-1);
+            return identifiers.at(-1);
         }
         catch (error) {
             await this.revert(tx);
@@ -594,7 +649,7 @@ export class WalletFacade {
         if (!intent || registrations.length === 0) {
             return tx;
         }
-        const signature = signSegment(intent.signatureData(1));
+        const signature = await signSegment(intent.signatureData(1));
         return await this.dust.addDustRegistrationSignature(tx, signature);
     }
     async signUnprovenTransaction(tx, signSegment) {
@@ -774,7 +829,13 @@ export class WalletFacade {
             this.shielded.revertTransaction(tx),
             this.unshielded.revertTransaction(tx),
             this.dust.revertTransaction(tx),
-        ]).then(() => this.pendingTransactionsService.clear(tx));
+        ]).then(async () => {
+            await this.pendingTransactionsService.clear(tx);
+            const key = revertTxHistoryKey(tx);
+            if (key !== undefined) {
+                await this.#txHistoryStorage.gotRejected({ ...key, rejectedAt: this.clock.now() });
+            }
+        });
     }
     async start(shieldedSecretKeys, dustSecretKey) {
         await Promise.all([
@@ -795,11 +856,10 @@ export class WalletFacade {
         ]);
     }
     async queryTxHistoryByHash(hash) {
-        const raw = await this.#txHistoryStorage.get(hash);
-        return raw && isWalletEntry(raw) ? raw : undefined;
+        return this.#txHistoryStorage.get(hash);
     }
     async getAllFromTxHistory() {
-        const allEntries = await this.#txHistoryStorage.getAll();
-        return [...allEntries];
+        const all = await this.#txHistoryStorage.getAll();
+        return [...all];
     }
 }

package/dist/transaction.d.ts

@@ -1,3 +1,21 @@
 import { type PendingTransactions } from '@midnightntwrk/wallet-sdk-capabilities';
 import * as ledger from '@midnightntwrk/ledger-v9';
+import { type AnyTransaction } from '@midnightntwrk/wallet-sdk-dust-wallet/v1';
+/**
+ * The key under which a transaction's history entry is stored.
+ *
+ * Prefer the ledger transaction hash — it's the canonical chain identifier and the value the indexer reports a
+ * confirmed tx under. `transactionHash()` is only defined for proven + signed + bound transactions, though; it throws
+ * for the other variants, notably the proof-erased transactions the simulator produces. In that case fall back to the
+ * hex of the tx's serialized bytes: `serialize()` is total over every variant (it's the same encoding used to submit
+ * the tx), so a key is always available — unlike `identifiers[0]`, which is an identifier, not a hash of the
+ * transaction.
+ *
+ * Both the submit (pending) and revert (rejected) sides route through this one function so they can never disagree on
+ * the key. The fallback is deterministic: the same transaction object yields the same bytes every time, and the
+ * auto-revert path reverts the very object it submitted, so the rejected entry lands on the pending entry in place.
+ * (Serialization differs across lifecycle states, so this is only stable for a fixed tx — which is exactly the
+ * submit→revert flow.)
+ */
+export declare const txHistoryHash: (tx: AnyTransaction) => string;
 export declare const finalizedTransactionTrait: PendingTransactions.TransactionTrait<ledger.FinalizedTransaction>;

package/dist/transaction.js

@@ -14,6 +14,30 @@
  */
 import { Array as Arr, DateTime, Duration, HashSet, Option, Order, pipe } from 'effect';
 import * as ledger from '@midnightntwrk/ledger-v9';
+/**
+ * The key under which a transaction's history entry is stored.
+ *
+ * Prefer the ledger transaction hash — it's the canonical chain identifier and the value the indexer reports a
+ * confirmed tx under. `transactionHash()` is only defined for proven + signed + bound transactions, though; it throws
+ * for the other variants, notably the proof-erased transactions the simulator produces. In that case fall back to the
+ * hex of the tx's serialized bytes: `serialize()` is total over every variant (it's the same encoding used to submit
+ * the tx), so a key is always available — unlike `identifiers[0]`, which is an identifier, not a hash of the
+ * transaction.
+ *
+ * Both the submit (pending) and revert (rejected) sides route through this one function so they can never disagree on
+ * the key. The fallback is deterministic: the same transaction object yields the same bytes every time, and the
+ * auto-revert path reverts the very object it submitted, so the rejected entry lands on the pending entry in place.
+ * (Serialization differs across lifecycle states, so this is only stable for a fixed tx — which is exactly the
+ * submit→revert flow.)
+ */
+export const txHistoryHash = (tx) => {
+    try {
+        return tx.transactionHash().toString();
+    }
+    catch {
+        return Buffer.from(tx.serialize()).toString('hex');
+    }
+};
 export const finalizedTransactionTrait = {
     areAllTxIdsIncluded(tx, txIds) {
         const txIdsSet = HashSet.fromIterable(tx.identifiers());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnightntwrk/wallet-sdk-facade",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.0-beta.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -26,19 +26,19 @@
     }
   },
   "dependencies": {
-    "@midnightntwrk/ledger-v9": "1.0.0-rc.2",
-    "@midnightntwrk/wallet-sdk-abstractions": "^2.1.0",
-    "@midnightntwrk/wallet-sdk-address-format": "^4.0.0-beta.0",
-    "@midnightntwrk/wallet-sdk-capabilities": "^4.0.0-beta.0",
-    "@midnightntwrk/wallet-sdk-dust-wallet": "^5.0.0-beta.0",
-    "@midnightntwrk/wallet-sdk-indexer-client": "^1.2.4-beta.0",
-    "@midnightntwrk/wallet-sdk-shielded": "^4.0.0-beta.0",
-    "@midnightntwrk/wallet-sdk-unshielded-wallet": "^4.0.0-beta.0",
+    "@midnightntwrk/ledger-v9": "1.0.0-rc.3",
+    "@midnightntwrk/wallet-sdk-abstractions": "3.0.0-beta.0",
+    "@midnightntwrk/wallet-sdk-address-format": "4.0.0-beta.2",
+    "@midnightntwrk/wallet-sdk-capabilities": "4.0.0-beta.2",
+    "@midnightntwrk/wallet-sdk-dust-wallet": "5.0.0-beta.2",
+    "@midnightntwrk/wallet-sdk-indexer-client": "1.3.0-beta.1",
+    "@midnightntwrk/wallet-sdk-shielded": "4.0.0-beta.2",
+    "@midnightntwrk/wallet-sdk-unshielded-wallet": "4.0.0-beta.2",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@midnightntwrk/wallet-sdk-hd": "^3.1.0-beta.0",
+    "@midnightntwrk/wallet-sdk-hd": "^3.1.0-beta.1",
     "@midnightntwrk/wallet-sdk-utilities": "^1.2.0"
   },
   "scripts": {