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

package/dist/WalletBuilder.js

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