@midnightntwrk/wallet-sdk-unshielded-wallet 3.1.0

package/dist/v1/RunningV1Variant.js

@@ -0,0 +1,114 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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, pipe, Scope, Stream, SubscriptionRef, Schedule, Duration, Sink, Console } from 'effect';
+import { ProtocolVersion } from '@midnightntwrk/wallet-sdk-abstractions';
+import { StateChange, VersionChangeType, } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
+import { EitherOps } from '@midnightntwrk/wallet-sdk-utilities';
+const progress = (state) => {
+    const appliedId = state.progress?.appliedId ?? 0n;
+    const highestTransactionId = state.progress?.highestTransactionId ?? 0n;
+    const sourceGap = highestTransactionId - appliedId;
+    const applyGap = appliedId - appliedId;
+    return [StateChange.ProgressUpdate({ sourceGap, applyGap })];
+};
+const protocolVersionChange = (previous, current) => {
+    return previous.protocolVersion != current.protocolVersion
+        ? [
+            StateChange.VersionChange({
+                change: VersionChangeType.Version({
+                    version: ProtocolVersion.ProtocolVersion(current.protocolVersion),
+                }),
+            }),
+        ]
+        : [];
+};
+export const V1Tag = Symbol('V1');
+export class RunningV1Variant {
+    __polyTag__ = V1Tag;
+    #scope;
+    #context;
+    #v1Context;
+    state;
+    constructor(scope, context, v1Context) {
+        this.#scope = scope;
+        this.#context = context;
+        this.#v1Context = v1Context;
+        this.state = Stream.fromEffect(context.stateRef.get).pipe(Stream.flatMap((initialState) => context.stateRef.changes.pipe(Stream.mapAccum(initialState, (previous, current) => {
+            return [current, [previous, current]];
+        }))), Stream.mapConcat(([previous, current]) => {
+            // TODO: emit progress only upon actual change
+            return [
+                StateChange.State({ state: current }),
+                ...progress(current),
+                ...protocolVersionChange(previous, current),
+            ];
+        }));
+    }
+    startSyncInBackground() {
+        return this.startSync().pipe(Stream.runScoped(Sink.drain), Effect.forkScoped, Effect.provideService(Scope.Scope, this.#scope));
+    }
+    startSync() {
+        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state)), Stream.mapEffect((update) => {
+            return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => pipe(this.#v1Context.syncCapability.applyUpdate(state, update), EitherOps.toEffect));
+        }), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
+            const maxDelay = Duration.minutes(2);
+            const jitter = Duration.millis(Math.floor(Math.random() * 1000));
+            const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);
+            return Duration.millis(Math.min(delayWithJitter, Duration.toMillis(maxDelay)));
+        }))));
+    }
+    balanceFinalizedTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceFinalizedTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnboundTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnboundTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    balanceUnprovenTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceUnprovenTransaction(state, tx), EitherOps.toEffect);
+        });
+    }
+    transferTransaction(outputs, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
+    rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.rotateUtxos(state, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
+    initSwap(desiredInputs, desiredOutputs, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
+    signUnprovenTransaction(transaction, signSegment) {
+        return this.#v1Context.transactingCapability.signUnprovenTransaction(transaction, signSegment);
+    }
+    signUnboundTransaction(transaction, signSegment) {
+        return this.#v1Context.transactingCapability.signUnboundTransaction(transaction, signSegment);
+    }
+    revertTransaction(transaction) {
+        return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), EitherOps.toEffect);
+        });
+    }
+    serializeState(state) {
+        return this.#v1Context.serializationCapability.serialize(state);
+    }
+}

package/dist/v1/Serialization.d.ts

@@ -0,0 +1,12 @@
+import { Either } from 'effect';
+import { type WalletError } from './WalletError.js';
+import { CoreWallet } from './CoreWallet.js';
+import { type NetworkId } from '@midnightntwrk/wallet-sdk-abstractions';
+export type SerializationCapability<TWallet, TSerialized> = {
+    serialize(wallet: TWallet): TSerialized;
+    deserialize(data: TSerialized): Either.Either<TWallet, WalletError>;
+};
+export type DefaultSerializationConfiguration = {
+    networkId: NetworkId.NetworkId;
+};
+export declare const makeDefaultV1SerializationCapability: () => SerializationCapability<CoreWallet, string>;

