@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/UnshieldedWallet.d.ts

@@ -1,12 +1,12 @@
 import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
+import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet, UnboundTransaction } from './v1/index.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
 import { SerializationCapability } from './v1/Serialization.js';
 import { TransactionHistoryService } from './v1/TransactionHistory.js';
 import { CoinsAndBalancesCapability } from './v1/CoinsAndBalances.js';
 import { KeysCapability } from './v1/Keys.js';
-import { TokenTransfer } from './v1/Transacting.js';
+import { TokenTransfer, FinalizedTransactionBalanceResult, UnboundTransactionBalanceResult, UnprovenTransactionBalanceResult } from './v1/Transacting.js';
 import { WalletSyncUpdate } from './v1/SyncSchema.js';
 import { UtxoWithMeta } from './v1/UnshieldedState.js';
 import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
@@ -35,12 +35,14 @@ export declare class UnshieldedWalletState<TSerialized = string> {
     constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: UnshieldedWalletCapabilities<TSerialized>);
     serialize(): TSerialized;
 }
-export type UnshieldedWallet = CustomizedUnshieldedWallet<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export interface CustomizedUnshieldedWallet<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+export type UnshieldedWallet = CustomizedUnshieldedWallet<WalletSyncUpdate, string>;
+export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<WalletSyncUpdate, string, DefaultV1Configuration>;
+export interface CustomizedUnshieldedWallet<TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]> {
     readonly state: rx.Observable<UnshieldedWalletState<TSerialized>>;
     start(): Promise<void>;
-    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Promise<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Promise<FinalizedTransactionBalanceResult>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Promise<UnboundTransactionBalanceResult>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Promise<UnprovenTransactionBalanceResult>;
     transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
     initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
     signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
@@ -48,10 +50,10 @@ export interface CustomizedUnshieldedWallet<TTransaction = ledger.Transaction<le
     waitForSyncedState(allowedGap?: bigint): Promise<UnshieldedWalletState<TSerialized>>;
     getAddress(): Promise<UnshieldedAddress>;
 }
-export interface CustomizedUnshieldedWalletClass<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+export interface CustomizedUnshieldedWalletClass<TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]> {
     configuration: TConfig;
-    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
-    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
+    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
 }
 export declare function UnshieldedWallet(configuration: DefaultV1Configuration): UnshieldedWalletClass;
-export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction>, TConfig>): CustomizedUnshieldedWalletClass<TTransaction, TSyncUpdate, TSerialized, TConfig>;
+export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate>, TConfig>): CustomizedUnshieldedWalletClass<TSyncUpdate, TSerialized, TConfig>;

package/dist/UnshieldedWallet.js

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { V1Builder, V1Tag, CoreWallet } from './v1/index.js';
+import { V1Builder, V1Tag, CoreWallet, } from './v1/index.js';
 import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
@@ -77,10 +77,24 @@ export function CustomUnshieldedWallet(configuration, builder) {
         start() {
             return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground() }).pipe(Effect.runPromise);
         }
-        balanceTransaction(tx) {
+        balanceFinalizedTransaction(tx) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.balanceTransaction(tx),
+                [V1Tag]: (v1) => v1.balanceFinalizedTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnboundTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnboundTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnprovenTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnprovenTransaction(tx),
             })
                 .pipe(Effect.runPromise);
         }

package/dist/v1/RunningV1Variant.d.ts

@@ -3,7 +3,8 @@ import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet
 import { SerializationCapability } from './Serialization.js';
 import { SyncCapability, SyncService } from './Sync.js';
 import { WalletSyncUpdate } from './SyncSchema.js';
-import { TransactingCapability, TokenTransfer } from './Transacting.js';
+import { TransactingCapability, TokenTransfer, FinalizedTransactionBalanceResult, UnboundTransactionBalanceResult, UnprovenTransactionBalanceResult } from './Transacting.js';
+import { UnboundTransaction } from './TransactionOps.js';
 import { WalletError } from './WalletError.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
@@ -12,28 +13,30 @@ import { CoreWallet } from './CoreWallet.js';
 import { TransactionHistoryService } from './TransactionHistory.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 export declare namespace RunningV1Variant {
