@midnightntwrk/wallet-sdk-capabilities 3.3.1

package/README.md

@@ -0,0 +1,126 @@
+# @midnightntwrk/wallet-sdk-capabilities
+
+Internal wallet capabilities for transaction balancing on the Midnight network.
+
+## Installation
+
+```bash
+npm install @midnightntwrk/wallet-sdk-capabilities
+```
+
+## Overview
+
+This package provides core transaction balancing capabilities used internally by wallet implementations. It handles the
+complex logic of selecting inputs and creating outputs to balance transactions while accounting for fee overhead costs.
+
+Key features:
+
+- Transaction balancing algorithms
+- Coin selection strategies
+- Imbalance tracking and resolution
+- Fee-aware counter-offer generation
+
+## Usage
+
+### Basic Transaction Balancing
+
+```typescript
+import { getBalanceRecipe, Imbalances, chooseCoin } from '@midnightntwrk/wallet-sdk-capabilities';
+
+const recipe = getBalanceRecipe({
+  coins: availableCoins,
+  initialImbalances: Imbalances.fromEntry('NIGHT', -1000n), // Need 1000 NIGHT
+  transactionCostModel: {
+    inputFeeOverhead: 1000n,
+    outputFeeOverhead: 500n,
+  },
+  feeTokenType: 'DUST',
+  createOutput: (coin) => ({ type: coin.type, value: coin.value }),
+  isCoinEqual: (a, b) => a.id === b.id,
+  coinSelection: chooseCoin, // Optional: defaults to smallest-first selection
+});
+
+console.log('Inputs to add:', recipe.inputs);
+console.log('Outputs to create:', recipe.outputs);
+```
+
+### Working with Imbalances
+
+```typescript
+import { Imbalances } from '@midnightntwrk/wallet-sdk-capabilities';
+
+// Create imbalances from entries
+const imbalances = Imbalances.fromEntries([
+  ['NIGHT', -500n], // Need 500 NIGHT (negative = deficit)
+  ['TOKEN_A', 200n], // Have 200 TOKEN_A excess (positive = surplus)
+]);
+
+// Merge imbalances
+const merged = Imbalances.merge(imbalances1, imbalances2);
+
+// Get value for a token type
+const nightImbalance = Imbalances.getValue(imbalances, 'NIGHT');
+```
+
+### Custom Coin Selection
+
+```typescript
+import { getBalanceRecipe, CoinSelection } from '@midnightntwrk/wallet-sdk-capabilities';
+
+// Custom strategy: prefer larger coins
+const largestFirst: CoinSelection<MyCoin> = (coins, tokenType, amountNeeded, costModel) => {
+  return coins
+    .filter((coin) => coin.type === tokenType)
+    .sort((a, b) => Number(b.value - a.value))
+    .at(0);
+};
+
+const recipe = getBalanceRecipe({
+  // ... other options
+  coinSelection: largestFirst,
+});
+```
+
+### Error Handling
+
+```typescript
+import { getBalanceRecipe, InsufficientFundsError } from '@midnightntwrk/wallet-sdk-capabilities';
+
+try {
+  const recipe = getBalanceRecipe({
+    /* ... */
+  });
+} catch (error) {
+  if (error instanceof InsufficientFundsError) {
+    console.log(`Cannot balance: insufficient ${error.tokenType}`);
+  }
+}
+```
+
+## Exports
+
+### Balancer
+
+- `getBalanceRecipe` - Main function to calculate inputs/outputs needed to balance a transaction
+- `createCounterOffer` - Creates counter offers with cost model awareness
+- `chooseCoin` - Default coin selection strategy (smallest coin first)
+- `InsufficientFundsError` - Error thrown when balancing fails due to insufficient funds
+- `BalanceRecipe` - Type for balance result with inputs and outputs
+- `CoinSelection` - Type for coin selection function
+
+### Imbalances
+
+- `Imbalances` - Utilities for creating and manipulating token imbalance maps
+- `Imbalance` - Type representing a single token imbalance `[TokenType, TokenValue]`
+- `TokenType` - String type alias for token identifiers
+- `TokenValue` - Bigint type alias for token amounts
+- `CoinRecipe` - Interface for basic coin structure with `type` and `value`
+
+### CounterOffer
+
+- `CounterOffer` - Class for building balanced transactions with fee awareness
+- `TransactionCostModel` - Interface defining `inputFeeOverhead` and `outputFeeOverhead`
+
+## License
+
+Apache-2.0

