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

package/dist/v1/Transacting.js

@@ -11,184 +11,142 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Either, Option, pipe } from 'effect';
+import { Either, Option, pipe, Array as Arr } 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,176 @@ 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);
+    signUnprovenTransaction(transaction, signSegment) {
+        return this.#signTransactionInternal(transaction, signSegment);
+    }
+    signUnboundTransaction(transaction, signSegment) {
+        return this.#signTransactionInternal(transaction, signSegment);
+    }
+    /**
+     * Internal method to sign either an unproven or unbound transaction
+     * @param transaction - The transaction to sign
+     * @param signSegment - The signing function
+     * @returns The signed transaction if successful, otherwise an error
+     */
+    #signTransactionInternal(transaction, signSegment) {
+        return Either.gen(this, function* () {
+            const segments = this.txOps.getSegments(transaction);
             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;
         });
     }
+    /**
+     * Reverts a transaction by rolling back all inputs owned by this wallet
+     * @param wallet - The wallet to revert the transaction for
+     * @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or UnprovenTransaction)
+     * @returns The updated wallet with rolled back UTXOs if successful, otherwise an error
+     */
+    revert(wallet, transaction) {
+        return pipe(this.txOps.extractOwnInputs(transaction, wallet.publicKey.publicKey), Arr.reduce(Either.right(wallet), (walletAcc, utxo) => pipe(walletAcc, Either.flatMap((w) => CoreWallet.rollbackUtxo(w, utxo)))));
+    }
+    /**
+     * 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,23 @@
+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;
+    extractOwnInputs(transaction: ledger.FinalizedTransaction | UnboundTransaction | ledger.UnprovenTransaction, signatureVerifyingKey: ledger.SignatureVerifyingKey): ledger.Utxo[];
+};
+export declare const TransactionOps: TransactionOps;

package/dist/v1/TransactionOps.js

@@ -0,0 +1,95 @@
+// 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';
+    },
+    extractOwnInputs(transaction, signatureVerifyingKey) {
+        const segments = TransactionOps.getSegments(transaction);
+        return pipe(segments, Arr.flatMap((segment) => {
+            const intent = transaction.intents?.get(segment);
+            if (!intent) {
+                return [];
+            }
+            const { guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+            const ownedInputsfromGuaranteedSection = guaranteedUnshieldedOffer?.inputs
+                ? guaranteedUnshieldedOffer.inputs.filter((input) => input.owner === signatureVerifyingKey)
+                : [];
+            const ownedInputsfromFallibleSection = fallibleUnshieldedOffer
+                ? fallibleUnshieldedOffer.inputs.filter((input) => input.owner === signatureVerifyingKey)
+                : [];
+            return [...ownedInputsfromGuaranteedSection, ...ownedInputsfromFallibleSection];
+        }));
+    },
+};