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

package/dist/v1/Serialization.js

@@ -0,0 +1,64 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Either, pipe, Schema } from 'effect';
+import { WalletError } from './WalletError.js';
+import { CoreWallet } from './CoreWallet.js';
+import { ProtocolVersion } from '@midnight-ntwrk/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) => WalletError.other(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/Simulator.d.ts

@@ -0,0 +1,22 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Array as Arr, Effect, Scope, Stream, SubscriptionRef } from 'effect';
+export type SimulatorState = Readonly<{
+    ledger: ledger.LedgerState;
+    lastTxResult: ledger.TransactionResult;
+    lastTxNumber: bigint;
+}>;
+export declare class Simulator {
+    #private;
+    static nextBlockContext: (number: bigint) => Effect.Effect<ledger.BlockContext>;
+    static init(genesisMints: Readonly<Arr.NonEmptyArray<{
+        amount: bigint;
+        type: ledger.RawTokenType;
+        recipient: ledger.ZswapSecretKeys;
+    }>>): Effect.Effect<Simulator, never, Scope.Scope>;
+    readonly state$: Stream.Stream<SimulatorState>;
+    constructor(stateRef: SubscriptionRef.SubscriptionRef<SimulatorState>, state$: Stream.Stream<SimulatorState>);
+    submitRegularTx(tx: ledger.ProofErasedTransaction): Effect.Effect<{
+        blockNumber: bigint;
+        blockHash: string;
+    }>;
+}

package/dist/v1/Simulator.js

@@ -0,0 +1,102 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Array as Arr, Effect, Encoding, pipe, Stream, SubscriptionRef, Clock } from 'effect';
+import { ArrayOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import * as crypto from 'crypto';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+const simpleHash = (input) => {
+    return Encoding.decodeHex(input).pipe(EitherOps.toEffect, Effect.andThen((parsed) => Effect.promise(() => crypto.subtle.digest('SHA-256', parsed))), Effect.andThen((out) => Encoding.encodeHex(new Uint8Array(out))), Effect.orDie);
+};
+const wellFormedStrictness = (params = {}) => {
+    const strictness = new ledger.WellFormedStrictness();
+    // Note: Enforce balancing should be true by default outside genesis mints
+    strictness.enforceBalancing = params?.enforceBalancing ?? false;
+    strictness.verifyNativeProofs = params?.verifyNativeProofs ?? false;
+    strictness.verifyContractProofs = params?.verifyContractProofs ?? false;
+    strictness.enforceLimits = params?.enforceLimits ?? false;
+    strictness.verifySignatures = params?.verifySignatures ?? false;
+    return strictness;
+};
+export class Simulator {
+    static nextBlockContext = (number) => pipe(number.toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash, Effect.map((hash) => ({
+        parentBlockHash: hash,
+        secondsSinceEpoch: number,
+        secondsSinceEpochErr: 1,
+    })));
+    static init(genesisMints) {
+        const emptyState = ledger.LedgerState.blank(NetworkId.NetworkId.Undeployed);
+        const noStrictness = wellFormedStrictness();
+        const makeTransactions = (context) => Effect.gen(function* () {
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const verificationTime = new Date(nowMillis);
+            const tx = pipe(genesisMints, Arr.map((transfer) => {
+                const coin = ledger.createShieldedCoinInfo(transfer.type, transfer.amount);
+                const output = ledger.ZswapOutput.new(coin, 0, transfer.recipient.coinPublicKey, transfer.recipient.encryptionPublicKey);
+                return ledger.ZswapOffer.fromOutput(output, transfer.type, transfer.amount);
+            }), ArrayOps.fold((acc, offer) => acc.merge(offer)), (offer) => ledger.Transaction.fromParts(NetworkId.NetworkId.Undeployed, offer).eraseProofs(), (tx) => tx.wellFormed(emptyState, noStrictness, verificationTime));
+            const [initialState, initialResult] = emptyState.apply(tx, new ledger.TransactionContext(emptyState, context));
+            const postBlockUpdateState = initialState.postBlockUpdate(verificationTime);
+            return {
+                initialResult,
+                initialState: postBlockUpdateState,
+                tx,
+            };
+        });
+        return Effect.gen(function* () {
+            const context = yield* Simulator.nextBlockContext(0n);
+            const init = yield* makeTransactions(context);
+            const initialState = {
+                ledger: init.initialState,
+                lastTxResult: init.initialResult,
+                lastTxNumber: 0n,
+            };
+            const ref = yield* SubscriptionRef.make(initialState);
+            const changesStream = yield* Stream.share(ref.changes, {
+                capacity: 'unbounded',
+                replay: Number.MAX_SAFE_INTEGER,
+            });
+            yield* pipe(changesStream, Stream.runDrain, Effect.forkScoped);
+            return new Simulator(ref, changesStream);
+        });
+    }
+    #stateRef;
+    state$;
+    constructor(stateRef, state$) {
+        this.#stateRef = stateRef;
+        this.state$ = state$;
+    }
+    submitRegularTx(tx) {
+        return pipe(this.#stateRef, SubscriptionRef.modifyEffect((simulatorState) => Effect.gen(function* () {
+            const nextNumber = simulatorState.lastTxNumber + 1n;
+            const context = yield* Simulator.nextBlockContext(nextNumber);
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const verificationTime = new Date(nowMillis);
+            const noStrictness = wellFormedStrictness();
+            const verifiedTx = tx.wellFormed(simulatorState.ledger, noStrictness, verificationTime);
+            const [newState, result] = simulatorState.ledger.apply(verifiedTx, new ledger.TransactionContext(simulatorState.ledger, context));
+            const postBlockUpdatedState = newState.postBlockUpdate(verificationTime);
+            const newSimulatorState = {
+                ...simulatorState,
+                ledger: postBlockUpdatedState,
+                lastTxResult: result,
+                lastTxNumber: nextNumber,
+            };
+            const output = {
+                blockNumber: nextNumber,
+                blockHash: context.parentBlockHash,
+            };
+            return [output, newSimulatorState];
+        })));
+    }
+}

package/dist/v1/Sync.d.ts

@@ -0,0 +1,32 @@
+import { Scope, Stream, Either } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { Simulator, SimulatorState } from './Simulator.js';
+import { WalletError } from './WalletError.js';
+import { TransactionHistoryService } from './TransactionHistory.js';
+import { 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;
+};
+export type DefaultSyncConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+};
+export type DefaultSyncContext = {
+    transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
+};
+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>;
+export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate>;

package/dist/v1/Sync.js

@@ -0,0 +1,85 @@
+// 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 { Stream, Schema, pipe, Either } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { UnshieldedTransactions } from '@midnight-ntwrk/wallet-sdk-indexer-client';
+import { WsSubscriptionClient, ConnectionHelper } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { SyncWalletError } from './WalletError.js';
+import { WsURL } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { WalletSyncUpdateSchema } from './SyncSchema.js';
+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 })), 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();
+                    void transactionHistoryService.create(update);
+                    return stateAfterUpdatingProgress;
+                }));
+            }
+        },
+    };
+};
+export const makeSimulatorSyncService = (config) => {
+    return {
+        updates: (_state) => config.simulator.state$.pipe(Stream.map((state) => ({ update: state }))),
+    };
+};
+export const makeSimulatorSyncCapability = () => {
+    return {
+        applyUpdate: (state, _update) => {
+            return Either.right(state);
+            // return CoreWallet.replayEvents(state, secretKeys, events);
+        },
+    };
+};

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);
+        },
+    };
+};