@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.11

package/README.md

@@ -0,0 +1,3 @@
+# Wallet SDK Unshielded Wallet
+
+TBD

package/dist/KeyStore.d.ts

@@ -0,0 +1,23 @@
+import { UnshieldedAddress, MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { Signature, SignatureVerifyingKey, UserAddress } from '@midnight-ntwrk/ledger-v6';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+export type PublicKey = {
+    publicKey: SignatureVerifyingKey;
+    address: UnshieldedAddress;
+};
+export declare const PublicKey: {
+    fromKeyStore: (keystore: UnshieldedKeystore) => PublicKey;
+};
+export interface UnshieldedKeystore {
+    getSecretKey(): Buffer;
+    getBech32Address(): MidnightBech32m;
+    getPublicKey(): SignatureVerifyingKey;
+    getAddress(): UserAddress;
+    signData(data: Uint8Array): Signature;
+}
+export interface Keystore {
+    keystore: UnshieldedKeystore;
+    getBech32Address(): MidnightBech32m;
+    getPublicKey(): SignatureVerifyingKey;
+}
+export declare const createKeystore: (secretKey: Uint8Array<ArrayBufferLike>, networkId: NetworkId.NetworkId) => UnshieldedKeystore;

package/dist/KeyStore.js

@@ -0,0 +1,25 @@
+import { UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { addressFromKey, signData, signatureVerifyingKey, } from '@midnight-ntwrk/ledger-v6';
+import { pipe } from 'effect';
+export const PublicKey = {
+    fromKeyStore: (keystore) => {
+        return {
+            publicKey: keystore.getPublicKey(),
+            address: pipe(keystore.getAddress(), (str) => Buffer.from(str, 'hex'), (bytes) => new UnshieldedAddress(bytes)),
+        };
+    },
+};
+export const createKeystore = (secretKey, networkId) => {
+    const keystore = {
+        getSecretKey: () => Buffer.from(secretKey),
+        getBech32Address: () => {
+            const address = keystore.getAddress();
+            const addressBuffer = Buffer.from(address, 'hex');
+            return UnshieldedAddress.codec.encode(networkId, new UnshieldedAddress(addressBuffer));
+        },
+        getPublicKey: () => signatureVerifyingKey(keystore.getSecretKey().toString('hex')),
+        getAddress: () => addressFromKey(keystore.getPublicKey()),
+        signData: (data) => signData(keystore.getSecretKey().toString('hex'), data),
+    };
+    return keystore;
+};

package/dist/State.d.ts

@@ -0,0 +1,21 @@
+import { Effect, Stream } from 'effect';
+import { UnshieldedStateAPI, Utxo } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
+import { ParseError } from 'effect/ParseResult';
+export interface State {
+    address: string;
+    balances: Map<string, bigint>;
+    pendingCoins: readonly Utxo[];
+    availableCoins: readonly Utxo[];
+    totalCoins: readonly Utxo[];
+    syncProgress: {
+        applyGap: number;
+        synced: boolean;
+    } | undefined;
+}
+export declare class StateImpl {
+    unshieldedState: UnshieldedStateAPI;
+    address: string;
+    constructor(unshieldedState: UnshieldedStateAPI, address: string);
+    updates(): Stream.Stream<State>;
+    serialize(): Effect.Effect<string, ParseError>;
+}

package/dist/State.js

@@ -0,0 +1,31 @@
+import { Effect, HashSet, pipe, Stream } from 'effect';
+import { UnshieldedStateEncoder } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
+export class StateImpl {
+    unshieldedState;
+    address;
+    constructor(unshieldedState, address) {
+        this.unshieldedState = unshieldedState;
+        this.address = address;
+    }
+    updates() {
+        return this.unshieldedState.state.pipe(Stream.map((state) => ({
+            address: this.address,
+            balances: HashSet.reduce(state.utxos, new Map(), (acc, utxo) => {
+                acc.set(utxo.type, (acc.get(utxo.type) || 0n) + utxo.value);
+                return acc;
+            }),
+            pendingCoins: HashSet.toValues(state.pendingUtxos),
+            availableCoins: HashSet.toValues(state.utxos),
+            totalCoins: HashSet.toValues(HashSet.union(state.utxos, state.pendingUtxos)),
+            syncProgress: state.syncProgress
+                ? {
+                    applyGap: (state.syncProgress?.highestTransactionId ?? 0) - (state.syncProgress?.currentTransactionId ?? 0),
+                    synced: state.syncProgress?.highestTransactionId === state.syncProgress?.currentTransactionId,
+                }
+                : undefined,
+        })));
+    }
+    serialize() {
+        return pipe(this.unshieldedState.getLatestState(), Effect.flatMap((state) => UnshieldedStateEncoder(state)), Effect.map((encoded) => JSON.stringify(encoded)));
+    }
+}

package/dist/SyncService.d.ts

@@ -0,0 +1,55 @@
+import { Layer, Context, Stream, Schema, Scope } from 'effect';
+export declare const UnshieldedUpdateSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransaction"]>;
+    transaction: Schema.Data<Schema.Struct<{
+        id: typeof Schema.Number;
+        hash: typeof Schema.String;
+        type: Schema.Literal<["RegularTransaction", "SystemTransaction"]>;
+        protocolVersion: typeof Schema.Number;
+        identifiers: Schema.Array$<typeof Schema.String>;
+        transactionResult: Schema.NullOr<Schema.Struct<{
+            status: typeof Schema.String;
+            segments: Schema.NullOr<Schema.Array$<Schema.Struct<{
+                id: typeof Schema.String;
+                success: typeof Schema.Boolean;
+            }>>>;
+        }>>;
+        createdUtxos: Schema.Array$<Schema.Data<Schema.Struct<{
+            value: Schema.Schema<bigint, string, never>;
+            owner: typeof Schema.String;
+            type: typeof Schema.String;
+            intentHash: typeof Schema.String;
+            outputNo: typeof Schema.Number;
+            ctime: typeof Schema.Number;
+            registeredForDustGeneration: typeof Schema.Boolean;
+        }>>>;
+        spentUtxos: Schema.Array$<Schema.Data<Schema.Struct<{
+            value: Schema.Schema<bigint, string, never>;
+            owner: typeof Schema.String;
+            type: typeof Schema.String;
+            intentHash: typeof Schema.String;
+            outputNo: typeof Schema.Number;
+            ctime: typeof Schema.Number;
+            registeredForDustGeneration: typeof Schema.Boolean;
+        }>>>;
+    }>>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["UnshieldedTransactionsProgress"]>;
+    highestTransactionId: typeof Schema.Number;
+}>]>;
+export type UnshieldedUpdate = Schema.Schema.Type<typeof UnshieldedUpdateSchema>;
+declare const SyncServiceError_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: "SyncServiceError";
+} & Readonly<A>;
+export declare class SyncServiceError extends SyncServiceError_base<{
+    readonly error?: unknown;
+}> {
+}
+export interface SyncServiceLive {
+    readonly startSync: (address: string, transactionId: number) => Stream.Stream<UnshieldedUpdate, SyncServiceError, Scope.Scope>;
+}
+declare const SyncService_base: Context.TagClass<SyncService, "@midnight-ntwrk/wallet-sdk-unshielded-wallet/SyncService", SyncServiceLive>;
+export declare class SyncService extends SyncService_base {
+    static readonly LiveWithIndexer: (indexerUrl: string) => Layer.Layer<SyncService>;
+}
+export {};