package/dist/balancer/Balancer.d.ts

@@ -0,0 +1,24 @@
+import { CounterOffer, type TransactionCostModel } from './CounterOffer.js';
+import type { CoinRecipe, Imbalances, TokenType, TokenValue } from './Imbalances.js';
+export declare class InsufficientFundsError extends Error {
+    readonly tokenType: TokenType;
+    constructor(tokenType: TokenType);
+}
+export interface BalanceRecipe<TInput extends CoinRecipe, TOutput extends CoinRecipe> {
+    inputs: TInput[];
+    outputs: TOutput[];
+}
+export type CoinSelection<TInput extends CoinRecipe> = (coins: readonly TInput[], tokenType: TokenType, amountNeeded: TokenValue, costModel: TransactionCostModel) => TInput | undefined;
+export type BalanceRecipeProps<TInput extends CoinRecipe, TOutput extends CoinRecipe> = {
+    coins: TInput[];
+    initialImbalances: Imbalances;
+    transactionCostModel: TransactionCostModel;
+    feeTokenType: string;
+    createOutput: (coin: CoinRecipe) => TOutput;
+    isCoinEqual: (a: TInput, b: TInput) => boolean;
+    coinSelection?: CoinSelection<TInput> | undefined;
+    targetImbalances?: Imbalances;
+};
+export declare const getBalanceRecipe: <TInput extends CoinRecipe, TOutput extends CoinRecipe>({ coins, initialImbalances, transactionCostModel, feeTokenType, createOutput, coinSelection, isCoinEqual, targetImbalances, }: BalanceRecipeProps<TInput, TOutput>) => BalanceRecipe<TInput, TOutput>;
+export declare const createCounterOffer: <TInput extends CoinRecipe, TOutput extends CoinRecipe>(coins: TInput[], initialImbalances: Imbalances, transactionCostModel: TransactionCostModel, feeTokenType: string, coinSelection: CoinSelection<TInput>, createOutput: (coin: CoinRecipe) => TOutput, isCoinEqual: (a: TInput, b: TInput) => boolean, targetImbalances?: Imbalances) => CounterOffer<TInput, TOutput>;
+export declare const chooseCoin: <TInput extends CoinRecipe>(coins: readonly TInput[], tokenType: TokenType) => TInput | undefined;

package/dist/balancer/Balancer.js

