@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/v1/Transacting.js

@@ -0,0 +1,252 @@
+// 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 * as ledger from '@midnight-ntwrk/ledger-v6';
+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 { 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);
+};
+export class TransactingCapabilityImplementation {
+    networkId;
+    getCoinSelection;
+    txTrait;
+    getCoins;
+    getKeys;
+    constructor(networkId, getCoinSelection, getCoins, getKeys, txTrait) {
+        this.getCoins = getCoins;
+        this.networkId = networkId;
+        this.getCoinSelection = getCoinSelection;
+        this.getKeys = getKeys;
+        this.txTrait = txTrait;
+    }
+    balanceTransaction(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);
+                    }
+                }
+            }
+            return {
+                newState: wallet,
+                transaction: transaction,
+            };
+        });
+    }
+    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 {
+                    newState: wallet,
+                    transaction: ledger.Transaction.fromParts(networkId, undefined, undefined, intent),
+                };
+            },
+            catch: (error) => new TransactingError({ message: 'Failed to create transaction', cause: error }),
+        });
+    }
+    initSwap(wallet, desiredInputs, desiredOutputs, ttl) {
+        return Either.gen(this, function* () {
+            const networkId = this.networkId;
+            const outputsValid = desiredOutputs.every((output) => output.amount > 0n);
+            if (!outputsValid) {
+                return yield* Either.left(new TransactingError({ message: 'The amount 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' }));
+            }
+            const ledgerOutputs = desiredOutputs.map((output) => ({
+                value: output.amount,
+                owner: UnshieldedAddress.codec
+                    .decode(networkId, MidnightBech32m.parse(output.receiverAddress))
+                    .data.toString('hex'),
+                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 [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,
+                transaction: tx,
+            };
+        });
+    }
+    signTransaction(transaction, signSegment) {
+        return Either.gen(function* () {
+            const segments = TransactionTrait.default.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 signature = signSegment(signedData);
+                transaction = yield* TransactionTrait.default.addOfferSignature(transaction, signature, segment);
+            }
+            return transaction;
+        });
+    }
+}

package/dist/v1/Transaction.d.ts

@@ -0,0 +1,25 @@
+import { Either } from 'effect';
+import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { TransactionImbalances } from './TransactionImbalances.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+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

@@ -0,0 +1,155 @@
+// 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-v6';
+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/TransactionHistory.d.ts

@@ -0,0 +1,12 @@
+import { TransactionHistoryStorage, TransactionHistoryEntry, TransactionHash } from '../storage/index.js';
+import { UnshieldedUpdate } from './SyncSchema.js';
+export interface TransactionHistoryService<SyncUpdate> {
+    create(update: SyncUpdate): Promise<void>;
+    get(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    getAll(): AsyncIterableIterator<TransactionHistoryEntry>;
+    delete(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+}
+export type DefaultTransactionHistoryConfiguration = {
+    txHistoryStorage: TransactionHistoryStorage;
+};
+export declare const makeDefaultTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService<UnshieldedUpdate>;

package/dist/v1/TransactionHistory.js

@@ -0,0 +1,29 @@
+const convertUpdateToEntry = ({ transaction, status }) => {
+    return {
+        id: transaction.id,
+        hash: transaction.hash,
+        protocolVersion: transaction.protocolVersion,
+        identifiers: transaction.identifiers ? transaction.identifiers : [],
+        status,
+        timestamp: transaction.block?.timestamp ?? null,
+        fees: transaction.fees?.paidFees ?? null,
+    };
+};
+export const makeDefaultTransactionHistoryService = (config, _getContext) => {
+    const { txHistoryStorage } = config;
+    return {
+        create: async (update) => {
+            const entry = convertUpdateToEntry(update);
+            await txHistoryStorage.create(entry);
+        },
+        get: async (hash) => {
+            return await txHistoryStorage.get(hash);
+        },
+        getAll: () => {
+            return txHistoryStorage.getAll();
+        },
+        delete: async (hash) => {
+            return txHistoryStorage.delete(hash);
+        },
+    };
+};

package/dist/v1/TransactionImbalances.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,21 @@
+// 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(),
+        };
+    };
+})();

package/dist/v1/UnshieldedState.d.ts