package/dist/v1/Serialization.js

@@ -0,0 +1,64 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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, Schema } from 'effect';
+import { OtherWalletError } from './WalletError.js';
+import { CoreWallet } from './CoreWallet.js';
+import { ProtocolVersion } from '@midnightntwrk/wallet-sdk-abstractions';
+import { UnshieldedState } from './UnshieldedState.js';
+export const makeDefaultV1SerializationCapability = () => {
+    const UtxoWithMetaSchema = Schema.Struct({
+        utxo: Schema.Struct({
+            value: Schema.BigInt,
+            owner: Schema.String,
+            type: Schema.String,
+            intentHash: Schema.String,
+            outputNo: Schema.Number,
+        }),
+        meta: Schema.Struct({
+            ctime: Schema.Date,
+            registeredForDustGeneration: Schema.Boolean,
+        }),
+    });
+    const SnapshotSchema = Schema.Struct({
+        publicKey: Schema.Struct({
+            publicKey: Schema.String,
+            addressHex: Schema.String,
+            address: Schema.String,
+        }),
+        state: Schema.Struct({
+            availableUtxos: Schema.Array(UtxoWithMetaSchema),
+            pendingUtxos: Schema.Array(UtxoWithMetaSchema),
+        }),
+        protocolVersion: Schema.BigInt,
+        appliedId: Schema.optional(Schema.BigInt),
+        networkId: Schema.String,
+    });
+    return {
+        serialize: (wallet) => {
+            const buildSnapshot = (w) => ({
+                publicKey: w.publicKey,
+                state: UnshieldedState.toArrays(w.state),
+                protocolVersion: w.protocolVersion,
+                networkId: w.networkId,
+                appliedId: w.progress?.appliedId,
+            });
+            return pipe(wallet, buildSnapshot, Schema.encodeSync(SnapshotSchema), JSON.stringify);
+        },
+        deserialize: (serialized) => pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SnapshotSchema)), Either.mapLeft((err) => new OtherWalletError(err)), Either.map((snapshot) => {
+            return CoreWallet.restore(UnshieldedState.restore(snapshot.state.availableUtxos, snapshot.state.pendingUtxos), snapshot.publicKey, {
+                highestTransactionId: snapshot.appliedId ?? 0n,
+                appliedId: snapshot.appliedId ?? 0n,
+            }, ProtocolVersion.ProtocolVersion(snapshot.protocolVersion), snapshot.networkId);
+        })),
+    };
+};

package/dist/v1/Sync.d.ts

@@ -0,0 +1,46 @@
+import { type Scope, Stream, Either } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { type Simulator, type SimulatorState } from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+import { type WalletError } from './WalletError.js';
+import { type TransactionHistoryService } from './TransactionHistory.js';
+import { type WalletSyncUpdate } from './SyncSchema.js';
+export interface SyncService<TState, TUpdate> {
+    updates: (state: TState) => Stream.Stream<TUpdate, WalletError, Scope.Scope>;
+}
+export interface SyncCapability<TState, TUpdate> {
+    applyUpdate: (state: TState, update: TUpdate) => Either.Either<TState, WalletError>;
+}
+export type IndexerClientConnection = {
+    indexerHttpUrl: string;
+    indexerWsUrl?: string;
+    keepAlive?: number;
+};
+export type DefaultSyncConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+};
+export type DefaultSyncContext = {
+    transactionHistoryService: TransactionHistoryService;
+};
+export declare const makeDefaultSyncService: (config: DefaultSyncConfiguration) => SyncService<CoreWallet, WalletSyncUpdate>;
+export declare const makeDefaultSyncCapability: (_config: DefaultSyncConfiguration, getContext: () => DefaultSyncContext) => SyncCapability<CoreWallet, WalletSyncUpdate>;
+export type SimulatorSyncConfiguration = {
+    simulator: Simulator;
+};
+export type SimulatorSyncUpdate = {
+    update: SimulatorState;
+};
+export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<CoreWallet, SimulatorSyncUpdate>;
+/**
+ * Creates a sync capability that extracts UTXOs from the simulator's ledger state and applies them to the wallet.
+ *
+ * This capability:
+ *
+ * 1. Extracts all UTXOs for the wallet's address from the simulator ledger
+ * 2. Compares with the wallet's current UTXOs to determine created/spent
+ * 3. Applies the update to the wallet state
+ *
+ * Note: The `registeredForDustGeneration` flag is set based on whether the address appears in the ledger's dust
+ * delegation table. This is a heuristic that may not perfectly match the indexer's behavior but provides reasonable
+ * accuracy.
+ */
+export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate>;