@@ -0,0 +1,68 @@
+// 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 { CounterOffer } from './CounterOffer.js';
+export class InsufficientFundsError extends Error {
+    tokenType;
+    constructor(tokenType) {
+        super(`Insufficient Funds: could not balance ${tokenType}`);
+        this.tokenType = tokenType;
+    }
+}
+export const getBalanceRecipe = ({ coins, initialImbalances, transactionCostModel, feeTokenType, createOutput, coinSelection, isCoinEqual, targetImbalances, }) => {
+    const counterOffer = createCounterOffer(coins, initialImbalances, transactionCostModel, feeTokenType, coinSelection ?? chooseCoin, createOutput, isCoinEqual, targetImbalances);
+    return {
+        inputs: counterOffer.inputs,
+        outputs: counterOffer.outputs,
+    };
+};
+export const createCounterOffer = (coins, initialImbalances, transactionCostModel, feeTokenType, coinSelection, createOutput, isCoinEqual, targetImbalances = new Map()) => {
+    const counterOffer = new CounterOffer(initialImbalances, transactionCostModel, feeTokenType, targetImbalances);
+    let imbalance;
+    while ((imbalance = counterOffer.findNonNativeImbalance())) {
+        coins = doBalance(imbalance, coins, counterOffer, coinSelection, createOutput, isCoinEqual);
+    }
+    while ((imbalance = counterOffer.findNativeImbalance())) {
+        coins = doBalance(imbalance, coins, counterOffer, coinSelection, createOutput, isCoinEqual);
+    }
+    return counterOffer;
+};
+const doBalance = (imbalance, coins, counterOffer, coinSelection, createOutput, isCoinEqual) => {
+    const [tokenType, imbalanceAmount] = imbalance;
+    const shouldAddOutput = (tokenType === counterOffer.feeTokenType &&
+        imbalanceAmount >=
+            counterOffer.getTargetImbalance(counterOffer.feeTokenType) +
+                counterOffer.transactionCostModel.outputFeeOverhead) ||
+        (tokenType !== counterOffer.feeTokenType && imbalanceAmount > counterOffer.getTargetImbalance(tokenType));
+    if (shouldAddOutput) {
+        const output = createOutput({
+            type: tokenType,
+            value: imbalanceAmount - counterOffer.getTargetImbalance(tokenType),
+        });
+        counterOffer.addOutput(output);
+    }
+    else {
+        const coin = coinSelection(coins, tokenType, imbalanceAmount, counterOffer.transactionCostModel);
+        if (typeof coin === 'undefined') {
+            throw new InsufficientFundsError(tokenType);
+        }
+        counterOffer.addInput(coin);
+        coins = coins.filter((c) => !isCoinEqual(c, coin));
+    }
+    return coins;
+};
+export const chooseCoin = (coins, tokenType) => {
+    return coins
+        .filter((coin) => coin.type === tokenType)
+        .sort((a, b) => Number(a.value - b.value))
+        .at(0);
+};

package/dist/balancer/CounterOffer.d.ts

@@ -0,0 +1,19 @@
+import { type CoinRecipe, type Imbalance, Imbalances, type TokenType } from './Imbalances.js';
+export interface TransactionCostModel {
+    inputFeeOverhead: bigint;
+    outputFeeOverhead: bigint;
+}
+export declare class CounterOffer<TInput extends CoinRecipe, TOutput extends CoinRecipe> {
+    readonly imbalances: Imbalances;
+    readonly transactionCostModel: TransactionCostModel;
+    readonly feeTokenType: string;
+    readonly inputs: TInput[];
+    readonly outputs: TOutput[];
+    readonly targetImbalances: Imbalances;
+    constructor(imbalances: Imbalances, transactionCostModel: TransactionCostModel, feeTokenType: string, targetImbalances: Imbalances);
+    getTargetImbalance(tokenType: TokenType): bigint;
+    findNonNativeImbalance(): Imbalance | undefined;
+    findNativeImbalance(): Imbalance | undefined;
+    addInput(input: TInput): void;
+    addOutput(output: TOutput): void;
+}

package/dist/balancer/CounterOffer.js

@@ -0,0 +1,65 @@
+// 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 { Imbalances } from './Imbalances.js';
+export class CounterOffer {
+    imbalances;
+    transactionCostModel;
+    feeTokenType;
+    inputs;
+    outputs;
+    targetImbalances;
+    constructor(imbalances, transactionCostModel, feeTokenType, targetImbalances) {
+        this.imbalances = Imbalances.ensureZerosFor(imbalances, Imbalances.typeSet(targetImbalances));
+        this.transactionCostModel = transactionCostModel;
+        this.feeTokenType = feeTokenType;
+        this.inputs = [];
+        this.outputs = [];
+        this.targetImbalances = targetImbalances;
+    }
+    getTargetImbalance(tokenType) {
+        return this.targetImbalances.get(tokenType) ?? 0n;
+    }
+    findNonNativeImbalance() {
+        return Array.from(this.imbalances.entries())
+            .filter(([tokenType]) => tokenType !== this.feeTokenType)
+            .find(([tokenType, value]) => value !== this.getTargetImbalance(tokenType));
+    }
+    findNativeImbalance() {
+        if (!this.feeTokenType) {
+            return undefined;
+        }
+        const nativeImbalance = this.imbalances.get(this.feeTokenType);
+        if (nativeImbalance !== undefined && nativeImbalance !== this.getTargetImbalance(this.feeTokenType)) {
+            return [this.feeTokenType, nativeImbalance];
+        }
+        return undefined;
+    }
+    addInput(input) {
+        this.inputs.push(input);
+        const imbalance = this.imbalances.get(input.type) || 0n;
+        this.imbalances.set(input.type, imbalance + input.value);
+        const nativeImbalance = this.imbalances.get(this.feeTokenType) || 0n;
+        this.imbalances.set(this.feeTokenType, nativeImbalance - this.transactionCostModel.inputFeeOverhead);
+    }
+    addOutput(output) {
+        const imbalance = this.imbalances.get(output.type) || 0n;
+        const subtractFee = output.type === this.feeTokenType ? this.transactionCostModel.outputFeeOverhead : 0n;
+        const absoluteCoinValue = output.value < 0n ? -output.value : output.value;
+        this.outputs.push({ ...output, type: output.type, value: absoluteCoinValue - subtractFee });
+        this.imbalances.set(output.type, imbalance - absoluteCoinValue);
+        if (output.type !== this.feeTokenType) {
+            const nativeImbalance = this.imbalances.get(this.feeTokenType) || 0n;
+            this.imbalances.set(this.feeTokenType, nativeImbalance - this.transactionCostModel.outputFeeOverhead);
+        }
+    }
+}

