@midnightntwrk/wallet-sdk-unshielded-wallet 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/KeyStore.d.ts

@@ -18,6 +18,14 @@ export interface UnshieldedKeystore {
     getBech32Address(): MidnightBech32m;
     getPublicKey(): SignatureVerifyingKey;
     getAddress(): UserAddress;
+    /** The synchronous in-process signing primitive. */
     signData(data: Uint8Array): Signature;
+    /**
+     * Async counterpart of {@link signData} that conforms to the SDK's signer callback shape (`(data) =>
+     * Promise<Signature>`), so the keystore can be passed directly to `signRecipe`/`signUnprovenTransaction`/… without
+     * wrapping each call site. It simply resolves the synchronous {@link signData}; out-of-process backends (MPC, HSM)
+     * supply their own async signer.
+     */
+    signDataAsync: (data: Uint8Array) => Promise<Signature>;
 }
 export declare const createKeystore: (secretKey: UnshieldedSecretKey, networkId: NetworkId.NetworkId) => UnshieldedKeystore;

package/dist/KeyStore.js

@@ -36,6 +36,7 @@ export const createKeystore = (secretKey, networkId) => {
         getPublicKey: () => signatureVerifyingKey(ledgerSigningKey),
         getAddress: () => addressFromKey(keystore.getPublicKey()),
         signData: (data) => signData(ledgerSigningKey, data),
+        signDataAsync: (data) => Promise.resolve(keystore.signData(data)),
     };
     return keystore;
 };

package/dist/UnshieldedWallet.d.ts

