@midnightntwrk/wallet-sdk-shielded 3.0.2

package/dist/v1/V1Builder.js

@@ -0,0 +1,172 @@
+// 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 * as ledger from '@midnight-ntwrk/ledger-v8';
+import { Effect, Scope } from 'effect';
+import { WalletSeed } from '@midnightntwrk/wallet-sdk-abstractions';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { makeDefaultV1SerializationCapability } from './Serialization.js';
+import { makeEventsSyncService, makeEventsSyncCapability, } from './Sync.js';
+import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { makeDefaultKeysCapability } from './Keys.js';
+import { chooseCoin } from '@midnightntwrk/wallet-sdk-capabilities';
+import { CoreWallet, PublicKeys } from './CoreWallet.js';
+import { makeDefaultTransactionHistoryService, } from './TransactionHistory.js';
+const V1BuilderSymbol = {
+    typeId: Symbol('@midnight-ntwrk/wallet#V1Builder'),
+};
+export class V1Builder {
+    #buildState;
+    constructor(buildState = {}) {
+        this.#buildState = buildState;
+    }
+    withDefaults() {
+        return this.withDefaultTransactionType()
+            .withSyncDefaults()
+            .withSerializationDefaults()
+            .withTransactingDefaults()
+            .withCoinsAndBalancesDefaults()
+            .withTransactionHistoryDefaults()
+            .withKeysDefaults()
+            .withCoinSelectionDefaults();
+    }
+    withTransactionType() {
+        return new V1Builder({
+            ...this.#buildState,
+            transactingCapability: undefined,
+            transactionHistoryService: undefined,
+        });
+    }
+    withDefaultTransactionType() {
+        return this.withTransactionType();
+    }
+    withSyncDefaults() {
+        return this.withSync(makeEventsSyncService, makeEventsSyncCapability);
+    }
+    withSync(syncService, syncCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            syncService,
+            syncCapability,
+        });
+    }
+    withSerializationDefaults() {
+        return this.withSerialization(makeDefaultV1SerializationCapability);
+    }
+    withSerialization(serializationCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            serializationCapability,
+        });
+    }
+    withTransactingDefaults() {
+        return this.withTransacting(makeDefaultTransactingCapability);
+    }
+    withTransacting(transactingCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            transactingCapability,
+        });
+    }
+    withCoinSelection(coinSelection) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinSelection,
+        });
+    }
+    withCoinSelectionDefaults() {
+        return this.withCoinSelection(() => chooseCoin);
+    }
+    withCoinsAndBalancesDefaults() {
+        return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+    }
+    withCoinsAndBalances(coinsAndBalancesCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinsAndBalancesCapability,
+        });
+    }
+    withTransactionHistoryDefaults() {
+        return this.withTransactionHistory(makeDefaultTransactionHistoryService);
+    }
+    withTransactionHistory(transactionHistoryService) {
+        return new V1Builder({
+            ...this.#buildState,
+            transactionHistoryService,
+        });
+    }
+    withKeysDefaults() {
+        return this.withKeys(makeDefaultKeysCapability);
+    }
+    withKeys(keysCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            keysCapability,
+        });
+    }
+    build(configuration) {
+        const v1Context = this.#buildContextFromBuildState(configuration);
+        const { networkId } = configuration;
+        return {
+            __polyTag__: V1Tag,
+            coinsAndBalances: v1Context.coinsAndBalancesCapability,
+            keys: v1Context.keysCapability,
+            serialization: v1Context.serializationCapability,
+            transactionHistory: v1Context.transactionHistoryService,
+            start(context) {
+                return Effect.gen(function* () {
+                    const scope = yield* Scope.Scope;
+                    return new RunningV1Variant(scope, context, v1Context);
+                });
+            },
+            migrateState(_previousState) {
+                const seed = WalletSeed.fromString('0000000000000000000000000000000000000000000000000000000000000001');
+                return Effect.succeed(CoreWallet.empty(PublicKeys.fromSecretKeys(ledger.ZswapSecretKeys.fromSeed(seed)), networkId));
+            },
+            deserializeState: (serialized) => {
+                return v1Context.serializationCapability.deserialize(null, serialized);
+            },
+        };
+    }
+    #buildContextFromBuildState(configuration) {
+        if (!isBuildStateFull(this.#buildState)) {
+            throw new Error('Not all components are configured in V1 Builder');
+        }
+        const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService, } = this.#buildState;
+        const getContext = () => context;
+        const context = {
+            serializationCapability: serializationCapability(configuration, getContext),
+            syncCapability: syncCapability(configuration, getContext),
+            syncService: syncService(configuration, getContext),
+            transactingCapability: transactingCapability(configuration, getContext),
+            coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+            keysCapability: keysCapability(configuration, getContext),
+            coinSelection: coinSelection(configuration, getContext),
+            transactionHistoryService: transactionHistoryService(configuration, getContext),
+        };
+        return context;
+    }
+}
+const isBuildStateFull = (buildState) => {
+    const allBuildStateKeys = [
+        'syncService',
+        'syncCapability',
+        'transactingCapability',
+        'coinSelection',
+        'serializationCapability',
+        'coinsAndBalancesCapability',
+        'keysCapability',
+        'transactionHistoryService',
+    ];
+    return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');
+};

package/dist/v1/WalletError.d.ts