package/dist/balancer/Imbalances.d.ts

@@ -0,0 +1,19 @@
+export type TokenType = string;
+export type TokenValue = bigint;
+export interface CoinRecipe {
+    type: TokenType;
+    value: TokenValue;
+}
+export type Imbalance = [TokenType, TokenValue];
+export type Imbalances = Map<TokenType, TokenValue>;
+export declare const Imbalances: {
+    empty: () => Imbalances;
+    fromEntry: (tokenType: TokenType, value: bigint) => Imbalances;
+    fromEntries: (entries: Iterable<readonly [TokenType, bigint]>) => Imbalances;
+    fromMap: (map: Map<TokenType, bigint>) => Imbalances;
+    fromMaybeMap: (map: Map<TokenType, bigint> | undefined) => Imbalances;
+    getValue: (map: Imbalances, tokenType: TokenType) => bigint;
+    typeSet: (map: Imbalances) => Set<TokenType>;
+    ensureZerosFor(map: Imbalances, types: Iterable<TokenType>): Imbalances;
+    merge: (a: Imbalances, b: Imbalances) => Imbalances;
+};

package/dist/balancer/Imbalances.js

@@ -0,0 +1,48 @@
+export const Imbalances = new (class {
+    empty = () => {
+        return new Map();
+    };
+    fromEntry = (tokenType, value) => {
+        return new Map([[tokenType, value]]);
+    };
+    fromEntries = (entries) => {
+        const out = new Map();
+        for (const [tokenType, value] of entries) {
+            const existingValue = this.getValue(out, tokenType);
+            out.set(tokenType, value + existingValue);
+        }
+        return out;
+    };
+    fromMap = (map) => {
+        return this.fromEntries(map.entries());
+    };
+    fromMaybeMap = (map) => {
+        return this.fromMap(map ?? new Map());
+    };
+    getValue = (map, tokenType) => {
+        return map.get(tokenType) ?? 0n;
+    };
+    typeSet = (map) => {
+        return new Set(map.keys());
+    };
+    ensureZerosFor(map, types) {
+        const out = this.fromEntries(map.entries());
+        for (const tokenType of types) {
+            const existingValue = this.getValue(out, tokenType);
+            out.set(tokenType, existingValue);
+        }
+        return out;
+    }
+    merge = (a, b) => {
+        const allTokenTypes = this.typeSet(a).union(this.typeSet(b));
+        return this.fromEntries(allTokenTypes
+            .values()
+            .map((tokenType) => {
+            const aValue = this.getValue(a, tokenType);
+            const bValue = this.getValue(b, tokenType);
+            return [tokenType, aValue + bValue];
+        })
+            .filter(([, value]) => value !== 0n)
+            .toArray());
+    };
+})();

package/dist/balancer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Balancer.js';
+export * from './CounterOffer.js';
+export * from './Imbalances.js';

package/dist/balancer/index.js