package/dist/v1/Sync.js

@@ -0,0 +1,137 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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, Stream, Schema, pipe, Either, HashMap } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { UtxoWithMeta } from './UnshieldedState.js';
+import { getCurrentBlockNumber, } from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+import { UnshieldedTransactions } from '@midnightntwrk/wallet-sdk-indexer-client';
+import { WsSubscriptionClient, ConnectionHelper } from '@midnightntwrk/wallet-sdk-indexer-client/effect';
+import { SyncWalletError } from './WalletError.js';
+import { WsURL } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import { EitherOps } from '@midnightntwrk/wallet-sdk-utilities';
+import { WalletSyncUpdateSchema } from './SyncSchema.js';
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+export const makeDefaultSyncService = (config) => {
+    return {
+        updates: (state) => {
+            const { indexerClientConnection } = config;
+            const webSocketUrlResult = ConnectionHelper.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl);
+            if (Either.isLeft(webSocketUrlResult)) {
+                return Stream.fail(new SyncWalletError(new Error(`Could not derive WebSocket URL from indexer HTTP URL: ${webSocketUrlResult.left.message}`)));
+            }
+            const indexerWsUrlResult = WsURL.make(webSocketUrlResult.right);
+            if (Either.isLeft(indexerWsUrlResult)) {
+                return Stream.fail(new SyncWalletError(new Error(`Invalid indexer WS URL: ${indexerWsUrlResult.left.message}`)));
+            }
+            const indexerWsUrl = indexerWsUrlResult.right;
+            const { appliedId } = state.progress;
+            const { address } = state.publicKey;
+            return pipe(UnshieldedTransactions.run({ address, transactionId: Number(appliedId) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl, keepAlive: indexerClientConnection.keepAlive })), Stream.mapError((error) => new SyncWalletError(error)), Stream.mapEffect((subscription) => {
+                const { unshieldedTransactions } = subscription;
+                return pipe(Schema.decodeUnknownEither(WalletSyncUpdateSchema)(unshieldedTransactions), Either.mapLeft((err) => new SyncWalletError(err)), EitherOps.toEffect);
+            }));
+        },
+    };
+};
+export const makeDefaultSyncCapability = (_config, getContext) => {
+    return {
+        applyUpdate: (state, update) => {
+            if (update.type === 'UnshieldedTransactionsProgress') {
+                return Either.right(CoreWallet.updateProgress(state, {
+                    highestTransactionId: BigInt(update.highestTransactionId),
+                    isConnected: true,
+                }));
+            }
+            else {
+                const updatePayload = {
+                    createdUtxos: update.createdUtxos,
+                    spentUtxos: update.spentUtxos,
+                    status: update.status,
+                };
+                const stateAfterApplyingUpdate = update.status === 'FAILURE'
+                    ? CoreWallet.applyFailedUpdate(state, updatePayload)
+                    : CoreWallet.applyUpdate(state, updatePayload);
+                return stateAfterApplyingUpdate.pipe(Either.map((wallet) => {
+                    const stateAfterUpdatingProgress = CoreWallet.updateProgress(wallet, {
+                        appliedId: BigInt(update.transaction.id),
+                    });
+                    const { transactionHistoryService } = getContext();
+                    Effect.runFork(transactionHistoryService.put(update));
+                    return stateAfterUpdatingProgress;
+                }));
+            }
+        },
+    };
+};
+export const makeSimulatorSyncService = (config) => {
+    return {
+        updates: (_state) => {
+            // Get the initial state immediately to ensure we process existing blocks.
+            // Then subscribe to state$ for subsequent changes.
+            return pipe(Stream.fromEffect(config.simulator.getLatestState()), Stream.concat(config.simulator.state$), Stream.map((state) => ({ update: state })));
+        },
+    };
+};
+/**
+ * Creates a sync capability that extracts UTXOs from the simulator's ledger state and applies them to the wallet.
+ *
+ * This capability:
+ *
+ * 1. Extracts all UTXOs for the wallet's address from the simulator ledger
+ * 2. Compares with the wallet's current UTXOs to determine created/spent
+ * 3. Applies the update to the wallet state
+ *
+ * Note: The `registeredForDustGeneration` flag is set based on whether the address appears in the ledger's dust
+ * delegation table. This is a heuristic that may not perfectly match the indexer's behavior but provides reasonable
+ * accuracy.
+ */
+export const makeSimulatorSyncCapability = () => {
+    const utxoKey = (utxo) => `${utxo.intentHash}#${utxo.outputNo}`;
+    return {
+        applyUpdate: (state, update) => {
+            const { ledger: ledgerState, currentTime } = update.update;
+            const walletAddress = state.publicKey.addressHex;
+            const nativeTokenType = ledger.nativeToken().raw;
+            // Heuristic: check if address appears in the ledger's dust delegation table
+            const isAddressRegisteredForDust = ledgerState.dust.toString().includes(walletAddress);
+            // Build a Map of simulator UTXOs keyed by intent hash + output number
+            const simulatorUtxoMap = new Map(Array.from(ledgerState.utxo.filter(walletAddress)).map((utxo) => [
+                utxoKey(utxo),
+                new UtxoWithMeta({
+                    utxo,
+                    meta: {
+                        ctime: currentTime,
+                        registeredForDustGeneration: utxo.type === nativeTokenType && isAddressRegisteredForDust,
+                    },
+                }),
+            ]));
+            // Created: in simulator but not in wallet (neither available nor pending)
+            const createdUtxos = Array.from(simulatorUtxoMap)
+                .filter(([hash]) => !HashMap.has(state.state.availableUtxos, hash) && !HashMap.has(state.state.pendingUtxos, hash))
+                .map(([, utxo]) => utxo);
+            // Spent: in wallet (pending or available) but no longer in simulator
+            const spentUtxos = [
+                ...Array.from(HashMap.entries(state.state.pendingUtxos)),
+                ...Array.from(HashMap.entries(state.state.availableUtxos)),
+            ]
+                .filter(([hash]) => !simulatorUtxoMap.has(hash))
+                .map(([, utxo]) => utxo);
+            const blockNumber = getCurrentBlockNumber(update.update);
+            const updateProgress = (wallet) => CoreWallet.updateProgress(wallet, { appliedId: blockNumber, isConnected: true });
+            if (createdUtxos.length === 0 && spentUtxos.length === 0) {
+                return Either.right(updateProgress(state));
+            }
+            return pipe(CoreWallet.applyUpdate(state, { createdUtxos, spentUtxos, status: 'SUCCESS' }), Either.map(updateProgress));
+        },
+    };
+};