@@ -0,0 +1,37 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Data, Either, HashMap } from 'effect';
+import { ApplyTransactionError, UtxoNotFoundError } from './WalletError.js';
+export interface UtxoMeta {
+    readonly ctime: Date;
+    readonly registeredForDustGeneration: boolean;
+}
+export type UtxoHash = string;
+export declare class UtxoWithMeta extends Data.Class<{
+    readonly utxo: ledger.Utxo;
+    readonly meta: UtxoMeta;
+}> {
+}
+export type UpdateStatus = 'SUCCESS' | 'FAILURE' | 'PARTIAL_SUCCESS';
+export interface UnshieldedUpdate {
+    readonly createdUtxos: readonly UtxoWithMeta[];
+    readonly spentUtxos: readonly UtxoWithMeta[];
+    readonly status: UpdateStatus;
+}
+export interface UnshieldedState {
+    readonly availableUtxos: HashMap.HashMap<UtxoHash, UtxoWithMeta>;
+    readonly pendingUtxos: HashMap.HashMap<UtxoHash, UtxoWithMeta>;
+}
+export declare const UnshieldedState: {
+    readonly empty: () => UnshieldedState;
+    readonly restore: (availableUtxos: readonly UtxoWithMeta[], pendingUtxos: readonly UtxoWithMeta[]) => UnshieldedState;
+    readonly spend: (state: UnshieldedState, utxo: UtxoWithMeta) => Either.Either<UnshieldedState, UtxoNotFoundError>;
+    readonly rollbackSpend: (state: UnshieldedState, utxo: UtxoWithMeta) => Either.Either<UnshieldedState, UtxoNotFoundError>;
+    readonly spendByUtxo: (state: UnshieldedState, utxo: ledger.Utxo) => Either.Either<UnshieldedState, UtxoNotFoundError>;
+    readonly rollbackSpendByUtxo: (state: UnshieldedState, utxo: ledger.Utxo) => Either.Either<UnshieldedState, UtxoNotFoundError>;
+    readonly applyUpdate: (state: UnshieldedState, update: UnshieldedUpdate) => Either.Either<UnshieldedState, ApplyTransactionError>;
+    readonly applyFailedUpdate: (state: UnshieldedState, update: UnshieldedUpdate) => Either.Either<UnshieldedState, ApplyTransactionError>;
+    readonly toArrays: (state: UnshieldedState) => {
+        readonly availableUtxos: readonly UtxoWithMeta[];
+        readonly pendingUtxos: readonly UtxoWithMeta[];
+    };
+};

package/dist/v1/UnshieldedState.js

@@ -0,0 +1,67 @@
+import { Data, Either, HashMap } from 'effect';
+import { ApplyTransactionError, UtxoNotFoundError } from './WalletError.js';
+export class UtxoWithMeta extends Data.Class {
+}
+const UtxoHash = (utxo) => `${utxo.intentHash}#${utxo.outputNo}`;
+export const UnshieldedState = {
+    empty: () => ({
+        availableUtxos: HashMap.empty(),
+        pendingUtxos: HashMap.empty(),
+    }),
+    restore: (availableUtxos, pendingUtxos) => ({
+        availableUtxos: HashMap.fromIterable(availableUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo])),
+        pendingUtxos: HashMap.fromIterable(pendingUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo])),
+    }),
+    spend: (state, utxo) => Either.gen(function* () {
+        const hash = UtxoHash(utxo.utxo);
+        if (!HashMap.has(state.availableUtxos, hash)) {
+            return yield* Either.left(new UtxoNotFoundError({ utxo: utxo.utxo }));
+        }
+        return {
+            availableUtxos: HashMap.remove(state.availableUtxos, hash),
+            pendingUtxos: HashMap.set(state.pendingUtxos, hash, utxo),
+        };
+    }),
+    rollbackSpend: (state, utxo) => Either.gen(function* () {
+        const hash = UtxoHash(utxo.utxo);
+        if (!HashMap.has(state.pendingUtxos, hash)) {
+            return yield* Either.left(new UtxoNotFoundError({ utxo: utxo.utxo }));
+        }
+        return {
+            availableUtxos: HashMap.set(state.availableUtxos, hash, utxo),
+            pendingUtxos: HashMap.remove(state.pendingUtxos, hash),
+        };
+    }),
+    spendByUtxo: (state, utxo) => Either.gen(function* () {
+        const hash = UtxoHash(utxo);
+        const found = yield* Either.fromOption(HashMap.get(state.availableUtxos, hash), () => new UtxoNotFoundError({ utxo }));
+        return yield* UnshieldedState.spend(state, found);
+    }),
+    rollbackSpendByUtxo: (state, utxo) => Either.gen(function* () {
+        const hash = UtxoHash(utxo);
+        const found = yield* Either.fromOption(HashMap.get(state.pendingUtxos, hash), () => new UtxoNotFoundError({ utxo }));
+        return yield* UnshieldedState.rollbackSpend(state, found);
+    }),
+    applyUpdate: (state, update) => Either.gen(function* () {
+        if (!['SUCCESS', 'PARTIAL_SUCCESS'].includes(update.status)) {
+            return yield* Either.left(new ApplyTransactionError({ message: `Invalid status: ${update.status}` }));
+        }
+        return {
+            availableUtxos: HashMap.union(HashMap.removeMany(state.availableUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo))), HashMap.fromIterable(update.createdUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo]))),
+            pendingUtxos: HashMap.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo))),
+        };
+    }),
+    applyFailedUpdate: (state, update) => Either.gen(function* () {
+        if (update.status !== 'FAILURE') {
+            return yield* Either.left(new ApplyTransactionError({ message: `Invalid status: ${update.status}` }));
+        }
+        return {
+            availableUtxos: HashMap.union(state.availableUtxos, HashMap.fromIterable(update.spentUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo]))),
+            pendingUtxos: HashMap.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo))),
+        };
+    }),
+    toArrays: (state) => ({
+        availableUtxos: HashMap.toValues(state.availableUtxos),
+        pendingUtxos: HashMap.toValues(state.pendingUtxos),
+    }),
+};