-    type Context<TSerialized, TSyncUpdate, TTransaction> = {
+    type Context<TSerialized, TSyncUpdate> = {
         serializationCapability: SerializationCapability<CoreWallet, TSerialized>;
         syncService: SyncService<CoreWallet, TSyncUpdate>;
         syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
-        transactingCapability: TransactingCapability<TTransaction, CoreWallet>;
+        transactingCapability: TransactingCapability<CoreWallet>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
         coinSelection: CoinSelection<ledger.Utxo>;
         transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
     };
-    type AnyContext = Context<any, any, any>;
+    type AnyContext = Context<any, any>;
 }
 export declare const V1Tag: unique symbol;
-export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate, ledger.FinalizedTransaction>;
-export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
+export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
     #private;
     readonly __polyTag__: typeof V1Tag;
     readonly state: Stream.Stream<StateChange.StateChange<CoreWallet>, WalletRuntimeError>;
-    constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction>);
+    constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate>);
     startSyncInBackground(): Effect.Effect<void>;
     startSync(): Stream.Stream<void, WalletError, Scope.Scope>;
-    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, WalletError>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Effect.Effect<FinalizedTransactionBalanceResult, WalletError>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Effect.Effect<UnboundTransactionBalanceResult, WalletError>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Effect.Effect<UnprovenTransactionBalanceResult, WalletError>;
     transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;

package/dist/v1/RunningV1Variant.js

@@ -67,14 +67,24 @@ export class RunningV1Variant {
             return Duration.millis(Math.min(delayWithJitter, Duration.toMillis(maxDelay)));
         }))));
     }