package/dist/SyncService.js

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

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

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

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

@@ -0,0 +1,279 @@
+/* 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

@@ -0,0 +1,37 @@
+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 {};

package/dist/WalletBuilder.js

@@ -0,0 +1,137 @@
+import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { UnshieldedStateDecoder, UnshieldedStateService } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
+import { ObservableOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { Deferred, Effect, Either, Fiber, Layer, pipe, Stream } from 'effect';
+import { StateImpl } from './State.js';
+import { SyncService } from './SyncService.js';
+import { TransactionHistoryService } from './TransactionHistoryService.js';
+import { TransactionService } from './TransactionService.js';
+import { NoOpTransactionHistoryStorage } from './tx-history-storage/NoOpTransactionHistoryStorage.js';
+const makeWallet = ({ publicKey, networkId, txHistoryStorage, }) => Effect.gen(function* () {
+    const syncService = yield* SyncService;
+    const transactionHistoryService = yield* TransactionHistoryService;
+    const unshieldedState = yield* UnshieldedStateService;
+    const transactionService = yield* TransactionService;
+    // TODO: Scope would be a preferred way to handle controlled stop
+    const stopLatch = yield* Deferred.make();
+    const bech32mAddress = UnshieldedAddress.codec.encode(networkId, publicKey.address);
+    const state = new StateImpl(unshieldedState, bech32mAddress.asString());
+    const applyUpdate = (update) => Effect.gen(function* () {
+        const { type } = update;
+        if (type === 'UnshieldedTransaction') {
+            const { transaction } = update;
+            yield* unshieldedState.applyTx(update.transaction);
+            yield* transactionHistoryService.create({
+                id: transaction.id,
+                hash: transaction.hash,
+                protocolVersion: transaction.protocolVersion,
+                identifiers: transaction.identifiers ?? [],
+                transactionResult: transaction.transactionResult
+                    ? {
+                        status: transaction.transactionResult.status,
+                        segments: transaction.transactionResult.segments ?? [],
+                    }
+                    : null,
+            });
+        }
+        if (type === 'UnshieldedTransactionsProgress') {
+            yield* unshieldedState.updateSyncProgress(update.highestTransactionId);
+        }
+    });
+    const start = () => Effect.gen(function* () {
+        const latestState = yield* unshieldedState.getLatestState();
+        const fiber = yield* pipe(syncService.startSync(bech32mAddress.asString(), latestState.syncProgress?.highestTransactionId ?? 0), Stream.tapError((error) => Effect.gen(function* () {
+            // eslint-disable-next-line no-console
+            yield* Effect.sync(() => console.error(error));
+            yield* Deferred.die(stopLatch, error);
+        })), Stream.runForEach(applyUpdate), Effect.fork);
+        yield* Deferred.await(stopLatch).pipe(Effect.andThen(Fiber.interrupt(fiber)));
+    });
+    const stop = () => Deferred.succeed(stopLatch, undefined).pipe(Effect.asVoid);
+    const transferTransaction = (outputs, ttl) => Effect.gen(function* () {
+        const latestState = yield* unshieldedState.getLatestState();
+        if (!latestState.syncProgress) {
+            return yield* Effect.fail('Unable to get the latest block number');
+        }
+        const mappedOutputs = outputs.map((output) => ({
+            ...output,
+            receiverAddress: UnshieldedAddress.codec
+                .decode(networkId, MidnightBech32m.parse(output.receiverAddress))
+                .data.toString('hex'),
+        }));
+        const transaction = yield* transactionService.transferTransaction(mappedOutputs, ttl, networkId);
+        return (yield* transactionService.balanceTransaction(transaction, unshieldedState, publicKey.address.hexString, publicKey.publicKey));
+    });
+    const initSwap = (desiredInputs, outputs, ttl) => Effect.gen(function* () {
+        const latestState = yield* unshieldedState.getLatestState();
+        if (!latestState.syncProgress) {
+            return yield* Effect.fail('Unable to get the latest block number');
+        }
+        const mappedOutputs = outputs.map((output) => ({
+            ...output,
+            receiverAddress: UnshieldedAddress.codec
+                .decode(networkId, MidnightBech32m.parse(output.receiverAddress))
+                .data.toString('hex'),
+        }));
+        return yield* transactionService.initSwap(desiredInputs, mappedOutputs, ttl, networkId, unshieldedState, publicKey.address.hexString, publicKey.publicKey);
+    });
+    const balanceTransaction = (tx) => transactionService.balanceTransaction(tx, unshieldedState, publicKey.address.hexString, publicKey.publicKey);
+    const signTransaction = (tx, signSegment) => Effect.gen(function* () {
+        const segments = transactionService.getSegments(tx);
+        if (!segments.length) {
+            return yield* Effect.fail('No segments found in the provided transaction');
+        }
+        for (const segment of segments) {
+            const data = yield* transactionService.getOfferSignatureData(tx, segment);
+            const signature = yield* signSegment(data);
+            tx = yield* transactionService.addOfferSignature(tx, signature, segment);
+        }
+        // return yield* transactionService.bindTransaction(tx);
+        return tx;
+    });
+    const transactionHistory = txHistoryStorage
+        ? {
+            get: (hash) => Effect.runPromise(transactionHistoryService.get(hash)),
+            getAll: () => ObservableOps.fromStream(transactionHistoryService.getAll()),
+            changes: () => ObservableOps.fromStream(transactionHistoryService.changes),
+        }
+        : undefined;
+    const result = {
+        state: () => ObservableOps.fromStream(state.updates()),
+        start: () => {
+            return new Promise((resolve) => {
+                Effect.runFork(Effect.scoped(start()));
+                resolve(void 0);
+            });
+        },
+        stop: () => Effect.runPromise(stop()),
+        transferTransaction: (outputs, ttl) => Effect.runPromise(transferTransaction(outputs, ttl)),
+        initSwap: (desiredInputs, desiredOutputs, ttl) => Effect.runPromise(initSwap(desiredInputs, desiredOutputs, ttl)),
+        balanceTransaction: (tx) => Effect.runPromise(balanceTransaction(tx)),
+        signTransaction: (tx, signSegment) => Effect.runPromise(signTransaction(tx, (data) => Effect.try(() => signSegment(data)))),
+        serializeState: () => Effect.runPromise(state.serialize()),
+        transactionHistory,
+    };
+    return result;
+});
+export class WalletBuilder {
+    static async build({ publicKey, networkId, indexerUrl, txHistoryStorage }) {
+        const txHistoryService = TransactionHistoryService.Live(txHistoryStorage ? txHistoryStorage : new NoOpTransactionHistoryStorage());
+        const layers = Layer.mergeAll(SyncService.LiveWithIndexer(indexerUrl), UnshieldedStateService.Live(), TransactionService.Live, txHistoryService);
+        const walletService = makeWallet({ publicKey, networkId, txHistoryStorage });
+        const wallet = walletService.pipe(Effect.provide(layers));
+        return Effect.runPromise(wallet);
+    }
+    static async restore({ publicKey, networkId, indexerUrl, serializedState, txHistoryStorage, }) {
+        const parsedState = JSON.parse(serializedState);
+        const decodedState = UnshieldedStateDecoder(parsedState);
+        if (Either.isLeft(decodedState)) {
+            throw new Error(`Failed to decode unshielded state: ${decodedState.left.message}`);
+        }
+        const txHistoryService = TransactionHistoryService.Live(txHistoryStorage ? txHistoryStorage : new NoOpTransactionHistoryStorage());
+        const layer = Layer.mergeAll(SyncService.LiveWithIndexer(indexerUrl), UnshieldedStateService.LiveWithState(decodedState.right), TransactionService.Live, txHistoryService);
+        const walletService = makeWallet({ publicKey, networkId, txHistoryStorage });
+        const wallet = walletService.pipe(Effect.provide(layer));
+        return Effect.runPromise(wallet);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './WalletBuilder.js';
+export { State as UnshieldedWalletState } from './State.js';
+export { PublicKey, createKeystore, UnshieldedKeystore, Keystore } from './KeyStore.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './WalletBuilder.js';
+export { PublicKey, createKeystore } from './KeyStore.js';

package/dist/tx-history-storage/InMemoryTransactionHistoryStorage.d.ts

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+import { TransactionHistoryStorage, TransactionHistoryEntry, TransactionHash } from './TransactionHistoryStorage.js';
+declare const TransactionHistorySchema: Schema.Map$<typeof Schema.String, Schema.Struct<{
+    id: typeof Schema.Number;
+    hash: typeof Schema.String;
+    protocolVersion: typeof Schema.Number;
+    identifiers: Schema.Array$<typeof Schema.String>;
+    transactionResult: Schema.NullOr<Schema.Struct<{
+        status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+        segments: Schema.Array$<Schema.Struct<{
+            id: typeof Schema.String;
+            success: typeof Schema.Boolean;
+        }>>;
+    }>>;
+}>>;
+export type TransactionHistory = Schema.Schema.Type<typeof TransactionHistorySchema>;
+/**
+ * In-memory implementation of the TransactionHistoryStorage interface.
+ *
+ * TODO: Implement update method with callback api when needed in the future
+ */
+export declare class InMemoryTransactionHistoryStorage implements TransactionHistoryStorage {
+    private entries;
+    constructor(entries?: TransactionHistory);
+    create(entry: TransactionHistoryEntry): Promise<void>;
+    delete(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    getAll(): AsyncIterableIterator<TransactionHistoryEntry>;
+    get(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    serialize(): string;
+    reset(): void;
+    static fromSerialized(serializedHistory: string): InMemoryTransactionHistoryStorage;
+}
+export {};

package/dist/tx-history-storage/InMemoryTransactionHistoryStorage.js

@@ -0,0 +1,53 @@
+import { Either, Schema } from 'effect';
+import { TransactionHistoryEntrySchema, } from './TransactionHistoryStorage.js';
+const TransactionHistorySchema = Schema.Map({
+    key: Schema.String,
+    value: TransactionHistoryEntrySchema,
+});
+const TransactionHistoryEncoder = Schema.encodeSync(TransactionHistorySchema);
+const TransactionHistoryDecoder = Schema.decodeUnknownEither(TransactionHistorySchema);
+/**
+ * In-memory implementation of the TransactionHistoryStorage interface.
+ *
+ * TODO: Implement update method with callback api when needed in the future
+ */
+export class InMemoryTransactionHistoryStorage {
+    entries;
+    constructor(entries) {
+        this.entries = entries || new Map();
+    }
+    create(entry) {
+        this.entries.set(entry.hash, entry);
+        return Promise.resolve();
+    }
+    delete(hash) {
+        const existingEntry = this.entries.get(hash);
+        if (!existingEntry) {
+            return Promise.resolve(undefined);
+        }
+        this.entries.delete(hash);
+        return Promise.resolve(existingEntry);
+    }
+    async *getAll() {
+        for (const entry of this.entries.values()) {
+            yield await Promise.resolve(entry);
+        }
+    }
+    get(hash) {
+        return Promise.resolve(this.entries.get(hash));
+    }
+    serialize() {
+        const result = TransactionHistoryEncoder(this.entries);
+        return JSON.stringify(result);
+    }
+    reset() {
+        this.entries.clear();
+    }
+    static fromSerialized(serializedHistory) {
+        const schema = JSON.parse(serializedHistory);
+        const decoded = Either.getOrElse(TransactionHistoryDecoder(schema), (error) => {
+            throw new Error(`Failed to decode transaction history: ${error.message}`);
+        });
+        return new InMemoryTransactionHistoryStorage(decoded);
+    }
+}

package/dist/tx-history-storage/NoOpTransactionHistoryStorage.d.ts

@@ -0,0 +1,9 @@
+import { TransactionHistoryStorage, TransactionHash, TransactionHistoryEntry } from './TransactionHistoryStorage.js';
+export declare class NoOpTransactionHistoryStorage implements TransactionHistoryStorage {
+    create(_entry: TransactionHistoryEntry): Promise<void>;
+    delete(_hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    getAll(): AsyncIterableIterator<TransactionHistoryEntry>;
+    get(_hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    serialize(): string;
+    static deserialize(_serialized: string): NoOpTransactionHistoryStorage;
+}

package/dist/tx-history-storage/NoOpTransactionHistoryStorage.js

@@ -0,0 +1,20 @@
+export class NoOpTransactionHistoryStorage {
+    create(_entry) {
+        return Promise.resolve();
+    }
+    delete(_hash) {
+        return Promise.resolve(undefined);
+    }
+    async *getAll() {
+        return Promise.resolve(yield* []);
+    }
+    get(_hash) {
+        return Promise.resolve(undefined);
+    }
+    serialize() {
+        return JSON.stringify({});
+    }
+    static deserialize(_serialized) {
+        return new NoOpTransactionHistoryStorage();
+    }
+}

package/dist/tx-history-storage/TransactionHistoryStorage.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from 'effect';
+declare const TransactionHashSchema: typeof Schema.String;
+export type TransactionHash = Schema.Schema.Type<typeof TransactionHashSchema>;
+export declare const TransactionHistoryEntrySchema: Schema.Struct<{
+    id: typeof Schema.Number;
+    hash: typeof Schema.String;
+    protocolVersion: typeof Schema.Number;
+    identifiers: Schema.Array$<typeof Schema.String>;
+    transactionResult: Schema.NullOr<Schema.Struct<{
+        status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+        segments: Schema.Array$<Schema.Struct<{
+            id: typeof Schema.String;
+            success: typeof Schema.Boolean;
+        }>>;
+    }>>;
+}>;
+export type TransactionHistoryEntry = Schema.Schema.Type<typeof TransactionHistoryEntrySchema>;
+export interface TransactionHistoryStorage {
+    create(entry: TransactionHistoryEntry): Promise<void>;
+    delete(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+    getAll(): AsyncIterableIterator<TransactionHistoryEntry>;
+    get(hash: TransactionHash): Promise<TransactionHistoryEntry | undefined>;
+}
+export {};

package/dist/tx-history-storage/TransactionHistoryStorage.js

@@ -0,0 +1,15 @@
+import { Schema } from 'effect';
+const TransactionHashSchema = Schema.String;
+export const TransactionHistoryEntrySchema = Schema.Struct({
+    id: Schema.Number,
+    hash: TransactionHashSchema,
+    protocolVersion: Schema.Number,
+    identifiers: Schema.Array(Schema.String),
+    transactionResult: Schema.NullOr(Schema.Struct({
+        status: Schema.Literal('SUCCESS', 'FAILURE', 'PARTIAL_SUCCESS'),
+        segments: Schema.Array(Schema.Struct({
+            id: Schema.String,
+            success: Schema.Boolean,
+        })),
+    })),
+});

package/dist/tx-history-storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './InMemoryTransactionHistoryStorage.js';
+export * from './TransactionHistoryStorage.js';

package/dist/tx-history-storage/index.js

@@ -0,0 +1,2 @@
+export * from './InMemoryTransactionHistoryStorage.js';
+export * from './TransactionHistoryStorage.js';

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@midnight-ntwrk/wallet-sdk-unshielded-wallet",
+  "version": "1.0.0-beta.11",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "IOHK",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midnight-ntwrk/artifacts.git"
+  },
+  "files": [
+    "dist/"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.5",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.8",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.7",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.7",
+    "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.6",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-unshielded-state": "1.0.0-beta.10",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.7",
+    "effect": "^3.17.3",
+    "rxjs": "^7.5"
+  },
+  "scripts": {
+    "typecheck": "tsc -b ./tsconfig.json --noEmit",
+    "test": "vitest run",
+    "lint": "eslint --max-warnings 0",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
+    "dist": "tsc -b ./tsconfig.build.json",
+    "dist:publish": "tsc -b ./tsconfig.publish.json",
+    "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",
+    "publint": "publint --strict"
+  },
+  "devDependencies": {
+    "eslint": "^9.37.0",
+    "publint": "~0.3.14",
+    "rimraf": "^6.0.1",
+    "testcontainers": "^11.0.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}