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

package/dist/SyncService.js

@@ -1,88 +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 { Effect, Layer, Context, Stream, pipe, Schema, Data } from 'effect';
-import { UnshieldedTransactions } from '@midnight-ntwrk/wallet-sdk-indexer-client';
-import { UnshieldedTransactionSchema } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
-import { WsSubscriptionClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
-const TransactionSchema = Schema.Struct({
-    type: Schema.Literal('UnshieldedTransaction'),
-    transaction: UnshieldedTransactionSchema,
-});
-const ProgressSchema = Schema.Struct({
-    type: Schema.Literal('UnshieldedTransactionsProgress'),
-    highestTransactionId: Schema.Number,
-});
-export const UnshieldedUpdateSchema = Schema.Union(TransactionSchema, ProgressSchema);
-const UnshieldedUpdateDecoder = Schema.decodeUnknown(UnshieldedUpdateSchema);
-export class SyncServiceError extends Data.TaggedError('SyncServiceError') {
-}
-export class SyncService extends Context.Tag('@midnight-ntwrk/wallet-sdk-unshielded-wallet/SyncService')() {
-    static LiveWithIndexer = (indexerUrl) => {
-        const make = Effect.gen(function* () {
-            const indexerClient = yield* UnshieldedTransactions;
-            const startSync = (address, transactionId) => pipe(indexerClient({ address, transactionId }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerUrl })), Stream.mapEffect((message) => {
-                const { type } = message.unshieldedTransactions;
-                if (type === 'UnshieldedTransactionsProgress') {
-                    return UnshieldedUpdateDecoder({
-                        type,
-                        highestTransactionId: message.unshieldedTransactions.highestTransactionId,
-                    });
-                }
-                else {
-                    const { transaction, createdUtxos, spentUtxos } = message.unshieldedTransactions;
-                    const isRegularTransaction = transaction.type === 'RegularTransaction';
-                    const transactionResult = isRegularTransaction
-                        ? {
-                            status: transaction.transactionResult.status,
-                            segments: transaction.transactionResult.segments?.map((segment) => ({
-                                id: segment.id.toString(),
-                                success: segment.success,
-                            })) ?? null,
-                        }
-                        : null;
-                    return UnshieldedUpdateDecoder({
-                        type,
-                        transaction: {
-                            type: transaction.type,
-                            id: transaction.id,
-                            hash: transaction.hash,
-                            identifiers: isRegularTransaction ? transaction.identifiers : [],
-                            protocolVersion: transaction.protocolVersion,
-                            transactionResult,
-                            createdUtxos: createdUtxos.map((utxo) => ({
-                                value: utxo.value,
-                                owner: utxo.owner,
-                                type: utxo.tokenType,
-                                intentHash: utxo.intentHash,
-                                outputNo: utxo.outputIndex,
-                                registeredForDustGeneration: utxo.registeredForDustGeneration,
-                                ctime: utxo.ctime ? utxo.ctime * 1000 : undefined,
-                            })),
-                            spentUtxos: spentUtxos.map((utxo) => ({
-                                value: utxo.value,
-                                owner: utxo.owner,
-                                type: utxo.tokenType,
-                                intentHash: utxo.intentHash,
-                                outputNo: utxo.outputIndex,
-                                registeredForDustGeneration: utxo.registeredForDustGeneration,
-                                ctime: utxo.ctime ? utxo.ctime * 1000 : undefined,
-                            })),
-                        },
-                    });
-                }
-            }), Stream.mapError((error) => new SyncServiceError({ error })));
-            return SyncService.of({ startSync });
-        });
-        return Layer.effect(SyncService, make);
-    };
-}

package/dist/TransactionHistoryService.d.ts