-    balanceTransaction(tx) {
+    balanceFinalizedTransaction(tx) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.balanceTransaction(state, tx), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+            return pipe(this.#v1Context.transactingCapability.balanceFinalizedTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnboundTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnboundTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnprovenTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnprovenTransaction(state, tx), EitherOps.toEffect);
         });
     }
     transferTransaction(outputs, ttl) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.flatMap(({ transaction, newState }) => pipe(this.#v1Context.transactingCapability.balanceTransaction(newState, transaction), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]))));
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
         });
     }
     initSwap(desiredInputs, desiredOutputs, ttl) {

package/dist/v1/Transacting.d.ts

@@ -4,7 +4,7 @@ import { Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { WalletError } from './WalletError.js';
 import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps, UnboundTransaction } from './TransactionOps.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
 export interface TokenTransfer {
@@ -12,14 +12,19 @@ export interface TokenTransfer {
     readonly type: ledger.RawTokenType;
     readonly receiverAddress: string;
 }
+export type FinalizedTransactionBalanceResult = ledger.UnprovenTransaction | undefined;
+export type UnboundTransactionBalanceResult = UnboundTransaction | undefined;
+export type UnprovenTransactionBalanceResult = ledger.UnprovenTransaction | undefined;
 export type TransactingResult<TTransaction, TState> = {
     readonly newState: TState;
     readonly transaction: TTransaction;
 };
-export interface TransactingCapability<_TTransaction, TState> {
+export interface TransactingCapability<TState> {
     makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
     initSwap(wallet: CoreWallet, desiredInputs: Record<string, bigint>, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
-    balanceTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<TransactingResult<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TState>, WalletError>;
+    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>;
     signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
@@ -30,16 +35,56 @@ export type DefaultTransactingContext = {
     coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
     keysCapability: KeysCapability<CoreWallet>;
 };
-export declare const makeDefaultTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<ledger.UnprovenTransaction, CoreWallet>;
-export declare class TransactingCapabilityImplementation<TTransaction extends ledger.UnprovenTransaction> implements TransactingCapability<ledger.UnprovenTransaction, CoreWallet> {
+export declare const makeDefaultTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<CoreWallet>;
+export declare class TransactingCapabilityImplementation implements TransactingCapability<CoreWallet> {
+    #private;
     readonly networkId: NetworkId.NetworkId;
     readonly getCoinSelection: () => CoinSelection<ledger.Utxo>;
-    readonly txTrait: TransactionTrait<TTransaction>;
+    readonly txOps: TransactionOps;
     readonly getCoins: () => CoinsAndBalancesCapability<CoreWallet>;
     readonly getKeys: () => KeysCapability<CoreWallet>;
-    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.Utxo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txTrait: TransactionTrait<TTransaction>);
-    balanceTransaction(wallet: CoreWallet, transaction: TTransaction): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
-    makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
-    initSwap(wallet: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<TTransaction, CoreWallet>, WalletError>;
+    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.Utxo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txOps: TransactionOps);
+    /**
+     * Balances an unbound transaction
+     * Note: Unbound transactions are balanced in place and returned
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Balances an unproven transaction
+     * Note: This method does the same thing as balanceUnboundTransaction but is provided for convenience and type safety
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Balances a bound transaction
+     * Note: In bound transactions we can only balance the guaranteed section in intents
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns A balancing counterpart transaction (which should be merged with the original transaction )
+     * and the new wallet state if successful, otherwise an error
+     */
+    balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
+    /**
+     * Makes a transfer transaction
+     * @param wallet - The wallet to make the transfer with
+     * @param outputs - The outputs for the transfer
+     * @param ttl - The TTL for the transaction
+     * @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
+     */
+    makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
+    /**
+     * Initializes a swap transaction
+     * @param wallet - The wallet to initialize the swap for
+     * @param desiredInputs - The desired inputs for the swap
+     * @param desiredOutputs - The desired outputs for the swap
+     * @param ttl - The TTL for the swap
+     * @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>;
     signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<ledger.UnprovenTransaction, WalletError>;
 }

package/dist/v1/Transacting.js

@@ -13,182 +13,140 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Either, Option, pipe } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
-import { SignError, TransactingError } from './WalletError.js';
-import { getBalanceRecipe, Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { isIntentBound, TransactionTrait } from './Transaction.js';
+import { InsufficientFundsError, OtherWalletError, SignError, TransactingError } from './WalletError.js';
+import { getBalanceRecipe, Imbalances, InsufficientFundsError as BalancingInsufficientFundsError, } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { TransactionOps } from './TransactionOps.js';
 import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 const GUARANTEED_SEGMENT = 0;
-const mergeCounterOffer = (counterOffer, currentOffer) => pipe(Option.fromNullable(currentOffer), Option.match({
-    onNone: () => Either.right(counterOffer),
-    onSome: (currentOffer) => Either.try({
-        try: () => ledger.UnshieldedOffer.new([...currentOffer.inputs, ...counterOffer.inputs], [...currentOffer.outputs, ...counterOffer.outputs], [...currentOffer.signatures, ...counterOffer.signatures]),
-        catch: (error) => new TransactingError({ message: 'Failed to merge counter offers', cause: error }),
-    }),
-}));
 export const makeDefaultTransactingCapability = (config, getContext) => {
-    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionTrait.default);
+    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps);
 };
 export class TransactingCapabilityImplementation {
     networkId;
     getCoinSelection;
-    txTrait;
+    txOps;
     getCoins;
     getKeys;
-    constructor(networkId, getCoinSelection, getCoins, getKeys, txTrait) {
+    constructor(networkId, getCoinSelection, getCoins, getKeys, txOps) {
         this.getCoins = getCoins;
         this.networkId = networkId;
         this.getCoinSelection = getCoinSelection;
         this.getKeys = getKeys;
-        this.txTrait = txTrait;
+        this.txOps = txOps;
     }
-    balanceTransaction(wallet, transaction) {
+    /**
+     * Balances an unbound transaction
+     * Note: Unbound transactions are balanced in place and returned
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnboundTransaction(wallet, transaction) {
+        return this.#balanceUnboundishTransaction(wallet, transaction);
+    }
+    /**
+     * Balances an unproven transaction
+     * Note: This method does the same thing as balanceUnboundTransaction but is provided for convenience and type safety
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    balanceUnprovenTransaction(wallet, transaction) {
+        return this.#balanceUnboundishTransaction(wallet, transaction);
+    }
+    /**
+     * Balances a bound transaction
+     * Note: In bound transactions we can only balance the guaranteed section in intents
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns A balancing counterpart transaction (which should be merged with the original transaction )
+     * and the new wallet state if successful, otherwise an error
+     */
+    balanceFinalizedTransaction(wallet, transaction) {
         return Either.gen(this, function* () {
-            const segments = TransactionTrait.default.getSegments(transaction);
-            if (!transaction.intents || !transaction.intents.size || !segments.length) {
-                return {
-                    newState: wallet,
-                    transaction,
-                };
-            }
-            const { addressHex, publicKey } = wallet.publicKey;
-            for (const segment of [...segments, GUARANTEED_SEGMENT]) {
-                const allIntentImbalances = yield* Either.try({
-                    try: () => transaction.imbalances(segment),
-                    catch: (error) => new TransactingError({ message: 'Failed to get intent imbalances', cause: error }),
-                });
-                const imbalances = allIntentImbalances
-                    .entries()
-                    .filter(([token, value]) => token.tag === 'unshielded' && value !== 0n)
-                    .map(([token, value]) => [token, value])
-                    .map(([token, value]) => {
-                    return [token.raw, value];
-                })
-                    .toArray();
-                // // intent is balanced
-                if (!imbalances.length)
-                    continue;
-                const availableCoins = this.getCoins().getAvailableCoins(wallet);
-                if (!availableCoins.length) {
-                    return yield* Either.left(new TransactingError({ message: 'No available coins to spend' }));
-                }
-                // select inputs, receive the change outputs
-                const { inputs, outputs: changeOutputs } = yield* Either.try({
-                    try: () => getBalanceRecipe({
-                        coins: availableCoins.map(({ utxo }) => utxo),
-                        initialImbalances: Imbalances.fromEntries(imbalances),
-                        feeTokenType: '',
-                        transactionCostModel: {
-                            inputFeeOverhead: 0n,
-                            outputFeeOverhead: 0n,
-                        },
-                        createOutput: (coin) => ({
-                            ...coin,
-                            owner: addressHex,
-                        }),
-                        isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
-                    }),
-                    catch: (error) => {
-                        const message = error instanceof Error ? error.message : error?.toString() || '';
-                        return new TransactingError({ message });
-                    },
-                });
-                // mark the coins as spent
-                const [spentInputs] = yield* CoreWallet.spendUtxos(wallet, inputs);
-                const ledgerInputs = spentInputs.map((input) => ({
-                    ...input,
-                    intentHash: input.intentHash,
-                    owner: publicKey,
-                }));
-                const counterOffer = yield* Either.try({
-                    try: () => ledger.UnshieldedOffer.new(ledgerInputs, changeOutputs, []),
-                    catch: (error) => new TransactingError({ message: 'Failed to create counter offer', cause: error }),
-                });
-                // NOTE: for the segment === 0 we insert the counter-offer into any intent's guaranteed section
-                if (segment !== GUARANTEED_SEGMENT) {
-                    const intent = transaction.intents.get(segment);
-                    const isBound = isIntentBound(intent);
-                    if (!isBound && intent.fallibleUnshieldedOffer) {
-                        const mergedOffer = yield* mergeCounterOffer(counterOffer, intent.fallibleUnshieldedOffer);
-                        intent.fallibleUnshieldedOffer = mergedOffer;
-                        transaction.intents = transaction.intents.set(segment, intent);
-                    }
-                    else {
-                        // create a new offer if the intent is bound
-                        const nextSegment = Math.max(...TransactionTrait.default.getSegments(transaction)) + 1;
-                        const newIntent = ledger.Intent.new(intent.ttl);
-                        newIntent.fallibleUnshieldedOffer = counterOffer;
-                        transaction.intents = transaction.intents.set(nextSegment, newIntent);
-                    }
-                }
-                else {
-                    let ttl = new Date();
-                    let updated = false;
-                    // try to find and modify any unbound intent first
-                    const segments = TransactionTrait.default.getSegments(transaction);
-                    for (const segment of segments) {
-                        const intent = transaction.intents.get(segment);
-                        ttl = intent.ttl;
-                        const isBound = isIntentBound(intent);
-                        if (!isBound) {
-                            const mergedOffer = yield* mergeCounterOffer(counterOffer, intent.guaranteedUnshieldedOffer);
-                            intent.guaranteedUnshieldedOffer = mergedOffer;
-                            transaction.intents = transaction.intents.set(segment, intent);
-                            updated = true;
-                            break;
-                        }
-                    }
-                    // no unbound intents found, insert a new one
-                    if (!updated) {
-                        const nextSegment = Math.max(...segments) + 1;
-                        const newIntent = ledger.Intent.new(ttl);
-                        newIntent.guaranteedUnshieldedOffer = counterOffer;
-                        transaction.intents = transaction.intents.set(nextSegment, newIntent);
-                    }
+            // Ensure all intents are bound
+            const segments = this.txOps.getSegments(transaction);
+            for (const segment of segments) {
+                const intent = transaction.intents?.get(segment);
+                const isBound = this.txOps.isIntentBound(intent);
+                if (!isBound) {
+                    return yield* Either.left(new TransactingError({ message: `Intent with id ${segment} is not bound` }));
                 }
             }
-            return {
-                newState: wallet,
-                transaction: transaction,
-            };
+            // get the first intent so we can use its ttl to create the balancing intent
+            const intent = transaction.intents?.get(segments[0]);
+            const imbalances = this.txOps.getImbalances(transaction, GUARANTEED_SEGMENT);
+            // guaranteed section is balanced
+            if (imbalances.size === 0) {
+                return [undefined, wallet];
+            }
+            const recipe = yield* this.#balanceSegment(wallet, imbalances, Imbalances.empty(), this.getCoinSelection());
+            const { newState, offer } = yield* this.#prepareOffer(wallet, recipe);
+            const balancingIntent = ledger.Intent.new(intent.ttl);
+            balancingIntent.guaranteedUnshieldedOffer = offer;
+            return [ledger.Transaction.fromPartsRandomized(this.networkId, undefined, undefined, balancingIntent), newState];
         });
     }
+    /**
+     * Makes a transfer transaction
+     * @param wallet - The wallet to make the transfer with
+     * @param outputs - The outputs for the transfer
+     * @param ttl - The TTL for the transaction
+     * @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
+     */
     makeTransfer(wallet, outputs, ttl) {
-        const networkId = this.networkId;
-        const isValid = outputs.every((output) => output.amount > 0n);
-        if (!isValid) {
-            throw new TransactingError({ message: 'The amount needs to be positive' });
-        }
-        const ledgerOutputs = outputs.map((output) => {
-            return {
-                value: output.amount,
-                owner: UnshieldedAddress.codec
-                    .decode(networkId, MidnightBech32m.parse(output.receiverAddress))
-                    .data.toString('hex'),
-                type: output.type,
-            };
-        });
-        return Either.try({
-            try: () => {
-                const intent = ledger.Intent.new(ttl);
-                intent.guaranteedUnshieldedOffer = ledger.UnshieldedOffer.new([], ledgerOutputs, []);
+        return Either.gen(this, function* () {
+            const { networkId } = this;
+            const isValid = outputs.every((output) => output.amount > 0n);
+            if (!isValid) {
+                return yield* Either.left(new TransactingError({ message: 'The amount of all inputs needs to be positive' }));
+            }
+            const ledgerOutputs = outputs.map((output) => {
                 return {
-                    newState: wallet,
-                    transaction: ledger.Transaction.fromParts(networkId, undefined, undefined, intent),
+                    value: output.amount,
+                    owner: UnshieldedAddress.codec
+                        .decode(networkId, MidnightBech32m.parse(output.receiverAddress))
+                        .data.toString('hex'),
+                    type: output.type,
                 };
-            },
-            catch: (error) => new TransactingError({ message: 'Failed to create transaction', cause: error }),
+            });
+            const recipe = yield* this.#balanceSegment(wallet, Imbalances.empty(), Imbalances.fromEntries(ledgerOutputs.map((output) => [output.type, output.value])), this.getCoinSelection());
+            const { newState, offer } = yield* this.#prepareOffer(wallet, {
+                inputs: recipe.inputs,
+                outputs: [...recipe.outputs, ...ledgerOutputs],
+            });
+            const intent = ledger.Intent.new(ttl);
+            const hasNightOutput = ledgerOutputs.some((output) => output.type === ledger.nativeToken().raw);
+            if (hasNightOutput) {
+                intent.fallibleUnshieldedOffer = offer;
+            }
+            else {
+                intent.guaranteedUnshieldedOffer = offer;
+            }
+            return {
+                newState,
+                transaction: ledger.Transaction.fromParts(networkId, undefined, undefined, intent),
+            };
         });
     }
+    /**
+     * Initializes a swap transaction
+     * @param wallet - The wallet to initialize the swap for
+     * @param desiredInputs - The desired inputs for the swap
+     * @param desiredOutputs - The desired outputs for the swap
+     * @param ttl - The TTL for the swap
+     * @returns The initialized swap transaction and the new wallet state if successful, otherwise an error
+     */
     initSwap(wallet, desiredInputs, desiredOutputs, ttl) {
         return Either.gen(this, function* () {
-            const networkId = this.networkId;
+            const { networkId } = this;
             const outputsValid = desiredOutputs.every((output) => output.amount > 0n);
             if (!outputsValid) {
-                return yield* Either.left(new TransactingError({ message: 'The amount needs to be positive' }));
+                return yield* Either.left(new TransactingError({ message: 'The amount of all outputs needs to be positive' }));
             }
             const inputsValid = Object.entries(desiredInputs).every(([, amount]) => amount > 0n);
             if (!inputsValid) {
-                return yield* Either.left(new TransactingError({ message: 'The input amounts need to be positive' }));
+                return yield* Either.left(new TransactingError({ message: 'The amount of all inputs needs to be positive' }));
             }
             const ledgerOutputs = desiredOutputs.map((output) => ({
                 value: output.amount,
@@ -198,55 +156,155 @@ export class TransactingCapabilityImplementation {
                 type: output.type,
             }));
             const targetImbalances = Imbalances.fromEntries(Object.entries(desiredInputs));
-            const availableCoins = this.getCoins().getAvailableCoins(wallet);
-            const { inputs, outputs: changeOutputs } = yield* Either.try({
-                try: () => getBalanceRecipe({
-                    coins: availableCoins.map(({ utxo }) => utxo),
-                    initialImbalances: Imbalances.empty(),
-                    feeTokenType: '',
-                    transactionCostModel: {
-                        inputFeeOverhead: 0n,
-                        outputFeeOverhead: 0n,
-                    },
-                    createOutput: (coin) => ({
-                        ...coin,
-                        owner: wallet.publicKey.addressHex,
-                    }),
-                    isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
-                    targetImbalances,
-                }),
-                catch: (error) => {
-                    const message = error instanceof Error ? error.message : error?.toString() || '';
-                    return new TransactingError({ message });
-                },
+            const recipe = yield* this.#balanceSegment(wallet, Imbalances.empty(), targetImbalances, this.getCoinSelection());
+            const { newState, offer } = yield* this.#prepareOffer(wallet, {
+                inputs: recipe.inputs,
+                outputs: [...recipe.outputs, ...ledgerOutputs],
             });
-            const [spentInputs, updatedWallet] = yield* CoreWallet.spendUtxos(wallet, inputs);
-            const ledgerInputs = spentInputs.map((input) => ({
-                ...input,
-                owner: wallet.publicKey.publicKey,
-            }));
-            const offer = ledger.UnshieldedOffer.new(ledgerInputs, [...changeOutputs, ...ledgerOutputs], []);
             const intent = ledger.Intent.new(ttl);
             intent.guaranteedUnshieldedOffer = offer;
             const tx = ledger.Transaction.fromParts(networkId, undefined, undefined, intent);
             return {
-                newState: updatedWallet,
+                newState,
                 transaction: tx,
             };
         });
     }
     signTransaction(transaction, signSegment) {
-        return Either.gen(function* () {
-            const segments = TransactionTrait.default.getSegments(transaction);
+        return Either.gen(this, function* () {
+            const segments = this.txOps.getSegments(transaction);
             if (!segments.length) {
                 throw new SignError({ message: 'No segments found in the provided transaction' });
             }
             for (const segment of segments) {
-                const signedData = yield* TransactionTrait.default.getOfferSignatureData(transaction, segment);
+                const signedData = yield* this.txOps.getSignatureData(transaction, segment);
                 const signature = signSegment(signedData);
-                transaction = yield* TransactionTrait.default.addOfferSignature(transaction, signature, segment);
+                transaction = yield* this.txOps.addSignature(transaction, signature, segment);
             }
             return transaction;
         });
     }
+    /**
+     * Balances a segment of a transaction
+     * @param wallet - The wallet to balance the segment for
+     * @param imbalances - The imbalances to balance the segment for
+     * @param targetImbalances - The target imbalances to balance the segment for
+     * @param coinSelection - The coin selection to use for the balance recipe
+     * @returns The balance recipe if successful, otherwise an error
+     */
+    #balanceSegment(wallet, imbalances, targetImbalances, coinSelection) {
+        return Either.try({
+            try: () => getBalanceRecipe({
+                coins: this.getCoins()
+                    .getAvailableCoins(wallet)
+                    .map(({ utxo }) => utxo),
+                initialImbalances: imbalances,
+                feeTokenType: '',
+                transactionCostModel: {
+                    inputFeeOverhead: 0n,
+                    outputFeeOverhead: 0n,
+                },
+                coinSelection,
+                createOutput: (coin) => ({
+                    ...coin,
+                    owner: wallet.publicKey.addressHex,
+                }),
+                isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
+                targetImbalances,
+            }),
+            catch: (err) => {
+                if (err instanceof BalancingInsufficientFundsError) {
+                    return new InsufficientFundsError({
+                        message: 'Insufficient funds',
+                        tokenType: err.tokenType,
+                        amount: imbalances.get(err.tokenType) ?? 0n,
+                    });
+                }
+                else {
+                    return new OtherWalletError({
+                        message: 'Balancing unshielded segment failed',
+                        cause: err,
+                    });
+                }
+            },
+        });
+    }
+    /**
+     * Prepares an offer for a given balance recipe
+     * @param wallet - The wallet to prepare the offer for
+     * @param balanceRecipe - The balance recipe to prepare the offer for
+     * @returns The prepared offer and the new wallet state if successful, otherwise an error
+     */
+    #prepareOffer(wallet, balanceRecipe) {
+        return Either.gen(function* () {
+            const [spentInputs, updatedWallet] = yield* CoreWallet.spendUtxos(wallet, balanceRecipe.inputs);
+            const { publicKey } = wallet.publicKey;
+            const ledgerInputs = spentInputs.map((input) => ({
+                ...input,
+                intentHash: input.intentHash,
+                owner: publicKey,
+            }));
+            const counterOffer = yield* Either.try({
+                try: () => ledger.UnshieldedOffer.new(ledgerInputs, [...balanceRecipe.outputs], []),
+                catch: (error) => new TransactingError({ message: 'Failed to create counter offer', cause: error }),
+            });
+            return {
+                newState: updatedWallet,
+                offer: counterOffer,
+            };
+        });
+    }
+    #mergeOffers(offerA, offerB) {
+        return pipe(Option.fromNullable(offerB), Option.match({
+            onNone: () => Either.right(offerA),
+            onSome: (offerB) => Either.try({
+                try: () => ledger.UnshieldedOffer.new([...offerB.inputs, ...offerA.inputs], [...offerB.outputs, ...offerA.outputs], [...offerB.signatures, ...offerA.signatures]),
+                catch: (error) => new TransactingError({ message: 'Failed to merge offers', cause: error }),
+            }),
+        }));
+    }
+    /**
+     * Balances an unboundish (unproven or unbound) transaction
+     * @param wallet - The wallet to balance the transaction with
+     * @param transaction - The transaction to balance
+     * @returns The balanced transaction and the new wallet state if successful, otherwise an error
+     */
+    #balanceUnboundishTransaction(wallet, transaction) {
+        return Either.gen(this, function* () {
+            const segments = this.txOps.getSegments(transaction);
+            // no segments to balance
+            if (segments.length === 0) {
+                return [undefined, wallet];
+            }
+            for (const segment of [...segments, GUARANTEED_SEGMENT]) {
+                const imbalances = this.txOps.getImbalances(transaction, segment);
+                // intent is balanced
+                if (imbalances.size === 0) {
+                    continue;
+                }
+                // if segment is GUARANTEED_SEGMENT, use the first intent to place the balancing offer in the guaranteed section
+                const intentSegment = segment === GUARANTEED_SEGMENT ? segments[0] : segment;
+                const intent = transaction.intents?.get(intentSegment);
+                if (!intent) {
+                    return yield* Either.left(new TransactingError({ message: `Intent with id ${segment} was not found` }));
+                }
+                const isBound = this.txOps.isIntentBound(intent);
+                if (isBound) {
+                    return yield* Either.left(new TransactingError({ message: `Intent with id ${segment} is already bound` }));
+                }
+                const recipe = yield* this.#balanceSegment(wallet, imbalances, Imbalances.empty(), this.getCoinSelection());
+                const { offer } = yield* this.#prepareOffer(wallet, recipe);
+                const targetOffer = segment !== GUARANTEED_SEGMENT ? intent.fallibleUnshieldedOffer : intent.guaranteedUnshieldedOffer;
+                const mergedOffer = yield* this.#mergeOffers(offer, targetOffer);
+                if (segment !== GUARANTEED_SEGMENT) {
+                    intent.fallibleUnshieldedOffer = mergedOffer;
+                }
+                else {
+                    intent.guaranteedUnshieldedOffer = mergedOffer;
+                }
+                transaction.intents = transaction.intents.set(intentSegment, intent);
+            }
+            return [transaction, wallet];
+        });
+    }
 }

package/dist/v1/TransactionOps.d.ts

@@ -0,0 +1,22 @@
+import { Either } from 'effect';
+import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { WalletError } from './WalletError.js';
+/**
+ * Unbound transaction type. This is a transaction that has no signatures and is not bound yet.
+ */
+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;
+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[];
+    addSignature(transaction: ledger.UnprovenTransaction | UnboundTransaction, signature: ledger.Signature, segment: number): Either.Either<ledger.UnprovenTransaction, 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;
+};
+export declare const TransactionOps: TransactionOps;

package/dist/v1/TransactionOps.js

@@ -0,0 +1,78 @@
+// 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, Array as Arr } 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 TransactionOps = {
+    getSignatureData(tx, segment) {
+        if (!tx.intents) {
+            return Either.left(new TransactingError({ message: 'Transaction has no intents' }));
+        }
+        const intent = tx.intents.get(segment);
+        if (!intent) {
+            return Either.left(new TransactingError({ message: `Intent with segment ${segment} was not found` }));
+        }
+        return Either.try({
+            try: () => intent.signatureData(segment),
+            catch: (error) => new TransactingError({ message: 'Failed to get offer signature data', cause: error }),
+        });
+    },
+    getSegments(transaction) {
+        return transaction.intents?.keys().toArray() ?? [];
+    },
+    addSignature(transaction, signature, segment) {
+        return Either.gen(function* () {
+            if (!transaction.intents || transaction.intents.size === 0) {
+                return yield* Either.left(new TransactingError({ message: 'No intents found in the transaction' }));
+            }
+            const originalIntent = yield* Either.fromNullable(transaction.intents?.get(segment), () => new TransactingError({ message: 'Intent with a given segment was not found' }));
+            if (TransactionOps.isIntentBound(originalIntent)) {
+                return yield* Either.left(new TransactingError({ message: `Intent at segment ${segment} is already bound` }));
+            }
+            const clonedIntent = yield* Either.try({
+                try: () => ledger.Intent.deserialize('signature', 'pre-proof', 'pre-binding', originalIntent.serialize()),
+                catch: (error) => new TransactingError({ message: 'Failed to clone intent', cause: error }),
+            });
+            if (clonedIntent.fallibleUnshieldedOffer) {
+                clonedIntent.fallibleUnshieldedOffer = yield* TransactionOps.addSignaturesToOffer(clonedIntent.fallibleUnshieldedOffer, signature, segment, 'fallible');
+            }
+            if (clonedIntent.guaranteedUnshieldedOffer) {
+                clonedIntent.guaranteedUnshieldedOffer = yield* TransactionOps.addSignaturesToOffer(clonedIntent.guaranteedUnshieldedOffer, signature, segment, 'guaranteed');
+            }
+            transaction.intents = transaction.intents?.set(segment, clonedIntent);
+            return transaction;
+        });
+    },
+    getImbalances(transaction, segment) {
+        const imbalances = transaction
+            .imbalances(segment)
+            .entries()
+            .filter(([token, value]) => token.tag === 'unshielded' && value !== 0n)
+            .map(([token, value]) => [token.raw.toString(), value])
+            .toArray();
+        return Imbalances.fromEntries(imbalances);
+    },
+    addSignaturesToOffer(offer, signature, segment, offerType) {
+        return pipe(offer.inputs, Arr.map((_, i) => offer.signatures.at(i) ?? signature), (signatures) => Either.try({
+            try: () => offer.addSignatures(signatures),
+            catch: (error) => new TransactingError({
+                message: `Failed to add ${offerType} signature at segment ${segment}`,
+                cause: error,
+            }),
+        }));
+    },
+    isIntentBound(intent) {
+        return intent.binding.instance === 'binding';
+    },
+};

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.16",
+  "version": "1.0.0-beta.18",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,14 +23,14 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v7": "7.0.0-alpha.1",
+    "@midnight-ntwrk/ledger-v7": "7.0.0-rc.1",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.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-hd": "3.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.15",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.9",
-    "effect": "^3.17.3",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.16",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.10",
+    "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(),
-        };
-    };
-})();