@@ -0,0 +1,15 @@
+// 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 './Balancer.js';
+export * from './CounterOffer.js';
+export * from './Imbalances.js';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './balancer/index.js';
+export * from './pendingTransactions/index.js';
+export * from './proving/index.js';
+export * from './simulation/index.js';
+export * from './submission/index.js';

package/dist/index.js

@@ -0,0 +1,17 @@
+// 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 './balancer/index.js';
+export * from './pendingTransactions/index.js';
+export * from './proving/index.js';
+export * from './simulation/index.js';
+export * from './submission/index.js';

package/dist/pendingTransactions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pendingTransactionsService.js';
+export * as PendingTransactions from './pendingTransactions.js';

package/dist/pendingTransactions/index.js

@@ -0,0 +1,16 @@
+/*
+ * 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 './pendingTransactionsService.js';
+export * as PendingTransactions from './pendingTransactions.js';

package/dist/pendingTransactions/pendingTransactions.d.ts

@@ -0,0 +1,61 @@
+import { type DateTime, Either, type ParseResult, Schema } from 'effect';
+export type TransactionTrait<TTransaction> = {
+    ids: (tx: TTransaction) => readonly string[];
+    firstId: (tx: TTransaction) => string;
+    areAllTxIdsIncluded: (tx: TTransaction, txIds: readonly string[]) => boolean;
+    isOneIncludedInOther: (tx: TTransaction, otherTx: TTransaction) => boolean;
+    hasTTLExpired: (tx: TTransaction, txCreationTime: DateTime.Utc, now: DateTime.Utc) => boolean;
+    serialize: (tx: TTransaction) => Uint8Array;
+    deserialize: (serialized: Uint8Array) => TTransaction;
+    isTx: (tx: unknown) => tx is TTransaction;
+};
+export type HasTransactionTrait<TTransaction> = {
+    txTrait: TransactionTrait<TTransaction>;
+};
+export type FailedTransactionResult = Readonly<{
+    segments: ReadonlyArray<{
+        id: number;
+        success: boolean;
+    }>;
+    status: 'PARTIAL_SUCCESS' | 'FAILURE';
+}>;
+export type SuccessTransactionResult = Readonly<{
+    segments: ReadonlyArray<{
+        id: number;
+        success: boolean;
+    }>;
+    status: 'SUCCESS';
+}>;
+export type TransactionResult = FailedTransactionResult | SuccessTransactionResult;
+export type PendingItem<TTransaction> = Readonly<{
+    tx: TTransaction;
+    creationTime: DateTime.Utc;
+}>;
+export type CheckedItem<TTransaction> = PendingItem<TTransaction> & {
+    result: TransactionResult;
+};
+export type PendingTransactionsItem<TTransaction> = PendingItem<TTransaction> | CheckedItem<TTransaction>;
+export type FailedTransactionItem<TTransaction> = PendingTransactionsItem<TTransaction> & {
+    result: FailedTransactionResult;
+};
+export type PendingTransactions<TTransaction> = Readonly<{
+    all: ReadonlyArray<PendingTransactionsItem<TTransaction>>;
+}>;
+export declare const has: <TTransaction>(transactions: PendingTransactions<TTransaction>, transaction: TTransaction, txTrait: TransactionTrait<TTransaction>) => boolean;
+export declare const all: <TTransaction>(transactions: PendingTransactions<TTransaction>) => readonly TTransaction[];
+export declare const allFailed: <TTransaction>(transactions: PendingTransactions<TTransaction>) => ReadonlyArray<FailedTransactionItem<TTransaction>>;
+export declare const allPending: <TTransaction>(state: PendingTransactions<TTransaction>) => readonly PendingItem<TTransaction>[];
+export declare const empty: <TTransaction>() => PendingTransactions<TTransaction>;
+export declare const addPendingTransaction: <TTransaction>(state: PendingTransactions<TTransaction>, tx: TTransaction, now: DateTime.Utc, txTrait: TransactionTrait<TTransaction>) => PendingTransactions<TTransaction>;
+export declare const clear: <TTransaction>(state: PendingTransactions<TTransaction>, tx: TTransaction, txTrait: TransactionTrait<TTransaction>) => PendingTransactions<TTransaction>;
+export declare const saveResult: <TTransaction>(state: PendingTransactions<TTransaction>, tx: TTransaction, result: TransactionResult, txTrait: TransactionTrait<TTransaction>) => PendingTransactions<TTransaction>;
+type Serialized<TTransaction> = Readonly<{
+    version: 'v1';
+    transactions: readonly PendingItem<TTransaction>[];
+}>;
+export declare const SerializedSchema: <TTransaction>(txTrait: TransactionTrait<TTransaction>) => Schema.Schema<Serialized<TTransaction>, any>;
+export declare const serialize: <TTransaction>(state: PendingTransactions<TTransaction>, txTrait: TransactionTrait<TTransaction>) => string;
+export declare const deserialize: <TTransaction>(serialized: string, txTrait: TransactionTrait<TTransaction>) => Either.Either<PendingTransactions<TTransaction>, ParseResult.ParseError>;
+export declare const toSerialized: <TTransaction>(pendingTransactions: PendingTransactions<TTransaction>) => Serialized<TTransaction>;
+export declare const fromSerialized: <TTransaction>(serialized: Serialized<TTransaction>) => PendingTransactions<TTransaction>;
+export {};

package/dist/pendingTransactions/pendingTransactions.js

@@ -0,0 +1,85 @@
+/*
+ * 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 { Array as Arr, Either, Order, pipe, Schema } from 'effect';
+export const has = (transactions, transaction, txTrait) => {
+    return transactions.all.some((item) => txTrait.areAllTxIdsIncluded(transaction, txTrait.ids(item.tx)));
+};
+export const all = (transactions) => {
+    return transactions.all.map((item) => item.tx);
+};
+export const allFailed = (transactions) => {
+    return transactions.all.filter((item) => 'result' in item && (item.result?.status === 'FAILURE' || item.result?.status === 'PARTIAL_SUCCESS'));
+};
+export const allPending = (state) => {
+    return state.all.filter((item) => !('result' in item) || item.result === undefined);
+};
+export const empty = () => {
+    return {
+        all: [],
+    };
+};
+export const addPendingTransaction = (state, tx, now, txTrait) => {
+    const [rest, foundMatching] = pipe(state.all, Arr.partition((item) => txTrait.isOneIncludedInOther(tx, item.tx)));
+    const allMatchingTransactions = Arr.append(foundMatching, { tx, creationTime: now });
+    const theBiggestMatchingTx = Arr.max(allMatchingTransactions, pipe(Order.number, Order.mapInput((input) => txTrait.ids(input).length), Order.mapInput((input) => input.tx)));
+    return {
+        ...state,
+        all: Arr.append(rest, theBiggestMatchingTx),
+    };
+};
+export const clear = (state, tx, txTrait) => {
+    return {
+        ...state,
+        all: Arr.filter(state.all, (item) => !txTrait.areAllTxIdsIncluded(item.tx, txTrait.ids(tx))),
+    };
+};
+export const saveResult = (state, tx, result, txTrait) => {
+    return {
+        ...state,
+        all: Arr.map(state.all, (item) => {
+            return txTrait.areAllTxIdsIncluded(item.tx, txTrait.ids(tx)) ? { ...item, result } : item;
+        }),
+    };
+};
+export const SerializedSchema = (txTrait) => {
+    const TxSchema = Schema.declare((tx) => txTrait.isTx(tx));
+    const TxFromHex = Schema.transform(Schema.Uint8ArrayFromHex, TxSchema, {
+        encode: (tx) => txTrait.serialize(tx),
+        decode: (bytes) => txTrait.deserialize(bytes),
+    });
+    const TxItemSchema = Schema.Struct({
+        tx: TxFromHex,
+        creationTime: Schema.DateTimeUtc,
+    });
+    return Schema.Struct({
+        version: Schema.Literal('v1'),
+        transactions: Schema.Array(TxItemSchema),
+    });
+};
+export const serialize = (state, txTrait) => pipe(state, toSerialized, Schema.encodeSync(SerializedSchema(txTrait)), JSON.stringify);
+export const deserialize = (serialized, txTrait) => {
+    return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SerializedSchema(txTrait))), Either.map((data) => fromSerialized(data)));
+};
+export const toSerialized = (pendingTransactions) => {
+    return {
+        version: 'v1',
+        transactions: pendingTransactions.all,
+    };
+};
+export const fromSerialized = (serialized) => {
+    return {
+        all: serialized.transactions,
+    };
+};

package/dist/pendingTransactions/pendingTransactionsService.d.ts

@@ -0,0 +1,52 @@
+import { type Clock, Effect, type ParseResult, Scope, Stream } from 'effect';
+import * as PendingTransactions from './pendingTransactions.js';
+import type * as rx from 'rxjs';
+import { type QueryClient } from '@midnightntwrk/wallet-sdk-indexer-client/effect';
+export type PendingTransactionsService<TTransaction> = {
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    state: () => rx.Observable<PendingTransactions.PendingTransactions<TTransaction>>;
+    addPendingTransaction: (tx: TTransaction) => Promise<void>;
+    clear: (tx: TTransaction) => Promise<void>;
+};
+export type IndexerClientConnection = {
+    indexerHttpUrl: string;
+    indexerWsUrl?: string;
+};
+export type DefaultPendingTransactionsServiceConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+};
+export type InitParams<TTransaction> = {
+    txTrait: PendingTransactions.TransactionTrait<TTransaction>;
+    initialState?: PendingTransactions.PendingTransactions<TTransaction>;
+    configuration: DefaultPendingTransactionsServiceConfiguration;
+};
+export declare class PendingTransactionsServiceImpl<TTransaction> implements PendingTransactionsService<TTransaction> {
+    #private;
+    static init<TTransaction>(initParams: InitParams<TTransaction>): Promise<PendingTransactionsServiceImpl<TTransaction>>;
+    static restore<TTransaction>(data: string, txTrait: PendingTransactions.TransactionTrait<TTransaction>, configuration: DefaultPendingTransactionsServiceConfiguration): Promise<PendingTransactionsServiceImpl<TTransaction>>;
+    private static initEffect;
+    constructor(effectService: PendingTransactionsServiceEffect<TTransaction>, scope: Scope.CloseableScope, configuration: DefaultPendingTransactionsServiceConfiguration);
+    addPendingTransaction(tx: TTransaction): Promise<void>;
+    clear(tx: TTransaction): Promise<void>;
+    start(): Promise<void>;
+    state(): rx.Observable<PendingTransactions.PendingTransactions<TTransaction>>;
+    stop(): Promise<void>;
+}
+export type PendingTransactionsServiceEffect<TTransaction> = {
+    startPolling: (ticks: Stream.Stream<unknown>) => Effect.Effect<void, Error, QueryClient | Scope.Scope | Clock.Clock>;
+    state: () => Stream.Stream<PendingTransactions.PendingTransactions<TTransaction>>;
+    addPendingTransaction: (tx: TTransaction) => Effect.Effect<void, never, never>;
+    clear: (tx: TTransaction) => Effect.Effect<void, never, never>;
+};
+export declare class PendingTransactionsServiceEffectImpl<TTransaction> implements PendingTransactionsServiceEffect<TTransaction> {
+    #private;
+    static restore<TTransaction>(data: string, txTrait: PendingTransactions.TransactionTrait<TTransaction>): Effect.Effect<PendingTransactionsServiceEffectImpl<TTransaction>, ParseResult.ParseError>;
+    constructor(txTrait: PendingTransactions.TransactionTrait<TTransaction>, initialState?: PendingTransactions.PendingTransactions<TTransaction>);
+    state(): Stream.Stream<PendingTransactions.PendingTransactions<TTransaction>>;
+    startPolling(ticks: Stream.Stream<unknown>): Effect.Effect<void, Error, QueryClient | Scope.Scope>;
+    addPendingTransaction(tx: TTransaction): Effect.Effect<void>;
+    clear(tx: TTransaction): Effect.Effect<void>;
+    private saveResult;
+    private queryForStatus;
+}