@@ -1,31 +0,0 @@
-import { Effect, Layer, Context, Stream } from 'effect';
-import { TransactionHash, TransactionHistoryEntry, TransactionHistoryStorage } from './tx-history-storage/index.js';
-declare const TransactionHistoryServiceError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "TransactionHistoryServiceError";
-} & Readonly<A>;
-export declare class TransactionHistoryServiceError extends TransactionHistoryServiceError_base<{
-    readonly error?: unknown;
-}> {
-    toString(): string;
-}
-export type TransactionHistoryChange = {
-    type: 'created' | 'updated' | 'deleted';
-    entry: TransactionHistoryEntry;
-};
-/**
- * TransactionHistoryService API
- *
- * Extend with tx lifecycle methods when needed in the future.
- */
-export interface TransactionHistoryServiceAPI {
-    create: (item: TransactionHistoryEntry) => Effect.Effect<void, TransactionHistoryServiceError>;
-    delete: (hash: TransactionHash) => Effect.Effect<void, TransactionHistoryServiceError>;
-    getAll: () => Stream.Stream<TransactionHistoryEntry, TransactionHistoryServiceError>;
-    get: (hash: TransactionHash) => Effect.Effect<TransactionHistoryEntry | undefined, TransactionHistoryServiceError>;
-    changes: Stream.Stream<TransactionHistoryChange | undefined>;
-}
-declare const TransactionHistoryService_base: Context.TagClass<TransactionHistoryService, "@midnight-ntwrk/wallet-sdk-unshielded-wallet/TransactionHistoryService", TransactionHistoryServiceAPI>;
-export declare class TransactionHistoryService extends TransactionHistoryService_base {
-    static readonly Live: (storage: TransactionHistoryStorage) => Layer.Layer<TransactionHistoryService>;
-}
-export {};

package/dist/TransactionHistoryService.js

@@ -1,49 +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 { Effect, Layer, Context, Data, SubscriptionRef, Stream } from 'effect';
-export class TransactionHistoryServiceError extends Data.TaggedError('TransactionHistoryServiceError') {
-    toString() {
-        return `TransactionHistoryServiceError: ${this.error instanceof Error ? this.error.toString() : 'Unknown error'}`;
-    }
-}
-export class TransactionHistoryService extends Context.Tag('@midnight-ntwrk/wallet-sdk-unshielded-wallet/TransactionHistoryService')() {
-    static Live = (storage) => Layer.effect(TransactionHistoryService, Effect.gen(function* () {
-        const txHistoryRef = yield* SubscriptionRef.make(undefined);
-        return {
-            create: (entry) => Effect.tryPromise({
-                try: async () => storage.create(entry),
-                catch: (error) => new TransactionHistoryServiceError({ error }),
-            }).pipe(Effect.tap(() => SubscriptionRef.set(txHistoryRef, {
-                type: 'created',
-                entry,
-            }))),
-            delete: (hash) => Effect.tryPromise({
-                try: async () => {
-                    const deletedEntry = await storage.get(hash);
-                    await storage.delete(hash);
-                    SubscriptionRef.set(txHistoryRef, {
-                        type: 'deleted',
-                        entry: deletedEntry,
-                    });
-                },
-                catch: (error) => new TransactionHistoryServiceError({ error }),
-            }),
-            getAll: () => Stream.fromAsyncIterable(storage.getAll(), () => new TransactionHistoryServiceError({ error: 'Failed to get all transactions' })),
-            get: (hash) => Effect.tryPromise({
-                try: async () => await storage.get(hash),
-                catch: (error) => new TransactionHistoryServiceError({ error }),
-            }),
-            changes: txHistoryRef.changes,
-        };
-    }));
-}

package/dist/TransactionService.d.ts