package/dist/v1/SyncProgress.d.ts

@@ -0,0 +1,18 @@
+export interface SyncProgressData {
+    readonly appliedId: bigint;
+    readonly highestTransactionId: bigint;
+    readonly isConnected: boolean;
+}
+export interface SyncProgressOps {
+    isCompleteWithin(data: SyncProgressData, maxGap?: bigint): boolean;
+}
+export interface SyncProgress extends SyncProgressData {
+    isStrictlyComplete(): boolean;
+    isCompleteWithin(maxGap?: bigint): boolean;
+}
+export declare const SyncProgress: SyncProgressOps;
+export declare const createSyncProgress: (params?: {
+    appliedId?: bigint;
+    highestTransactionId?: bigint;
+    isConnected?: boolean;
+}) => SyncProgress;

package/dist/v1/SyncProgress.js

@@ -0,0 +1,23 @@
+export const SyncProgress = {
+    isCompleteWithin(data, maxGap = 50n) {
+        const applyLag = BigInt(Math.abs(Number(data.highestTransactionId - data.appliedId)));
+        return data.isConnected && applyLag <= maxGap;
+    },
+};
+export const createSyncProgress = (params = {}) => {
+    const { appliedId = 0n, highestTransactionId = 0n, isConnected = false } = params;
+    const data = {
+        appliedId,
+        highestTransactionId,
+        isConnected,
+    };
+    return {
+        ...data,
+        isStrictlyComplete() {
+            return SyncProgress.isCompleteWithin(this, 0n);
+        },
+        isCompleteWithin(maxGap) {
+            return SyncProgress.isCompleteWithin(this, maxGap);
+        },
+    };
+};