@@ -8,6 +8,7 @@ import { type CoinsAndBalancesCapability } from './v1/CoinsAndBalances.js';
 import { type KeysCapability } from './v1/Keys.js';
 import { type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './v1/Transacting.js';
 import { type WalletSyncUpdate } from './v1/SyncSchema.js';
+import { type SignSegment } from './v1/Signing.js';
 import { type UtxoWithMeta } from './v1/UnshieldedState.js';
 import { type Variant, type VariantBuilder, type WalletLike } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
 import { type PublicKey } from './KeyStore.js';
@@ -54,8 +55,8 @@ export type UnshieldedWalletAPI<TSerialized = string> = {
      */
     rotateUtxos(guaranteedUtxos: readonly UtxoWithMeta[], fallibleUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Promise<ledger.UnprovenTransaction>;
     initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
-    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
-    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: SignSegment): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: SignSegment): Promise<UnboundTransaction>;
     serializeState(): Promise<TSerialized>;
     waitForSyncedState(allowedGap?: bigint): Promise<UnshieldedWalletState<TSerialized>>;
     revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<void>;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './UnshieldedWallet.js';
-export { type UnshieldedTransactionHistoryEntry, UnshieldedSectionSchema } from './v1/TransactionHistory.js';
+export { type UnshieldedTransactionHistoryEntry, UnshieldedSectionSchema, mergeUnshieldedSections, } from './v1/TransactionHistory.js';
+export { type SignSegment } from './v1/Signing.js';
 export * from './KeyStore.js';

package/dist/index.js

@@ -11,5 +11,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 export * from './UnshieldedWallet.js';
-export { UnshieldedSectionSchema } from './v1/TransactionHistory.js';
+export { UnshieldedSectionSchema, mergeUnshieldedSections, } from './v1/TransactionHistory.js';
 export * from './KeyStore.js';

package/dist/v1/RunningV1Variant.d.ts

@@ -6,6 +6,7 @@ import { type WalletSyncUpdate } from './SyncSchema.js';
 import { type TransactingCapability, type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './Transacting.js';
 import { type UtxoWithMeta } from './UnshieldedState.js';
 import { type UnboundTransaction } from './TransactionOps.js';
+import { type SignSegment, type SigningService } from './Signing.js';
 import { type WalletError } from './WalletError.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { type KeysCapability } from './Keys.js';
@@ -19,6 +20,7 @@ export declare namespace RunningV1Variant {
         syncService: SyncService<CoreWallet, TSyncUpdate>;
         syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
         transactingCapability: TransactingCapability<CoreWallet>;
+        signingService: SigningService;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
         coinSelection: CoinSelection<ledger.Utxo>;
@@ -41,8 +43,8 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate> implements Varia
     transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     rotateUtxos(guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
-    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
-    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<UnboundTransaction, WalletError>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: SignSegment): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: SignSegment): Effect.Effect<UnboundTransaction, WalletError>;
     revertTransaction(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Effect.Effect<void, WalletError>;
     serializeState(state: CoreWallet): TSerialized;
 }

package/dist/v1/RunningV1Variant.js

@@ -98,10 +98,10 @@ export class RunningV1Variant {
         });
     }
     signUnprovenTransaction(transaction, signSegment) {
-        return this.#v1Context.transactingCapability.signUnprovenTransaction(transaction, signSegment);
+        return this.#v1Context.signingService.sign(transaction, signSegment);
     }
     signUnboundTransaction(transaction, signSegment) {
-        return this.#v1Context.transactingCapability.signUnboundTransaction(transaction, signSegment);
+        return this.#v1Context.signingService.sign(transaction, signSegment);
     }
     revertTransaction(transaction) {
         return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => {

package/dist/v1/Signing.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import type * as ledger from '@midnightntwrk/ledger-v9';
+import { type UnboundTransaction } from './TransactionOps.js';
+import { type WalletError } from './WalletError.js';
+/**
+ * Produces a {@link ledger.Signature} over the supplied bytes. Asynchronous so that out-of-process signers (MPC, HSM) —
+ * whose whole purpose is that the secret never materializes in-process — can be plugged in directly. A synchronous
+ * in-process keystore satisfies this by resolving immediately: `keystore.signDataAsync`.
+ */
+export type SignSegment = (data: Uint8Array) => Promise<ledger.Signature>;
+/**
+ * Authorizes a transaction by signing each of its signable segments with the supplied async {@link SignSegment}. The
+ * service is the imperative shell: it drives the async signer and maps its failures into the typed error channel; the
+ * pure work is delegated to {@link TransactionOps.collectSignableData} and {@link TransactionOps.attachSignatures}.
+ */
+export interface SigningService {
+    sign<TTransaction extends ledger.UnprovenTransaction | UnboundTransaction>(transaction: TTransaction, signSegment: SignSegment): Effect.Effect<TTransaction, WalletError>;
+}
+/**
+ * The default signing service: collect each segment's signable data (pure), invoke the async signer once per segment
+ * (sequentially — segment counts are tiny), then attach the signatures (pure, with scheme validation). A signer
+ * rejection or throw is wrapped in a {@link SignError}; a scheme mismatch short-circuits inside `attachSignatures`
+ * before anything is attached, so no partially-signed transaction can escape.
+ */
+export declare const makeDefaultSigningService: () => SigningService;

package/dist/v1/Signing.js

@@ -0,0 +1,40 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Signing as a service (#504). Authorizing a transaction means producing a `Signature` over each signable segment.
+// For an in-process keystore that is instantaneous, but MPC (threshold protocols with network round-trips) and HSM
+// (on-device PKCS#11) signers are inherently asynchronous. The signer is therefore an async callback, and the
+// orchestration that invokes it lives here — in the Effect (imperative-shell) layer — while the pure transformations
+// (which segments to sign, scheme validation, signature attachment) stay in `TransactionOps`.
+import { EitherOps } from '@midnightntwrk/wallet-sdk-utilities';
+import { Effect, pipe } from 'effect';
+import { TransactionOps } from './TransactionOps.js';
+import { SignError } from './WalletError.js';
+/**
+ * The default signing service: collect each segment's signable data (pure), invoke the async signer once per segment
+ * (sequentially — segment counts are tiny), then attach the signatures (pure, with scheme validation). A signer
+ * rejection or throw is wrapped in a {@link SignError}; a scheme mismatch short-circuits inside `attachSignatures`
+ * before anything is attached, so no partially-signed transaction can escape.
+ */
+export const makeDefaultSigningService = () => ({
+    sign(transaction, signSegment) {
+        return Effect.gen(function* () {
+            const segments = yield* EitherOps.toEffect(TransactionOps.collectSignableData(transaction));
+            const signatures = yield* Effect.forEach(segments, (segment) => pipe(Effect.tryPromise({
+                try: () => signSegment(segment.data),
+                catch: (cause) => new SignError({ message: 'Signer callback failed', cause }),
+            }), Effect.map((signature) => ({ segment: segment.segment, signature }))));
+            return yield* EitherOps.toEffect(TransactionOps.attachSignatures(transaction, signatures));
+        });
+    },
+});

package/dist/v1/SyncSchema.d.ts

@@ -40,6 +40,8 @@ export declare const UnshieldedTransactionSchema: Schema.Data<Schema.Struct<{
     protocolVersion: typeof Schema.Number;
     identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
     block: Schema.Struct<{
+        hash: typeof Schema.String;
+        height: typeof Schema.Number;
         timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
     }>;
     fees: Schema.optional<Schema.Struct<{
@@ -64,6 +66,8 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
         protocolVersion: typeof Schema.Number;
         identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
         block: Schema.Struct<{
+            hash: typeof Schema.String;
+            height: typeof Schema.Number;
             timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
         }>;
         fees: Schema.optional<Schema.Struct<{
@@ -167,6 +171,8 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
         readonly block: {
+            readonly hash: string;
+            readonly height: number;
             readonly timestamp: Date;
         };
         readonly fees?: {
@@ -217,6 +223,8 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
         readonly block: {
+            readonly hash: string;
+            readonly height: number;
             readonly timestamp: Date;
         };
         readonly fees?: {
@@ -259,6 +267,8 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
         protocolVersion: typeof Schema.Number;
         identifiers: Schema.optional<Schema.Array$<typeof Schema.String>>;
         block: Schema.Struct<{
+            hash: typeof Schema.String;
+            height: typeof Schema.Number;
             timestamp: Schema.transform<typeof Schema.Number, typeof Schema.DateFromSelf>;
         }>;
         fees: Schema.optional<Schema.Struct<{
@@ -362,6 +372,8 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
         readonly block: {
+            readonly hash: string;
+            readonly height: number;
             readonly timestamp: Date;
         };
         readonly fees?: {
@@ -412,6 +424,8 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
         readonly block: {
+            readonly hash: string;
+            readonly height: number;
             readonly timestamp: Date;
         };
         readonly fees?: {

package/dist/v1/SyncSchema.js

@@ -70,6 +70,8 @@ export const UnshieldedTransactionSchema = Schema.Data(Schema.Struct({
     protocolVersion: Schema.Number,
     identifiers: Schema.optional(Schema.Array(Schema.String)),
     block: Schema.Struct({
+        hash: Schema.String,
+        height: Schema.Number,
         timestamp: DateFromMillis,
     }),
     fees: Schema.optional(Schema.Struct({

package/dist/v1/Transacting.d.ts

@@ -44,9 +44,7 @@ export interface TransactingCapability<TState> {
     balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
     balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
     balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
-    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
     revertTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<CoreWallet, WalletError>;
-    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId.NetworkId;
@@ -111,8 +109,6 @@ export declare class TransactingCapabilityImplementation implements TransactingC
      * @returns The initialized swap transaction and the new wallet state if successful, otherwise an error
      */
     initSwap(wallet: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
-    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
-    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
     /**
      * Reverts a transaction by rolling back all inputs owned by this wallet
      *

package/dist/v1/Transacting.js

@@ -16,7 +16,6 @@ import { CoreWallet } from './CoreWallet.js';
 import { InsufficientFundsError, OtherWalletError, TransactingError } from './WalletError.js';
 import { getBalanceRecipe, Imbalances, InsufficientFundsError as BalancingInsufficientFundsError, } from '@midnightntwrk/wallet-sdk-capabilities';
 import { TransactionOps } from './TransactionOps.js';
-import { assertSignatureMatchesKey } from '../SchemeConsistency.js';
 const GUARANTEED_SEGMENT = 0;
 export const makeDefaultTransactingCapability = (config, getContext) => {
     return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps);
@@ -221,47 +220,6 @@ export class TransactingCapabilityImplementation {
             };
         });
     }
-    signUnprovenTransaction(transaction, signSegment) {
-        return this.#signTransactionInternal(transaction, signSegment);
-    }
-    signUnboundTransaction(transaction, signSegment) {
-        return this.#signTransactionInternal(transaction, signSegment);
-    }
-    /**
-     * Internal method to sign either an unproven or unbound transaction
-     *
-     * @param transaction - The transaction to sign
-     * @param signSegment - The signing function
-     * @returns The signed transaction if successful, otherwise an error
-     */
-    #signTransactionInternal(transaction, signSegment) {
-        return Either.gen(this, function* () {
-            const segments = this.txOps.getSegments(transaction);
-            for (const segment of segments) {
-                const signedData = yield* this.txOps.getSignatureData(transaction, segment);
-                const signature = signSegment(signedData);
-                // Reject a wrong-scheme signature before it is attached, so a mismatch
-                // never reaches the network (no partially-signed transaction escapes).
-                yield* this.#assertSignatureMatchesSegmentOwners(transaction, segment, signature);
-                transaction = yield* this.txOps.addSignature(transaction, signature, segment);
-            }
-            return transaction;
-        });
-    }
-    /**
-     * Asserts that a freshly produced signature shares the scheme (`schnorr` vs `ecdsa`) of every input owner it will
-     * authorize in the given segment. Pure and synchronous: a mismatch short-circuits signing with a typed
-     * `SchemeMismatchError` before the signature is attached.
-     */
-    #assertSignatureMatchesSegmentOwners(transaction, segment, signature) {
-        const intent = transaction.intents?.get(segment);
-        const owners = [
-            ...(intent?.guaranteedUnshieldedOffer?.inputs ?? []),
-            ...(intent?.fallibleUnshieldedOffer?.inputs ?? []),
-        ].map((input) => input.owner);
-        const ok = Either.right(signature);
-        return pipe(owners, Arr.reduce(ok, (acc, owner) => Either.flatMap(acc, () => assertSignatureMatchesKey(owner, signature))));
-    }
     /**
      * Reverts a transaction by rolling back all inputs owned by this wallet
      *

package/dist/v1/TransactionHistory.d.ts

@@ -19,8 +19,37 @@ export declare const UnshieldedSectionSchema: Schema.Struct<{
         outputIndex: typeof Schema.Number;
     }>>;
 }>;
-export declare const UnshieldedTransactionHistoryEntrySchema: Schema.Struct<{
-    unshielded: Schema.Struct<{
+type UnshieldedSection = Schema.Schema.Type<typeof UnshieldedSectionSchema>;
+export declare const mergeUnshieldedSections: (existing: UnshieldedSection, incoming: UnshieldedSection) => UnshieldedSection;
+/**
+ * Unshielded entry schema. Extends the common entry shape with an optional `unshielded` section. Tightening — required
+ * `unshielded` plus required `protocolVersion`/`status`/`timestamp` — happens at the writer-input type, not on the
+ * stored shape. Fees are not unshielded's concern (dust pays them); unshielded never writes `fees`.
+ */
+export declare const UnshieldedTransactionHistoryEntrySchema: 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>;
+    }>]>;
+}> & {
+    unshielded: Schema.optional<Schema.Struct<{
         id: typeof Schema.Number;
         createdUtxos: Schema.Array$<Schema.Struct<{
             value: Schema.Schema<bigint, string, never>;
@@ -36,19 +65,15 @@ export declare const UnshieldedTransactionHistoryEntrySchema: Schema.Struct<{
             intentHash: typeof Schema.String;
             outputIndex: typeof Schema.Number;
         }>>;
-    }>;
-    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 UnshieldedTransactionHistoryEntry = Schema.Schema.Type<typeof UnshieldedTransactionHistoryEntrySchema>;
 export type TransactionHistoryService = {
     put(update: UnshieldedUpdate): Effect.Effect<void, TransactionHistoryError>;
 };
+export type UnshieldedHistoryStorage = TransactionHistoryStorage.TransactionHistoryReader<TransactionHistoryStorage.TransactionHistoryEntryWithHash> & TransactionHistoryStorage.TransactionHistoryWriter<UnshieldedTransactionHistoryEntry>;
 export type DefaultTransactionHistoryConfiguration = {
-    txHistoryStorage: TransactionHistoryStorage.TransactionHistoryStorage<TransactionHistoryStorage.TransactionHistoryEntryWithHash>;
+    txHistoryStorage: UnshieldedHistoryStorage;
 };
 export declare const makeDefaultTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService;
+export {};

package/dist/v1/TransactionHistory.js

@@ -26,17 +26,29 @@ export const UnshieldedSectionSchema = Schema.Struct({
     createdUtxos: Schema.Array(UtxoSchema),
     spentUtxos: Schema.Array(UtxoSchema),
 });
-export const UnshieldedTransactionHistoryEntrySchema = Schema.Struct({
-    ...TransactionHistoryStorage.TransactionHistoryCommonSchema.fields,
-    unshielded: UnshieldedSectionSchema,
+export const mergeUnshieldedSections = (existing, incoming) => ({
+    ...existing,
+    ...incoming,
 });
-const convertUpdateToStorageEntry = ({ transaction, createdUtxos, spentUtxos, status, }) => ({
+/**
+ * Unshielded entry schema. Extends the common entry shape with an optional `unshielded` section. Tightening — required
+ * `unshielded` plus required `protocolVersion`/`status`/`timestamp` — happens at the writer-input type, not on the
+ * stored shape. Fees are not unshielded's concern (dust pays them); unshielded never writes `fees`.
+ */
+export const UnshieldedTransactionHistoryEntrySchema = TransactionHistoryStorage.extendEntrySchema({
+    unshielded: Schema.optional(UnshieldedSectionSchema),
+});
+const convertUpdateToFinalizedInput = ({ transaction, createdUtxos, spentUtxos, status, }) => ({
     hash: transaction.hash,
     protocolVersion: transaction.protocolVersion,
     status,
     identifiers: transaction.identifiers ?? [],
     timestamp: transaction.block.timestamp,
-    fees: transaction.fees?.paidFees ?? null,
+    finalizedBlock: {
+        hash: transaction.block.hash,
+        height: transaction.block.height,
+        timestamp: transaction.block.timestamp,
+    },
     unshielded: {
         id: transaction.id,
         createdUtxos: createdUtxos.map(({ utxo }) => ({
@@ -59,8 +71,8 @@ export const makeDefaultTransactionHistoryService = (config, _getContext) => {
     const txHistoryStorage = config.txHistoryStorage;
     return {
         put: (update) => Effect.tryPromise({
-            try: () => txHistoryStorage.upsert(convertUpdateToStorageEntry(update)),
-            catch: (e) => new TransactionHistoryError({ message: 'Failed to put transaction history entry', cause: e }),
+            try: () => txHistoryStorage.gotFinalized(convertUpdateToFinalizedInput(update)),
+            catch: (e) => new TransactionHistoryError({ message: 'Failed to record finalized history entry', cause: e }),
         }),
     };
 };

package/dist/v1/TransactionOps.d.ts

@@ -6,11 +6,23 @@ import { type WalletError } from './WalletError.js';
 export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
 /** Utility type to extract the Intent type from a Transaction type. Maps Transaction<S, P, B> to Intent<S, P, B>. */
 export type IntentOf<T> = T extends ledger.Transaction<infer S, infer P, infer B> ? ledger.Intent<S, P, B> : never;
+/** A transaction segment paired with the bytes that must be signed to authorize it. */
+export type SignableSegment = {
+    readonly segment: number;
+    readonly data: Uint8Array;
+};
+/** A signature produced for a specific transaction segment, ready to be attached. */
+export type SegmentSignature = {
+    readonly segment: number;
+    readonly signature: ledger.Signature;
+};
 export type TransactionOps = {
     getSignatureData: (transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.PreBinding>, segment: number) => Either.Either<Uint8Array, WalletError>;
     getSegments(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): number[];
     findAvailableSegmentId(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Option.Option<number>;
     addSignature<TTransaction extends ledger.UnprovenTransaction | UnboundTransaction>(transaction: TTransaction, signature: ledger.Signature, segment: number): Either.Either<TTransaction, WalletError>;
+    collectSignableData(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.PreBinding>): Either.Either<readonly SignableSegment[], WalletError>;
+    attachSignatures<TTransaction extends ledger.UnprovenTransaction | UnboundTransaction>(transaction: TTransaction, signatures: readonly SegmentSignature[]): Either.Either<TTransaction, WalletError>;
     getImbalances(transaction: ledger.FinalizedTransaction | UnboundTransaction | ledger.UnprovenTransaction, segment: number): Imbalances;
     addSignaturesToOffer(offer: ledger.UnshieldedOffer<ledger.SignatureEnabled>, signature: ledger.Signature, segment: number, offerType: 'guaranteed' | 'fallible'): Either.Either<ledger.UnshieldedOffer<ledger.SignatureEnabled>, WalletError>;
     isIntentBound(intent: ledger.Intent<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): boolean;

package/dist/v1/TransactionOps.js

@@ -13,7 +13,21 @@
 import { Either, pipe, Array as Arr, Iterable as IterableOps } from 'effect';
 import { Imbalances } from '@midnightntwrk/wallet-sdk-capabilities';
 import { addressFromKey, SignatureEnabled } from '@midnightntwrk/ledger-v9';
+import { assertSignatureMatchesKey } from '../SchemeConsistency.js';
 import { TransactingError } from './WalletError.js';
+/**
+ * Asserts that `signature` shares the scheme of every input owner authorized in `segment`. Pure and synchronous: a
+ * mismatch short-circuits with a typed `SchemeMismatchError` so a wrong-scheme signature is never attached.
+ */
+const assertSignatureMatchesSegmentOwners = (transaction, segment, signature) => {
+    const intent = transaction.intents?.get(segment);
+    const owners = [
+        ...(intent?.guaranteedUnshieldedOffer?.inputs ?? []),
+        ...(intent?.fallibleUnshieldedOffer?.inputs ?? []),
+    ].map((input) => input.owner);
+    const seed = Either.right(signature);
+    return pipe(owners, Arr.reduce(seed, (acc, owner) => Either.flatMap(acc, () => assertSignatureMatchesKey(owner, signature))));
+};
 export const TransactionOps = {
     getSignatureData(tx, segment) {
         if (!tx.intents) {
@@ -58,6 +72,19 @@ export const TransactionOps = {
             return transaction;
         });
     },
+    collectSignableData(transaction) {
+        // A transaction with no intents has no signable segments — yields an empty list, never an error.
+        return Either.all(TransactionOps.getSegments(transaction).map((segment) => Either.map(TransactionOps.getSignatureData(transaction, segment), (data) => ({ segment, data }))));
+    },
+    attachSignatures(transaction, signatures) {
+        return Either.gen(function* () {
+            // Validate every signature's scheme against its segment's owners BEFORE attaching any of them, so a
+            // mismatch leaves the transaction untouched (no partially-signed transaction can escape toward the network).
+            yield* Either.all(signatures.map(({ segment, signature }) => assertSignatureMatchesSegmentOwners(transaction, segment, signature)));
+            const seed = Either.right(transaction);
+            return yield* pipe(signatures, Arr.reduce(seed, (acc, { segment, signature }) => Either.flatMap(acc, (tx) => TransactionOps.addSignature(tx, signature, segment))));
+        });
+    },
     getImbalances(transaction, segment) {
         const imbalances = transaction
             .imbalances(segment)

package/dist/v1/V1Builder.d.ts

@@ -8,6 +8,7 @@ import { type DefaultSyncContext, type DefaultSyncConfiguration, type SyncCapabi
 import { type WalletSyncUpdate } from './SyncSchema.js';
 import { type DefaultTransactingConfiguration, type DefaultTransactingContext, type TransactingCapability } from './Transacting.js';
 import { type WalletError } from './WalletError.js';
+import { type SigningService } from './Signing.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { type KeysCapability } from './Keys.js';
 import { type CoinSelection } from '@midnightntwrk/wallet-sdk-capabilities';
@@ -42,6 +43,8 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
     withSerialization<TSerializationConfig, TSerializationContext extends Partial<RunningV1Variant.AnyContext>, TSerialized>(serializationCapability: (configuration: TSerializationConfig, getContext: () => TSerializationContext) => SerializationCapability<CoreWallet, TSerialized>): V1Builder<TConfig & TSerializationConfig, TContext & TSerializationContext, TSerialized, TSyncUpdate>;
     withTransactingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate>;
     withTransacting<TTransactingConfig, TTransactingContext extends Partial<RunningV1Variant.AnyContext>>(transactingCapability: (config: TTransactingConfig, getContext: () => TTransactingContext) => TransactingCapability<CoreWallet>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate>;
+    withSigningDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>;
+    withSigning<TSigningConfig, TSigningContext extends Partial<RunningV1Variant.AnyContext>>(signingService: (configuration: TSigningConfig, getContext: () => TSigningContext) => SigningService): V1Builder<TConfig & TSigningConfig, TContext & TSigningContext, TSerialized, TSyncUpdate>;
     withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection<ledger.Utxo>): V1Builder<TConfig & TCoinSelectionConfig, TContext & TCoinSelectionContext, TSerialized, TSyncUpdate>;
     withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>;
     withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>;
@@ -61,6 +64,9 @@ declare namespace V1Builder {
     type HasTransacting<TConfig, TContext> = {
         readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<CoreWallet>;
     };
+    type HasSigning<TConfig, TContext> = {
+        readonly signingService: (configuration: TConfig, getContext: () => TContext) => SigningService;
+    };
     type HasCoinSelection<TConfig, TContext> = {
         readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection<ledger.Utxo>;
     };
@@ -77,7 +83,7 @@ declare namespace V1Builder {
         readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<CoreWallet>;
     };
     /** The internal build state of {@link V1Builder}. */
-    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext>>;
+    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext> & HasSigning<TConfig, TContext> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext>>;
     type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never> = {
         [K in keyof FullBuildState<never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate>[K] | undefined;
     };

package/dist/v1/V1Builder.js

@@ -4,6 +4,7 @@ import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
 import { makeDefaultV1SerializationCapability } from './Serialization.js';
 import { makeDefaultSyncService, makeDefaultSyncCapability, } from './Sync.js';
 import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultSigningService } from './Signing.js';
 import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { makeDefaultKeysCapability } from './Keys.js';
 import { chooseCoin } from '@midnightntwrk/wallet-sdk-capabilities';
@@ -22,6 +23,7 @@ export class V1Builder {
         return this.withSyncDefaults()
             .withSerializationDefaults()
             .withTransactingDefaults()
+            .withSigningDefaults()
             .withCoinsAndBalancesDefaults()
             .withTransactionHistoryDefaults()
             .withKeysDefaults()
@@ -55,6 +57,15 @@ export class V1Builder {
             transactingCapability,
         });
     }
+    withSigningDefaults() {
+        return this.withSigning(makeDefaultSigningService);
+    }
+    withSigning(signingService) {
+        return new V1Builder({
+            ...this.#buildState,
+            signingService,
+        });
+    }
     withCoinSelection(coinSelection) {
         return new V1Builder({
             ...this.#buildState,
@@ -119,13 +130,14 @@ export class V1Builder {
         if (!isBuildStateFull(this.#buildState)) {
             throw new Error('Not all components are configured in V1 Builder');
         }
-        const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService, } = this.#buildState;
+        const { syncCapability, syncService, transactingCapability, signingService, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService, } = this.#buildState;
         const getContext = () => context;
         const context = {
             serializationCapability: serializationCapability(configuration, getContext),
             syncCapability: syncCapability(configuration, getContext),
             syncService: syncService(configuration, getContext),
             transactingCapability: transactingCapability(configuration, getContext),
+            signingService: signingService(configuration, getContext),
             coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
             keysCapability: keysCapability(configuration, getContext),
             coinSelection: coinSelection(configuration, getContext),
@@ -139,6 +151,7 @@ const isBuildStateFull = (buildState) => {
         'syncService',
         'syncCapability',
         'transactingCapability',
+        'signingService',
         'coinSelection',
         'serializationCapability',
         'coinsAndBalancesCapability',

package/dist/v1/index.d.ts

@@ -2,6 +2,7 @@ export * from './V1Builder.js';
 export * as Sync from './Sync.js';
 export * as SyncProgress from './SyncProgress.js';
 export * as Transacting from './Transacting.js';
+export * as Signing from './Signing.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';

package/dist/v1/index.js

@@ -14,6 +14,7 @@ export * from './V1Builder.js';
 export * as Sync from './Sync.js';
 export * as SyncProgress from './SyncProgress.js';
 export * as Transacting from './Transacting.js';
+export * as Signing from './Signing.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnightntwrk/wallet-sdk-unshielded-wallet",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,13 +30,13 @@
     }
   },
   "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-indexer-client": "^1.2.4-beta.0",
-    "@midnightntwrk/wallet-sdk-runtime": "^1.0.4",
-    "@midnightntwrk/wallet-sdk-utilities": "^1.2.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-indexer-client": "1.3.0-beta.1",
+    "@midnightntwrk/wallet-sdk-runtime": "1.0.6-beta.0",
+    "@midnightntwrk/wallet-sdk-utilities": "1.2.0",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },
@@ -54,7 +54,7 @@
     "publint": "publint --strict"
   },
   "devDependencies": {
-    "@midnightntwrk/wallet-sdk-hd": "^3.1.0-beta.0",
+    "@midnightntwrk/wallet-sdk-hd": "^3.1.0-beta.1",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0"
   }