@@ -1,43 +0,0 @@
-import { Effect, Layer, Context } from 'effect';
-import { ParseError } from 'effect/ParseResult';
-import { UnshieldedStateAPI, UtxoNotFoundError } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
-import { Binding, PreBinding, type Bindingish, type PreProof, type Proofish, type SignatureEnabled, type Signaturish, Transaction, type RawTokenType, type UserAddress } from '@midnight-ntwrk/ledger-v6';
-import { SignatureVerifyingKey } from '@midnight-ntwrk/ledger-v6';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
-export type TokenTransfer = {
-    readonly amount: bigint;
-    readonly type: string;
-    readonly receiverAddress: string;
-};
-declare const DeserializationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "DeserializationError";
-} & Readonly<A>;
-export declare class DeserializationError extends DeserializationError_base<{
-    readonly message: string;
-    readonly internal?: unknown;
-}> {
-}
-declare const TransactionServiceError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "TransactionServiceError";
-} & Readonly<A>;
-export declare class TransactionServiceError extends TransactionServiceError_base<{
-    readonly message: string;
-    readonly cause?: unknown;
-}> {
-}
-export interface TransactionServiceLive {
-    readonly transferTransaction: (outputs: TokenTransfer[], ttl: Date, networkId: NetworkId.NetworkId) => Effect.Effect<Transaction<SignatureEnabled, PreProof, PreBinding>, TransactionServiceError>;
-    readonly initSwap: (desiredInputs: Record<RawTokenType, bigint>, desiredOutputs: TokenTransfer[], ttl: Date, networkId: NetworkId.NetworkId, state: UnshieldedStateAPI, myAddress: UserAddress, publicKey: SignatureVerifyingKey) => Effect.Effect<Transaction<SignatureEnabled, PreProof, PreBinding>, TransactionServiceError | ParseError | UtxoNotFoundError>;
-    readonly deserializeTransaction: <S extends Signaturish, P extends Proofish, B extends Bindingish>(markerS: S['instance'], markerP: P['instance'], markerB: B['instance'], tx: string) => Effect.Effect<Transaction<S, P, B>, DeserializationError>;
-    readonly serializeTransaction: (transaction: Transaction<Signaturish, Proofish, Bindingish>) => Effect.Effect<string, TransactionServiceError>;
-    readonly balanceTransaction: (transaction: Transaction<SignatureEnabled, Proofish, Bindingish>, state: UnshieldedStateAPI, myAddress: UserAddress, publicKey: SignatureVerifyingKey) => Effect.Effect<Transaction<SignatureEnabled, Proofish, Bindingish>, TransactionServiceError | ParseError | UtxoNotFoundError>;
-    readonly getOfferSignatureData: (transaction: Transaction<Signaturish, Proofish, Bindingish>, segment: number) => Effect.Effect<Uint8Array, TransactionServiceError>;
-    readonly addOfferSignature: <S extends Signaturish, P extends Proofish, B extends Bindingish>(transaction: Transaction<S, P, B>, signature: string, segment: number) => Effect.Effect<Transaction<S, P, B>, TransactionServiceError>;
-    readonly bindTransaction: <S extends Signaturish, P extends Proofish, B extends Bindingish>(transaction: Transaction<S, P, B>) => Effect.Effect<Transaction<S, P, Binding>, TransactionServiceError>;
-    readonly getSegments: (transaction: Transaction<Signaturish, Proofish, Bindingish>) => number[];
-}
-declare const TransactionService_base: Context.TagClass<TransactionService, "@midnight-ntwrk/wallet-sdk-unshielded-wallet/TransactionService", TransactionServiceLive>;
-export declare class TransactionService extends TransactionService_base {
-    static readonly Live: Layer.Layer<TransactionService>;
-}
-export {};

package/dist/TransactionService.js