@@ -0,0 +1,74 @@
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type LedgerOps } from '@midnightntwrk/wallet-sdk-utilities';
+export declare const WalletError: {
+    other(err: unknown): WalletError;
+    submission(err: unknown): WalletError;
+};
+export type WalletError = OtherWalletError | InsufficientFundsError | SubmissionError | AddressError | SyncWalletError | InvalidCoinHashesError | TransactingError | LedgerOps.LedgerError;
+declare const OtherWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Other";
+} & Readonly<A>;
+export declare class OtherWalletError extends OtherWalletError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const SyncWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Sync";
+} & Readonly<A>;
+export declare class SyncWalletError extends SyncWalletError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const SubmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.SubmissionWalletError";
+} & Readonly<A>;
+export declare class SubmissionError extends SubmissionError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const InsufficientFundsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.InsufficientFunds";
+} & Readonly<A>;
+export declare class InsufficientFundsError extends InsufficientFundsError_base<{
+    message: string;
+    tokenType: ledger.RawTokenType;
+    amount: bigint;
+}> {
+}
+declare const AddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Address";
+} & Readonly<A>;
+export declare class AddressError extends AddressError_base<{
+    message: string;
+    originalAddress: string;
+    cause?: unknown;
+}> {
+}
+declare const InvalidCoinHashesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.InvalidCoinHashes";
+} & Readonly<A>;
+export declare class InvalidCoinHashesError extends InvalidCoinHashesError_base<{
+    message: string;
+    missingNonces: Set<ledger.Nonce>;
+}> {
+}
+declare const TransactingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Transacting";
+} & Readonly<A>;
+export declare class TransactingError extends TransactingError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const TransactionHistoryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.TransactionHistory";
+} & Readonly<A>;
+export declare class TransactionHistoryError extends TransactionHistoryError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export {};

package/dist/v1/WalletError.js

@@ -0,0 +1,53 @@
+// 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 { Data } from 'effect';
+export const WalletError = {
+    other(err) {
+        let message;
+        if (err) {
+            if (typeof err == 'object' && 'message' in err) {
+                message = String(err.message);
+            }
+            else if (typeof err == 'string') {
+                message = err;
+            }
+            else {
+                message = '';
+            }
+        }
+        else {
+            message = '';
+        }
+        return new OtherWalletError({ message: `Other wallet error: ${message}`, cause: err });
+    },
+    submission(err) {
+        const message = err && typeof err == 'object' && 'message' in err ? String(err.message) : '';
+        return new SubmissionError({ message: `Transaction submission error: ${message}`, cause: err });
+    },
+};
+export class OtherWalletError extends Data.TaggedError('Wallet.Other') {
+}
+export class SyncWalletError extends Data.TaggedError('Wallet.Sync') {
+}
+export class SubmissionError extends Data.TaggedError('Wallet.SubmissionWalletError') {
+}
+export class InsufficientFundsError extends Data.TaggedError('Wallet.InsufficientFunds') {
+}
+export class AddressError extends Data.TaggedError('Wallet.Address') {
+}
+export class InvalidCoinHashesError extends Data.TaggedError('Wallet.InvalidCoinHashes') {
+}
+export class TransactingError extends Data.TaggedError('Wallet.Transacting') {
+}
+export class TransactionHistoryError extends Data.TaggedError('Wallet.TransactionHistory') {
+}

package/dist/v1/index.d.ts

@@ -0,0 +1,12 @@
+export * from './V1Builder.js';
+export * as Sync from './Sync.js';
+export * as Transacting from './Transacting.js';
+export * as TransactionHistory from './TransactionHistory.js';
+export * as Serialization from './Serialization.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';
+export * as Keys from './Keys.js';
+export * from './RunningV1Variant.js';
+export * as Simulator from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+export * as WalletError from './WalletError.js';
+export * from './CoreWallet.js';
+export * from './TransactionOps.js';

package/dist/v1/index.js

@@ -0,0 +1,24 @@
+// 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.
+export * from './V1Builder.js';
+export * as Sync from './Sync.js';
+export * as Transacting from './Transacting.js';
+export * as TransactionHistory from './TransactionHistory.js';
+export * as Serialization from './Serialization.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';
+export * as Keys from './Keys.js';
+export * from './RunningV1Variant.js';
+export * as Simulator from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+export * as WalletError from './WalletError.js';
+export * from './CoreWallet.js';
+export * from './TransactionOps.js';

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@midnightntwrk/wallet-sdk-shielded",
+  "version": "3.0.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "Midnight Foundation",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midnightntwrk/midnight-wallet.git",
+    "directory": "packages/shielded-wallet"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./v1": {
+      "types": "./dist/v1/index.d.ts",
+      "import": "./dist/v1/index.js"
+    }
+  },
+  "dependencies": {
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
+    "@midnightntwrk/wallet-sdk-abstractions": "^2.1.0",
+    "@midnightntwrk/wallet-sdk-address-format": "^3.1.2",
+    "@midnightntwrk/wallet-sdk-capabilities": "^3.3.1",
+    "@midnightntwrk/wallet-sdk-indexer-client": "^1.2.3",
+    "@midnightntwrk/wallet-sdk-runtime": "^1.0.5",
+    "@midnightntwrk/wallet-sdk-utilities": "^1.2.0",
+    "effect": "^3.19.19",
+    "rxjs": "^7.8.2"
+  },
+  "scripts": {
+    "typecheck": "tsc -b ./tsconfig.json --noEmit --force",
+    "test": "vitest run",
+    "lint": "eslint --max-warnings 0",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "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"
+  }
+}