@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/v1/V1Builder.d.ts

@@ -20,39 +20,37 @@ export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfigurat
 declare const V1BuilderSymbol: {
     readonly typeId: unique symbol;
 };
-export type V1Variant<TSerialized, TSyncUpdate, TTransaction> = Variant.Variant<typeof V1Tag, CoreWallet, null, RunningV1Variant<TSerialized, TSyncUpdate, TTransaction>> & {
+export type V1Variant<TSerialized, TSyncUpdate> = Variant.Variant<typeof V1Tag, CoreWallet, null, RunningV1Variant<TSerialized, TSyncUpdate>> & {
     deserializeState: (serialized: TSerialized) => Either.Either<CoreWallet, WalletError>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
     serialization: SerializationCapability<CoreWallet, TSerialized>;
     transactionHistory: TransactionHistoryService<UnshieldedUpdate>;
 };
-export type AnyV1Variant = V1Variant<any, any, any>;
-export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
-export type TransactionOf<T extends AnyV1Variant> = T extends V1Variant<any, any, infer TTransaction> ? TTransaction : never;
-export type SerializedStateOf<T extends AnyV1Variant> = T extends V1Variant<infer TSerialized, any, any> ? TSerialized : never;
-export type DefaultV1Builder = V1Builder<DefaultV1Configuration, RunningV1Variant.Context<string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>, string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
-export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Configuration, TContext extends Partial<RunningV1Variant.AnyContext> = object, TSerialized = never, TSyncUpdate = never, TTransaction = never> implements VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction>, TConfig> {
+export type AnyV1Variant = V1Variant<any, any>;
+export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate>;
+export type TransactionOf<T extends AnyV1Variant> = T extends V1Variant<any, any> ? ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish> : never;
+export type SerializedStateOf<T extends AnyV1Variant> = T extends V1Variant<infer TSerialized, any> ? TSerialized : never;
+export type DefaultV1Builder = V1Builder<DefaultV1Configuration, RunningV1Variant.Context<string, WalletSyncUpdate>, string, WalletSyncUpdate>;
+export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Configuration, TContext extends Partial<RunningV1Variant.AnyContext> = object, TSerialized = never, TSyncUpdate = never> implements VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate>, TConfig> {
     #private;
-    constructor(buildState?: V1Builder.PartialBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>);
+    constructor(buildState?: V1Builder.PartialBuildState<TConfig, TContext, TSerialized, TSyncUpdate>);
     withDefaults(): DefaultV1Builder;
-    withTransactionType<Transaction>(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, Transaction>;
-    withDefaultTransactionType(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
-    withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext & DefaultSyncContext, TSerialized, WalletSyncUpdate, TTransaction>;
-    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate, TTransaction>;
-    withSerializationDefaults(): V1Builder<TConfig, TContext, string, TSyncUpdate, TTransaction>;
-    withSerialization<TSerializationConfig, TSerializationContext extends Partial<RunningV1Variant.AnyContext>, TSerialized>(serializationCapability: (configuration: TSerializationConfig, getContext: () => TSerializationContext) => SerializationCapability<CoreWallet, TSerialized>): V1Builder<TConfig & TSerializationConfig, TContext & TSerializationContext, TSerialized, TSyncUpdate, TTransaction>;
-    withTransactingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
-    withTransacting<TTransactingConfig, TTransactingContext extends Partial<RunningV1Variant.AnyContext>>(transactingCapability: (config: TTransactingConfig, getContext: () => TTransactingContext) => TransactingCapability<TTransaction, CoreWallet>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate, TTransaction>;
-    withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection<ledger.Utxo>): V1Builder<TConfig & TCoinSelectionConfig, TContext & TCoinSelectionContext, TSerialized, TSyncUpdate, TTransaction>;
-    withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
-    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
-    withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<CoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate, TTransaction>;
-    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction>): V1Builder<TConfig & DefaultTransactionHistoryConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction>;
-    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryService: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryService<UnshieldedUpdate>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction>;
-    withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
-    withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction>;
-    build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction>, TSerialized, TSyncUpdate, TTransaction>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate, TTransaction>;
+    withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext & DefaultSyncContext, TSerialized, WalletSyncUpdate>;
+    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate>;
+    withSerializationDefaults(): V1Builder<TConfig, TContext, string, TSyncUpdate>;
+    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>;
+    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>;
+    withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<CoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate>;
+    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>): V1Builder<TConfig & DefaultTransactionHistoryConfiguration, TContext, TSerialized, TSyncUpdate>;
+    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryService: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryService<UnshieldedUpdate>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate>;
+    withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate>;
+    withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate>;
+    build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate>, TSerialized, TSyncUpdate>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate>;
 }
 /** @internal */
 declare namespace V1Builder {
@@ -60,8 +58,8 @@ declare namespace V1Builder {
         readonly syncService: (configuration: TConfig, getContext: () => TContext) => SyncService<CoreWallet, TSyncUpdate>;
         readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<CoreWallet, TSyncUpdate>;
     };
-    type HasTransacting<TConfig, TContext, TTransaction> = {
-        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<TTransaction, CoreWallet>;
+    type HasTransacting<TConfig, TContext> = {
+        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<CoreWallet>;
     };
     type HasCoinSelection<TConfig, TContext> = {
         readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection<ledger.Utxo>;
@@ -81,9 +79,9 @@ declare namespace V1Builder {
     /**
      * The internal build state of {@link V1Builder}.
      */
-    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext>>;
-    type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never, TTransaction = never> = {
-        [K in keyof FullBuildState<never, never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>[K] | undefined;
+    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 PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never> = {
+        [K in keyof FullBuildState<never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate>[K] | undefined;
     };
     /**
      * Utility interface that manages the type variance of {@link V1Builder}.

package/dist/v1/V1Builder.js

@@ -19,8 +19,7 @@ export class V1Builder {
         this.#buildState = buildState;
     }
     withDefaults() {
-        return this.withDefaultTransactionType()
-            .withSyncDefaults()
+        return this.withSyncDefaults()
             .withSerializationDefaults()
             .withTransactingDefaults()
             .withCoinsAndBalancesDefaults()
@@ -28,16 +27,6 @@ export class V1Builder {
             .withKeysDefaults()
             .withCoinSelectionDefaults();
     }
-    withTransactionType() {
-        return new V1Builder({
-            ...this.#buildState,
-            transactingCapability: undefined,
-            transactionHistoryService: undefined,
-        });
-    }
-    withDefaultTransactionType() {
-        return this.withTransactionType();
-    }
     withSyncDefaults() {
         return this.withSync(makeDefaultSyncService, makeDefaultSyncCapability);
     }

package/dist/v1/index.d.ts

@@ -10,6 +10,6 @@ export * from './RunningV1Variant.js';
 export * as Simulator from './Simulator.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';
 export * as TransactionHistoryStorage from '../storage/index.js';
 export * as UnshieldedState from './UnshieldedState.js';

package/dist/v1/index.js

@@ -22,6 +22,6 @@ export * from './RunningV1Variant.js';
 export * as Simulator from './Simulator.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';
 export * as TransactionHistoryStorage from '../storage/index.js';
 export * as UnshieldedState from './UnshieldedState.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-unshielded-wallet",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.19",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,14 +23,14 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v7": "7.0.0-rc.1",
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.11",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.12",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.12",
     "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.16",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.10",
-    "effect": "^3.17.3",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.17",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.11",
+    "effect": "^3.19.14",
     "rxjs": "^7.5"
   },
   "scripts": {
@@ -46,6 +46,7 @@
   },
   "devDependencies": {
     "eslint": "^9.37.0",
+    "fast-check": "^4.5.3",
     "prettier": "^3.7.0",
     "publint": "~0.3.14",
     "rimraf": "^6.0.1",

package/dist/v1/Transaction.d.ts

@@ -1,25 +0,0 @@
-import { Either } from 'effect';
-import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { TransactionImbalances } from './TransactionImbalances.js';
-import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { TransactingError, WalletError } from './WalletError.js';
-export declare const isIntentBound: (intent: ledger.Intent<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>) => boolean;
-export type TransactionTrait<Tx> = {
-    id(tx: Tx): string;
-    getOfferSignatureData: (transaction: Tx, segment: number) => Either.Either<Uint8Array, WalletError>;
-    getSegments(transaction: Tx): number[];
-    addOfferSignature(transaction: Tx, signature: ledger.Signature, segment: number): Either.Either<Tx, WalletError>;
-    bindTransaction(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.PreBinding>): Either.Either<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Binding>, WalletError>;
-};
-export declare const TransactionTrait: {
-    default: TransactionTrait<ledger.UnprovenTransaction>;
-    shared: {
-        getOfferSignatureData(tx: ledger.UnprovenTransaction, segment: number): Either.Either<Uint8Array<ArrayBufferLike>, WalletError>;
-        addOfferSignature(transaction: ledger.UnprovenTransaction, signature: ledger.Signature, segment?: number): Either.Either<ledger.UnprovenTransaction, WalletError>;
-        getSegments(transaction: ledger.UnprovenTransaction): number[];
-        bindTransaction(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.PreBinding>): Either.Either<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Binding>, TransactingError>;
-        getImbalances(tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction): TransactionImbalances;
-        getGuaranteedImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;
-        getFallibleImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;
-    };
-};

package/dist/v1/Transaction.js

@@ -1,155 +0,0 @@
-// This file is part of MIDNIGHT-WALLET-SDK.
-// Copyright (C) 2025 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.
-import { Either, pipe } from 'effect';
-import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { TransactingError } from './WalletError.js';
-export const isIntentBound = (intent) => {
-    return intent.binding instanceof ledger.Binding;
-};
-export const TransactionTrait = new (class {
-    default = {
-        getOfferSignatureData(tx, segment) {
-            return TransactionTrait.shared.getOfferSignatureData(tx, segment);
-        },
-        getSegments(tx) {
-            return TransactionTrait.shared.getSegments(tx);
-        },
-        addOfferSignature(transaction, signature, segment) {
-            return TransactionTrait.shared.addOfferSignature(transaction, signature, segment);
-        },
-        bindTransaction(transaction) {
-            return TransactionTrait.shared.bindTransaction(transaction);
-        },
-        id(tx) {
-            return tx.identifiers().at(0);
-        },
-    };
-    shared = {
-        getOfferSignatureData(tx, segment) {
-            return Either.try({
-                try: () => {
-                    if (!tx.intents) {
-                        throw new TransactingError({ message: 'Transaction has no intents' });
-                    }
-                    const intent = tx.intents.get(segment);
-                    if (!intent) {
-                        throw new TransactingError({ message: `Intent with segment ${segment} was not found` });
-                    }
-                    return pipe(isIntentBound(intent) ? intent : intent.bind(segment), (boundIntent) => boundIntent.signatureData(segment));
-                },
-                catch: (error) => error instanceof TransactingError
-                    ? error
-                    : new TransactingError({ message: 'Failed to get offer signature data', cause: error }),
-            });
-        },
-        addOfferSignature(transaction, signature, segment = 1) {
-            return Either.gen(function* () {
-                if (!transaction.intents || !transaction.intents.size) {
-                    throw new TransactingError({ message: 'No intents found in the provided transaction' });
-                }
-                const intent = transaction.intents.get(segment);
-                if (!intent) {
-                    throw new TransactingError({ message: 'Intent with a given segment was not found' });
-                }
-                const isBound = isIntentBound(intent);
-                if (isBound)
-                    return transaction;
-                let updatedIntent = intent;
-                if (intent.guaranteedUnshieldedOffer) {
-                    const offer = intent.guaranteedUnshieldedOffer;
-                    const inputsLen = offer.inputs.length;
-                    const signatures = [];
-                    for (let i = 0; i < inputsLen; ++i) {
-                        signatures.push(offer.signatures.at(i) ?? signature);
-                    }
-                    updatedIntent = yield* Either.try({
-                        try: () => {
-                            const offerWithSignatures = offer.addSignatures(signatures);
-                            updatedIntent.guaranteedUnshieldedOffer = offerWithSignatures;
-                            return updatedIntent;
-                        },
-                        catch: (error) => new TransactingError({
-                            message: `Failed to add guaranteed signature at segment ${segment}`,
-                            cause: error,
-                        }),
-                    });
-                }
-                if (intent.fallibleUnshieldedOffer) {
-                    const offer = intent.fallibleUnshieldedOffer;
-                    const inputsLen = offer.inputs.length;
-                    const signatures = [];
-                    for (let i = 0; i < inputsLen; ++i) {
-                        signatures.push(offer.signatures.at(i) ?? signature);
-                    }
-                    updatedIntent = yield* Either.try({
-                        try: () => {
-                            const offerWithSignatures = offer.addSignatures(signatures);
-                            updatedIntent.fallibleUnshieldedOffer = offerWithSignatures;
-                            return updatedIntent;
-                        },
-                        catch: (error) => new TransactingError({
-                            message: `Failed to add fallible signature at segment ${segment}`,
-                            cause: error,
-                        }),
-                    });
-                }
-                transaction.intents = transaction.intents.set(segment, updatedIntent);
-                return transaction;
-            });
-        },
-        getSegments(transaction) {
-            return transaction.intents && transaction.intents.size > 0 ? transaction.intents.keys().toArray() : [];
-        },
-        bindTransaction(transaction) {
-            return Either.try({
-                try: () => transaction.bind(),
-                catch: (error) => new TransactingError({ message: 'Failed to bind transaction', cause: error }),
-            });
-        },
-        getImbalances(tx) {
-            const guaranteedImbalances = TransactionTrait.shared.getGuaranteedImbalances(tx);
-            const fallibleImbalances = TransactionTrait.shared.getFallibleImbalances(tx);
-            return pipe({
-                guaranteed: guaranteedImbalances,
-                fallible: fallibleImbalances,
-                fees: 0n,
-            });
-        },
-        getGuaranteedImbalances: (tx) => {
-            const rawGuaranteedImbalances = tx
-                .imbalances(0)
-                .entries()
-                .filter(([token]) => token.tag === 'shielded')
-                .map(([token, value]) => {
-                return [token.raw.toString(), value];
-            });
-            return Imbalances.fromEntries(rawGuaranteedImbalances);
-        },
-        getFallibleImbalances: (tx) => {
-            try {
-                const rawFallibleImbalances = tx
-                    .imbalances(1)
-                    .entries()
-                    .filter(([token]) => token.tag === 'shielded')
-                    .map(([token, value]) => {
-                    return [token.raw.toString(), value];
-                });
-                return Imbalances.fromEntries(rawFallibleImbalances);
-            }
-            catch {
-                return Imbalances.empty();
-            }
-        },
-    };
-})();

package/dist/v1/TransactionImbalances.d.ts

@@ -1,8 +0,0 @@
-import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-export type TransactionImbalances = Readonly<{
-    guaranteed: Imbalances;
-    fallible: Imbalances;
-}>;
-export declare const TransactionImbalances: {
-    empty: () => TransactionImbalances;
-};

package/dist/v1/TransactionImbalances.js

@@ -1,21 +0,0 @@
-// This file is part of MIDNIGHT-WALLET-SDK.
-// Copyright (C) 2025 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.
-import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-export const TransactionImbalances = new (class {
-    empty = () => {
-        return {
-            guaranteed: Imbalances.empty(),
-            fallible: Imbalances.empty(),
-        };
-    };
-})();