@@ -1,291 +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.
-/* temporarily disable eslint until we upgrade to ledger 6 */
-import { Effect, Layer, Context, Data, HashSet, pipe, Option, Either } from 'effect';
-import { getBalanceRecipe, Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { Binding, Transaction, Intent, UnshieldedOffer, } from '@midnight-ntwrk/ledger-v6';
-export class DeserializationError extends Data.TaggedError('DeserializationError') {
-}
-export class TransactionServiceError extends Data.TaggedError('TransactionServiceError') {
-}
-const GUARANTEED_SEGMENT = 0;
-const ledgerTry = (fn) => {
-    return Either.try({
-        try: fn,
-        catch: (error) => {
-            // eslint-disable-next-line no-console
-            console.log('Error from ledger', error);
-            const message = error instanceof Error ? error.message : `${error?.toString()}`;
-            return new TransactionServiceError({ message: `Error from ledger: ${message}`, cause: error });
-        },
-    });
-};
-const isIntentBound = (intent) => {
-    return ledgerTry(() => intent.binding instanceof Binding);
-};
-const mergeCounterOffer = (counterOffer, currentOffer) => pipe(Option.fromNullable(currentOffer), Option.match({
-    onNone: () => Either.right(counterOffer),
-    onSome: (currentOffer) => ledgerTry(() => UnshieldedOffer.new([...currentOffer.inputs, ...counterOffer.inputs], [...currentOffer.outputs, ...counterOffer.outputs], [...currentOffer.signatures, ...counterOffer.signatures])),
-}));
-export class TransactionService extends Context.Tag('@midnight-ntwrk/wallet-sdk-unshielded-wallet/TransactionService')() {
-    static Live = Layer.succeed(TransactionService, (() => {
-        const transferTransaction = (desiredOutputs, ttl, networkId) => Effect.gen(function* () {
-            const isValid = desiredOutputs.every((output) => output.amount > 0n);
-            if (!isValid) {
-                return yield* Effect.fail(new TransactionServiceError({ message: 'The amount needs to be positive' }));
-            }
-            const ledgerOutputs = desiredOutputs.map((output) => {
-                return {
-                    value: output.amount,
-                    owner: output.receiverAddress,
-                    type: output.type,
-                };
-            });
-            return yield* ledgerTry(() => {
-                const intent = Intent.new(ttl);
-                intent.guaranteedUnshieldedOffer = UnshieldedOffer.new([], ledgerOutputs, []);
-                return Transaction.fromParts(networkId, undefined, undefined, intent);
-            });
-        });
-        const initSwap = (desiredInputs, desiredOutputs, ttl, networkId, state, myAddress, publicKey) => Effect.gen(function* () {
-            const outputsValid = desiredOutputs.every((output) => output.amount > 0n);
-            if (!outputsValid) {
-                return yield* Effect.fail(new TransactionServiceError({ message: 'The amount needs to be positive' }));
-            }
-            const inputsValid = Object.entries(desiredInputs).every(([, amount]) => amount > 0n);
-            if (!inputsValid) {
-                return yield* Effect.fail(new TransactionServiceError({ message: 'The input amounts need to be positive' }));
-            }
-            const ledgerOutputs = desiredOutputs.map((output) => ({
-                value: output.amount,
-                owner: output.receiverAddress,
-                type: output.type,
-            }));
-            const targetImbalances = Imbalances.fromEntries(Object.entries(desiredInputs));
-            const latestState = yield* state.getLatestState();
-            const availableCoins = HashSet.toValues(latestState.utxos);
-            const { inputs, outputs: changeOutputs } = yield* Effect.try({
-                try: () => getBalanceRecipe({
-                    coins: availableCoins,
-                    initialImbalances: Imbalances.empty(),
-                    feeTokenType: '',
-                    transactionCostModel: {
-                        inputFeeOverhead: 0n,
-                        outputFeeOverhead: 0n,
-                    },
-                    createOutput: (coin) => ({
-                        ...coin,
-                        owner: myAddress,
-                    }),
-                    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 TransactionServiceError({ message });
-                },
-            });
-            for (const input of inputs) {
-                yield* state.spend(input);
-            }
-            const ledgerInputs = inputs.map((input) => ({
-                ...input,
-                owner: publicKey,
-            }));
-            const offer = yield* ledgerTry(() => UnshieldedOffer.new(ledgerInputs, [...changeOutputs, ...ledgerOutputs], []));
-            const intent = Intent.new(ttl);
-            intent.guaranteedUnshieldedOffer = offer;
-            return yield* ledgerTry(() => Transaction.fromParts(networkId, undefined, undefined, intent));
-        });
-        const deserializeTransaction = (markerS, markerP, markerB, tx) => 
-        // NOTE: ledger's deserialization error is too of a low-level and doesn't tell us what exactly was wrong
-        Effect.mapError(ledgerTry(() => {
-            const data = Buffer.from(tx, 'hex');
-            return Transaction.deserialize(markerS, markerP, markerB, data);
-        }), (e) => new DeserializationError({ message: 'Unable to deserialize transaction', internal: e.message }));
-        const serializeTransaction = (transaction) => Effect.map(ledgerTry(() => transaction.serialize()), (res) => Buffer.from(res).toString('hex'));
-        const balanceTransaction = (transaction, state, myAddress, publicKey) => Effect.gen(function* () {
-            const segments = getSegments(transaction);
-            if (!transaction.intents || !transaction.intents.size || !segments.length) {
-                return transaction;
-            }
-            for (const segment of [...segments, GUARANTEED_SEGMENT]) {
-                const allIntentImbalances = yield* ledgerTry(() => transaction.imbalances(segment));
-                const imbalances = allIntentImbalances
-                    .entries()
-                    .filter(([token, value]) => token.tag === 'unshielded' && value !== 0n)
-                    .map(([token, value]) => {
-                    return [token.raw.toString(), value];
-                })
-                    .toArray();
-                // intent is balanced
-                if (!imbalances.length)
-                    continue;
-                const latestState = yield* state.getLatestState();
-                const availableCoins = HashSet.toValues(latestState.utxos);
-                // select inputs, receive the change outputs
-                const { inputs, outputs: changeOutputs } = yield* Effect.try({
-                    try: () => getBalanceRecipe({
-                        coins: availableCoins,
-                        initialImbalances: Imbalances.fromEntries(imbalances),
-                        feeTokenType: '',
-                        transactionCostModel: {
-                            inputFeeOverhead: 0n,
-                            outputFeeOverhead: 0n,
-                        },
-                        createOutput: (coin) => ({
-                            ...coin,
-                            owner: myAddress,
-                        }),
-                        isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
-                    }),
-                    catch: (error) => {
-                        const message = error instanceof Error ? error.message : error?.toString() || '';
-                        return new TransactionServiceError({ message });
-                    },
-                });
-                if (!inputs.length) {
-                    return yield* Effect.fail(new TransactionServiceError({ message: 'No coins found to spend' }));
-                }
-                // mark the coins as spent
-                for (const input of inputs) {
-                    yield* state.spend(input);
-                }
-                const ledgerInputs = inputs.map((input) => ({
-                    ...input,
-                    intentHash: input.intentHash,
-                    owner: publicKey,
-                }));
-                const counterOffer = yield* ledgerTry(() => UnshieldedOffer.new(ledgerInputs, changeOutputs, []));
-                // 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 = yield* isIntentBound(intent);
-                    if (!isBound && intent.fallibleUnshieldedOffer) {
-                        const mergedOffer = yield* mergeCounterOffer(counterOffer, intent.fallibleUnshieldedOffer);
-                        yield* ledgerTry(() => {
-                            intent.fallibleUnshieldedOffer = mergedOffer;
-                            transaction.intents = transaction.intents.set(segment, intent);
-                        });
-                    }
-                    else {
-                        // create a new offer if the intent is bound
-                        yield* ledgerTry(() => {
-                            const nextSegment = Math.max(...getSegments(transaction)) + 1;
-                            const newIntent = Intent.new(intent.ttl);
-                            newIntent.fallibleUnshieldedOffer = counterOffer;
-                            transaction.intents = transaction.intents.set(nextSegment, newIntent);
-                        });
-                    }
-                }
-                else {
-                    let ttl;
-                    let updated = false;
-                    // try to find and modify any unbound intent first
-                    const segments = getSegments(transaction);
-                    for (const segment of segments) {
-                        const intent = transaction.intents.get(segment);
-                        ttl = intent.ttl;
-                        const isBound = yield* isIntentBound(intent);
-                        if (!isBound) {
-                            const mergedOffer = yield* mergeCounterOffer(counterOffer, intent.guaranteedUnshieldedOffer);
-                            yield* ledgerTry(() => {
-                                intent.guaranteedUnshieldedOffer = mergedOffer;
-                                transaction.intents = transaction.intents.set(segment, intent);
-                            });
-                            updated = true;
-                            break;
-                        }
-                    }
-                    // no unbound intents found, insert a new one
-                    if (!updated) {
-                        yield* ledgerTry(() => {
-                            const nextSegment = Math.max(...segments) + 1;
-                            const newIntent = Intent.new(ttl);
-                            newIntent.guaranteedUnshieldedOffer = counterOffer;
-                            transaction.intents = transaction.intents.set(nextSegment, newIntent);
-                        });
-                    }
-                }
-            }
-            return transaction;
-        });
-        const getOfferSignatureData = (transaction, segment = 1) => {
-            if (!transaction.intents) {
-                return Effect.fail(new TransactionServiceError({ message: 'No intents found in the provided transaction' }));
-            }
-            const intent = transaction.intents.get(segment);
-            if (!intent) {
-                return Effect.fail(new TransactionServiceError({ message: 'Intent with a given segment was not found' }));
-            }
-            return pipe(ledgerTry(() => (isIntentBound(intent) ? intent : intent.bind(segment))), Effect.andThen((boundIntent) => ledgerTry(() => boundIntent.signatureData(segment))));
-        };
-        const addOfferSignature = (transaction, signature, segment = 1) => Effect.gen(function* () {
-            if (!transaction.intents || !transaction.intents.size) {
-                return yield* Effect.fail(new TransactionServiceError({ message: 'No intents found in the provided transaction' }));
-            }
-            const intent = transaction.intents.get(segment);
-            if (!intent) {
-                return yield* Effect.fail(new TransactionServiceError({ message: 'Intent with a given segment was not found' }));
-            }
-            // skip if it's locked
-            const isBound = yield* 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);
-                }
-                const updatedOffer = yield* ledgerTry(() => offer.addSignatures(signatures));
-                updatedIntent = yield* ledgerTry(() => {
-                    updatedIntent.guaranteedUnshieldedOffer = updatedOffer;
-                    return updatedIntent;
-                });
-            }
-            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);
-                }
-                const updatedOffer = yield* ledgerTry(() => offer.addSignatures(signatures));
-                updatedIntent = yield* ledgerTry(() => {
-                    updatedIntent.fallibleUnshieldedOffer = updatedOffer;
-                    return updatedIntent;
-                });
-            }
-            transaction.intents = yield* ledgerTry(() => transaction.intents.set(segment, updatedIntent));
-            return transaction;
-        });
-        const bindTransaction = (transaction) => ledgerTry(() => transaction.bind());
-        const getSegments = (transaction) => {
-            return transaction.intents ? [...transaction.intents.keys()] : [];
-        };
-        return TransactionService.of({
-            transferTransaction,
-            initSwap,
-            deserializeTransaction,
-            serializeTransaction,
-            balanceTransaction,
-            getOfferSignatureData,
-            addOfferSignature,
-            bindTransaction,
-            getSegments,
-        });
-    })());
-}

package/dist/WalletBuilder.d.ts

@@ -1,37 +0,0 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { Observable } from 'rxjs';
-import { PublicKey } from './KeyStore.js';
-import { State } from './State.js';
-import { TransactionHistoryChange } from './TransactionHistoryService.js';
-import { TokenTransfer } from './TransactionService.js';
-import { TransactionHash, TransactionHistoryEntry, TransactionHistoryStorage } from './tx-history-storage/index.js';
-interface WalletConfig {
-    publicKey: PublicKey;
-    networkId: NetworkId.NetworkId;
-    indexerUrl: string;
-    txHistoryStorage?: TransactionHistoryStorage | undefined;
-}
-export interface UnshieldedWallet {
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    serializeState(): Promise<string>;
-    state: () => Observable<State>;
-    transferTransaction(outputs: TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
-    initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
-    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Promise<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
-    signTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
-    transactionHistory: undefined | {
-        get: (item: TransactionHash) => Promise<TransactionHistoryEntry | undefined>;
-        getAll: () => Observable<TransactionHistoryEntry>;
-        changes: () => Observable<TransactionHistoryChange | undefined>;
-    };
-}
-interface RestorableWalletConfig extends WalletConfig {
-    serializedState: string;
-}
-export declare class WalletBuilder {
-    static build({ publicKey, networkId, indexerUrl, txHistoryStorage }: WalletConfig): Promise<UnshieldedWallet>;
-    static restore({ publicKey, networkId, indexerUrl, serializedState, txHistoryStorage, }: RestorableWalletConfig): Promise<UnshieldedWallet>;
-}
-export {};