@midnight-ntwrk/wallet-sdk-shielded 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/ShieldedWallet.d.ts

@@ -2,7 +2,7 @@ import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstr
 import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
-import { ProvingRecipe } from './v1/ProvingRecipe.js';
+import { BalancingResult } from './v1/Transacting.js';
 import { SerializationCapability } from './v1/Serialization.js';
 import { ProgressUpdate, TransactionHistoryCapability } from './v1/TransactionHistory.js';
 import { AvailableCoin, CoinsAndBalancesCapability, PendingCoin } from './v1/CoinsAndBalances.js';
@@ -18,6 +18,7 @@ export type ShieldedWalletCapabilities<TSerialized = string, TTransaction = ledg
     keys: KeysCapability<CoreWallet>;
     transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
 };
+export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
 export declare class ShieldedWalletState<TSerialized = string, TTransaction = ledger.FinalizedTransaction> {
     static readonly mapState: <TSerialized_1 = string, TTransaction_1 = ledger.FinalizedTransaction>(capabilities: ShieldedWalletCapabilities<TSerialized_1, TTransaction_1>) => (state: ProtocolState.ProtocolState<CoreWallet>) => ShieldedWalletState<TSerialized_1, TTransaction_1>;
     readonly protocolVersion: ProtocolVersion.ProtocolVersion;
@@ -49,10 +50,10 @@ export interface CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TT
 ]> {
     readonly state: rx.Observable<ShieldedWalletState<TSerialized, TTransaction>>;
     start(secretKeys: TStartAux): Promise<void>;
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>, newCoins: readonly ledger.ShieldedCoinInfo[]): Promise<ProvingRecipe<TTransaction>>;
-    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
-    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Promise<TTransaction>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<BalancingResult>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    finalizeTransaction(transaction: ledger.UnprovenTransaction): Promise<TTransaction>;
     readonly submitTransaction: SubmitTransactionMethod<TTransaction>;
     serializeState(): Promise<TSerialized>;
     waitForSyncedState(allowedGap?: bigint): Promise<ShieldedWalletState<TSerialized, TTransaction>>;

package/dist/ShieldedWallet.js

@@ -107,10 +107,10 @@ export function CustomShieldedWallet(configuration, builder) {
                 .dispatch({ [V1Tag]: (v1) => v1.initSwap(secretKeys, desiredInputs, desiredOutputs) })
                 .pipe(Effect.runPromise);
         }
-        finalizeTransaction(recipe) {
+        finalizeTransaction(transaction) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.finalizeTransaction(recipe),
+                [V1Tag]: (v1) => v1.finalizeTransaction(transaction),
             })
                 .pipe(Effect.runPromise);
         }

package/dist/v1/Proving.d.ts

@@ -1,9 +1,8 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect } from 'effect';
-import { ProvingRecipe } from './ProvingRecipe.js';
 import { WalletError } from './WalletError.js';
 export interface ProvingService<TTransaction> {
-    prove(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
+    prove(transaction: ledger.UnprovenTransaction): Effect.Effect<TTransaction, WalletError>;
 }
 export type DefaultProvingConfiguration = {
     provingServerUrl: URL;

package/dist/v1/Proving.js

@@ -19,35 +19,18 @@ export const makeDefaultProvingService = (configuration) => {
         url: configuration.provingServerUrl,
     });
     return {
-        prove(recipe) {
-            switch (recipe.type) {
-                case 'BalanceTransactionToProve':
-                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transactionToProve, ledger.CostModel.initialCostModel())), Effect.map((provenTx) => recipe.transactionToBalance.merge(provenTx.bind())), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
-                        message: error.message,
-                        cause: error,
-                    }))));
-                case 'TransactionToProve':
-                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transaction, ledger.CostModel.initialCostModel())), Effect.map((proven) => proven.bind()), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
-                        message: error.message,
-                        cause: error,
-                    }))));
-                case 'NothingToProve':
-                    return Effect.succeed(recipe.transaction);
-            }
+        prove(transaction) {
+            return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(transaction, ledger.CostModel.initialCostModel())), Effect.map((transaction) => transaction.bind()), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
+                message: error.message,
+                cause: error,
+            }))));
         },
     };
 };
 export const makeSimulatorProvingService = () => {
     return {
-        prove(recipe) {
-            switch (recipe.type) {
-                case 'BalanceTransactionToProve':
-                    return pipe(Effect.succeed(recipe.transactionToProve.eraseProofs()), Effect.map((proven) => recipe.transactionToBalance.merge(proven)));
-                case 'TransactionToProve':
-                    return Effect.succeed(recipe.transaction.eraseProofs());
-                case 'NothingToProve':
-                    return Effect.succeed(recipe.transaction);
-            }
+        prove(transaction) {
+            return Effect.succeed(transaction.eraseProofs());
         },
     };
 };

package/dist/v1/RunningV1Variant.d.ts

@@ -2,10 +2,9 @@ import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect, Scope, Stream } from 'effect';
 import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import { ProvingService } from './Proving.js';
-import { ProvingRecipe } from './ProvingRecipe.js';
 import { SerializationCapability } from './Serialization.js';
 import { EventsSyncUpdate, SyncCapability, SyncService } from './Sync.js';
-import { TransactingCapability, TokenTransfer } from './Transacting.js';
+import { TransactingCapability, TokenTransfer, BalancingResult } from './Transacting.js';
 import { WalletError } from './WalletError.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
@@ -37,10 +36,10 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>);
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError, Scope.Scope>;
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<BalancingResult, WalletError>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    finalizeTransaction(transaction: ledger.UnprovenTransaction): Effect.Effect<TTransaction, WalletError>;
     submitTransaction: SubmitTransactionMethod<TTransaction>;
     serializeState(state: CoreWallet): TSerialized;
 }

package/dist/v1/RunningV1Variant.js

@@ -66,28 +66,28 @@ export class RunningV1Variant {
     }
     balanceTransaction(secretKeys, tx) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), EitherOps.toEffect);
         });
     }
     transferTransaction(secretKeys, outputs) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), EitherOps.toEffect);
         });
     }
     initSwap(secretKeys, desiredInputs, desiredOutputs) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), EitherOps.toEffect);
         });
     }
-    finalizeTransaction(recipe) {
+    finalizeTransaction(transaction) {
         return this.#v1Context.provingService
-            .prove(recipe)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertRecipe(state, recipe)))));
+            .prove(transaction)
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     }
     submitTransaction = ((transaction, waitForStatus = 'InBlock') => {
         return this.#v1Context.submissionService
             .submitTransaction(transaction, waitForStatus)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revert(state, transaction)))));
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     });
     serializeState(state) {
         return this.#v1Context.serializationCapability.serialize(state);

package/dist/v1/Sync.d.ts

@@ -1,5 +1,5 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Scope, Stream, Schema } from 'effect';
+import { Schema, Scope, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { Simulator, SimulatorState } from './Simulator.js';
 import { WalletError } from './WalletError.js';
@@ -16,6 +16,7 @@ export type IndexerClientConnection = {
 };
 export type DefaultSyncConfiguration = {
     indexerClientConnection: IndexerClientConnection;
+    batchSize?: number;
 };
 export type DefaultSyncContext = {
     transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
@@ -25,11 +26,11 @@ export declare const SecretKeysResource: {
     create: (secretKeys: ledger.ZswapSecretKeys) => SecretKeysResource;
 };
 export type WalletSyncUpdate = {
-    update: EventsSyncUpdate;
+    updates: EventsSyncUpdate[];
     secretKeys: SecretKeysResource;
 };
 export declare const WalletSyncUpdate: {
-    create: (update: EventsSyncUpdate, secretKeys: ledger.ZswapSecretKeys) => WalletSyncUpdate;
+    create: (updates: EventsSyncUpdate[], secretKeys: ledger.ZswapSecretKeys) => WalletSyncUpdate;
 };
 export declare const EventsSyncUpdate: Schema.TaggedStruct<"EventsSyncUpdate", {
     id: typeof Schema.Number;

package/dist/v1/Sync.js

@@ -11,10 +11,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Effect, ParseResult, Stream, Schema, pipe, Either, Duration } from 'effect';
+import { Chunk, Duration, Effect, Either, ParseResult, pipe, Schedule, Schema, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { ZswapEvents } from '@midnight-ntwrk/wallet-sdk-indexer-client';
-import { WsSubscriptionClient, ConnectionHelper } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { ConnectionHelper, WsSubscriptionClient } 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';
@@ -39,9 +39,9 @@ export const SecretKeysResource = {
     },
 };
 export const WalletSyncUpdate = {
-    create: (update, secretKeys) => {
+    create: (updates, secretKeys) => {
         return {
-            update,
+            updates,
             secretKeys: SecretKeysResource.create(secretKeys),
         };
     },
@@ -97,17 +97,20 @@ export const makeEventsSyncService = (config) => {
             }
             const indexerWsUrl = indexerWsUrlResult.right;
             const appliedIndex = state.progress?.appliedIndex ?? 0n;
-            const batchSize = 50;
-            const batchTimeout = Duration.seconds(10);
-            return pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl })), Stream.mapError((error) => new SyncWalletError(error)), Stream.mapEffect((subscription) => pipe(Schema.decodeUnknownEither(EventsSyncUpdateFromPayload)(subscription.zswapLedgerEvents), Either.mapLeft((err) => new SyncWalletError(err)), EitherOps.toEffect)), Stream.map((data) => WalletSyncUpdate.create(data, secretKeys)), Stream.groupedWithin(batchSize, batchTimeout), Stream.flatMap((chunk) => Stream.fromIterable(chunk)));
+            const batchSize = config.batchSize ?? 10;
+            return pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl })), Stream.mapError((error) => new SyncWalletError(error)), Stream.mapEffect((subscription) => pipe(subscription.zswapLedgerEvents, Schema.decodeUnknownEither(EventsSyncUpdateFromPayload), Either.mapLeft((err) => new SyncWalletError(err)), EitherOps.toEffect)), Stream.groupedWithin(batchSize, Duration.millis(1)), Stream.map(Chunk.toArray), Stream.map((data) => WalletSyncUpdate.create(data, secretKeys)), Stream.schedule(Schedule.spaced(Duration.millis(4))));
         },
     };
 };
 export const makeEventsSyncCapability = () => {
     return {
         applyUpdate: (state, wrappedUpdate) => {
-            const nextIndex = BigInt(wrappedUpdate.update.id);
-            const highestRelevantWalletIndex = BigInt(wrappedUpdate.update.maxId);
+            if (wrappedUpdate.updates.length === 0) {
+                return state;
+            }
+            const lastUpdate = wrappedUpdate.updates.at(-1);
+            const nextIndex = BigInt(lastUpdate.id);
+            const highestRelevantWalletIndex = BigInt(lastUpdate.maxId);
             // in case the nextIndex is less than or equal to the appliedIndex
             // just update highestRelevantWalletIndex
             if (nextIndex <= state.progress.appliedIndex) {
@@ -117,7 +120,7 @@ export const makeEventsSyncCapability = () => {
                 });
             }
             return wrappedUpdate.secretKeys((keys) => {
-                return CoreWallet.updateProgress(CoreWallet.replayEvents(state, keys, [wrappedUpdate.update.event]), {
+                return CoreWallet.updateProgress(CoreWallet.replayEvents(state, keys, wrappedUpdate.updates.map((u) => u.event)), {
                     highestRelevantWalletIndex,
                     appliedIndex: nextIndex,
                     isConnected: true,

package/dist/v1/Transacting.d.ts

@@ -1,12 +1,11 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Array as Arr, Either } from 'effect';
-import { ProvingRecipe } from './ProvingRecipe.js';
 import { CoreWallet } from './CoreWallet.js';
 import { WalletError } from './WalletError.js';
 import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { TransactionImbalances } from './TransactionImbalances.js';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps } from './TransactionOps.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
 export interface TokenTransfer {
@@ -14,21 +13,12 @@ export interface TokenTransfer {
     readonly type: ledger.RawTokenType;
     readonly receiverAddress: string;
 }
+export type BalancingResult = ledger.UnprovenTransaction | undefined;
 export interface TransactingCapability<TSecrets, TState, TTransaction> {
-    balanceTransaction(secrets: TSecrets, state: TState, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    makeTransfer(secrets: TSecrets, state: TState, outputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    initSwap(secrets: TSecrets, state: TState, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    revert(state: TState, tx: TTransaction): Either.Either<TState, WalletError>;
-    revertRecipe(state: TState, recipe: ProvingRecipe<TTransaction>): Either.Either<TState, WalletError>;
+    balanceTransaction(secrets: TSecrets, state: TState, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Either.Either<[BalancingResult, TState], WalletError>;
+    makeTransfer(secrets: TSecrets, state: TState, outputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, TState], WalletError>;
+    initSwap(secrets: TSecrets, state: TState, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, TState], WalletError>;
+    revertTransaction(state: TState, transaction: TTransaction | ledger.UnprovenTransaction): Either.Either<TState, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId.NetworkId;
@@ -44,24 +34,14 @@ export declare class TransactingCapabilityImplementation<TTransaction extends le
     #private;
     readonly networkId: NetworkId.NetworkId;
     readonly getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>;
-    readonly txTrait: TransactionTrait<TTransaction>;
+    readonly txOps: TransactionOps<TTransaction>;
     readonly getCoins: () => CoinsAndBalancesCapability<CoreWallet>;
     readonly getKeys: () => KeysCapability<CoreWallet>;
-    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txTrait: TransactionTrait<TTransaction>);
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, tx: TTransaction): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    makeTransfer(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, transfers: Arr.NonEmptyReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    revert(state: CoreWallet, tx: TTransaction): Either.Either<CoreWallet, WalletError>;
-    revertRecipe(state: CoreWallet, recipe: ProvingRecipe<TTransaction>): Either.Either<CoreWallet, WalletError>;
+    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txOps: TransactionOps<TTransaction>);
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, tx: TTransaction): Either.Either<[BalancingResult, CoreWallet], WalletError>;
+    makeTransfer(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, transfers: Arr.NonEmptyReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, CoreWallet], WalletError>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, CoreWallet], WalletError>;
+    revertTransaction(state: CoreWallet, transaction: TTransaction | ledger.UnprovenTransaction): Either.Either<CoreWallet, WalletError>;
     balanceFallibleSection(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, imbalances: TransactionImbalances, coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>): Either.Either<{
         offer: ledger.ZswapOffer<ledger.PreProof> | undefined;
         newState: CoreWallet;

package/dist/v1/Transacting.js

@@ -13,56 +13,41 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Array as Arr, Either, Option, pipe, Record } from 'effect';
 import { ArrayOps } from '@midnight-ntwrk/wallet-sdk-utilities';
-import { BALANCE_TRANSACTION_TO_PROVE, NOTHING_TO_PROVE, TRANSACTION_TO_PROVE, } from './ProvingRecipe.js';
 import { CoreWallet } from './CoreWallet.js';
 import { AddressError, InsufficientFundsError, OtherWalletError } from './WalletError.js';
 import { getBalanceRecipe, Imbalances, InsufficientFundsError as BalancingInsufficientFundsError, } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { MidnightBech32m, ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { ShieldedCostModel, TransactionImbalances } from './TransactionImbalances.js';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps } from './TransactionOps.js';
 export const makeDefaultTransactingCapability = (config, getContext) => {
-    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionTrait.default);
+    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps.default);
 };
 export const makeSimulatorTransactingCapability = (config, getContext) => {
-    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionTrait.proofErased);
+    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps.proofErased);
 };
 export class TransactingCapabilityImplementation {
     networkId;
     getCoinSelection;
-    txTrait;
+    txOps;
     getCoins;
     getKeys;
-    constructor(networkId, getCoinSelection, getCoins, getKeys, txTrait) {
+    constructor(networkId, getCoinSelection, getCoins, getKeys, txOps) {
         this.getCoins = getCoins;
         this.networkId = networkId;
         this.getCoinSelection = getCoinSelection;
         this.getKeys = getKeys;
-        this.txTrait = txTrait;
+        this.txOps = txOps;
     }
     balanceTransaction(secretKeys, state, tx) {
         return Either.gen(this, function* () {
             const coinSelection = this.getCoinSelection();
-            const networkId = this.networkId;
-            const initialImbalances = this.txTrait.getImbalances(tx);
+            const initialImbalances = this.txOps.getImbalances(tx);
             if (TransactionImbalances.areBalanced(initialImbalances)) {
-                return {
-                    recipe: {
-                        type: NOTHING_TO_PROVE,
-                        transaction: tx,
-                    },
-                    newState: state,
-                };
+                return [undefined, state];
             }
             const { newState: afterFallible, offer: maybeFallible } = yield* this.balanceFallibleSection(secretKeys, state, initialImbalances, coinSelection);
             const { newState: afterGuaranteed, offer: guaranteed } = yield* this.#balanceGuaranteedSection(secretKeys, afterFallible, initialImbalances, coinSelection, Imbalances.empty());
-            return {
-                newState: afterGuaranteed,
-                recipe: {
-                    type: BALANCE_TRANSACTION_TO_PROVE,
-                    transactionToBalance: tx,
-                    transactionToProve: ledger.Transaction.fromParts(networkId, guaranteed, maybeFallible),
-                },
-            };
+            return [ledger.Transaction.fromParts(this.networkId, guaranteed, maybeFallible), afterGuaranteed];
         });
     }
     makeTransfer(secretKeys, state, transfers) {
@@ -77,17 +62,11 @@ export class TransactingCapabilityImplementation {
             const { initialOffersAndCoins, selfCoins } = yield* this.#processDesiredOutputs(state, positiveTransfers);
             const offerToBalance = pipe(initialOffersAndCoins, Arr.map((o) => o.outputOffer), ArrayOps.fold((a, b) => a.merge(b)));
             const unprovenTxToBalance = ledger.Transaction.fromParts(networkId, offerToBalance);
-            const imbalances = TransactionTrait.unproven.getImbalances(unprovenTxToBalance);
+            const imbalances = TransactionOps.unproven.getImbalances(unprovenTxToBalance);
             const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, imbalances, this.getCoinSelection(), Imbalances.empty());
             const finalState = CoreWallet.watchCoins(newState, secretKeys, selfCoins);
             const finalTx = unprovenTxToBalance.merge(ledger.Transaction.fromParts(networkId, offer));
-            return {
-                newState: finalState,
-                recipe: {
-                    type: TRANSACTION_TO_PROVE,
-                    transaction: finalTx,
-                },
-            };
+            return [finalTx, finalState];
         });
     }
     initSwap(secretKeys, state, desiredInputs, desiredOutputs) {
@@ -113,51 +92,22 @@ export class TransactingCapabilityImplementation {
             const finalTx = outputsParseResult.unprovenTxToBalance
                 ? outputsParseResult.unprovenTxToBalance.merge(balancingTx)
                 : balancingTx;
-            return {
-                newState: finalState,
-                recipe: {
-                    type: TRANSACTION_TO_PROVE,
-                    transaction: finalTx,
-                },
-            };
+            return [finalTx, finalState];
         });
     }
-    revert(state, tx) {
+    revertTransaction(state, transaction) {
         return Either.try({
             try: () => {
-                return CoreWallet.revertTransaction(state, tx);
+                return CoreWallet.revertTransaction(state, transaction);
             },
             catch: (err) => {
                 return new OtherWalletError({
-                    message: `Error while reverting transaction ${this.txTrait.id(tx)}`,
+                    message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
                     cause: err,
                 });
             },
         });
     }
-    revertRecipe(state, recipe) {
-        const doRevert = (tx) => {
-            return Either.try({
-                try: () => {
-                    return CoreWallet.revertTransaction(state, tx);
-                },
-                catch: (err) => {
-                    return new OtherWalletError({
-                        message: `Error while reverting transaction ${TransactionTrait.unproven.id(tx)}`,
-                        cause: err,
-                    });
-                },
-            });
-        };
-        switch (recipe.type) {
-            case TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transaction);
-            case BALANCE_TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transactionToProve);
-            case NOTHING_TO_PROVE:
-                return Either.right(state);
-        }
-    }
     #prepareOffer(secretKeys, state, recipe, segment) {
         const [inputOffers, stateAfterSpends] = CoreWallet.spendCoins(state, secretKeys, recipe.inputs, segment);
         const stateAfterWatches = CoreWallet.watchCoins(stateAfterSpends, secretKeys, recipe.outputs);
@@ -301,7 +251,7 @@ export class TransactingCapabilityImplementation {
                     const networkId = this.networkId;
                     const offerToBalance = pipe(initialOffersAndCoins, Arr.map((o) => o.outputOffer), ArrayOps.fold((a, b) => a.merge(b)));
                     const unprovenTxToBalance = ledger.Transaction.fromParts(networkId, offerToBalance);
-                    const imbalances = TransactionTrait.unproven.getImbalances(unprovenTxToBalance);
+                    const imbalances = TransactionOps.unproven.getImbalances(unprovenTxToBalance);
                     return {
                         imbalances,
                         selfCoins,

package/dist/v1/{Transaction.d.ts → TransactionOps.d.ts}

@@ -1,14 +1,14 @@
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { TransactionImbalances } from './TransactionImbalances.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-export type TransactionTrait<Tx> = {
+export type TransactionOps<Tx> = {
     getImbalances(tx: Tx): TransactionImbalances;
     id(tx: Tx): string;
 };
-export declare const TransactionTrait: {
-    default: TransactionTrait<ledger.FinalizedTransaction>;
-    proofErased: TransactionTrait<ledger.ProofErasedTransaction>;
-    unproven: TransactionTrait<ledger.UnprovenTransaction>;
+export declare const TransactionOps: {
+    default: TransactionOps<ledger.FinalizedTransaction>;
+    proofErased: TransactionOps<ledger.ProofErasedTransaction>;
+    unproven: TransactionOps<ledger.UnprovenTransaction>;
     shared: {
         getImbalances(tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction): TransactionImbalances;
         getGuaranteedImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;

package/dist/v1/{Transaction.js → TransactionOps.js}

@@ -12,10 +12,10 @@
 // limitations under the License.
 import { pipe } from 'effect';
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-export const TransactionTrait = new (class {
+export const TransactionOps = new (class {
     default = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -23,7 +23,7 @@ export const TransactionTrait = new (class {
     };
     proofErased = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -31,7 +31,7 @@ export const TransactionTrait = new (class {
     };
     unproven = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -39,8 +39,8 @@ export const TransactionTrait = new (class {
     };
     shared = {
         getImbalances(tx) {
-            const guaranteedImbalances = TransactionTrait.shared.getGuaranteedImbalances(tx);
-            const fallibleImbalances = TransactionTrait.shared.getFallibleImbalances(tx);
+            const guaranteedImbalances = TransactionOps.shared.getGuaranteedImbalances(tx);
+            const fallibleImbalances = TransactionOps.shared.getFallibleImbalances(tx);
             return pipe({
                 guaranteed: guaranteedImbalances,
                 fallible: fallibleImbalances,

package/dist/v1/index.d.ts

@@ -5,7 +5,6 @@ export * as Transacting from './Transacting.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as Proving from './Proving.js';
-export * as ProvingRecipe from './ProvingRecipe.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
@@ -13,4 +12,4 @@ export * as Simulator from './Simulator.js';
 export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';

package/dist/v1/index.js

@@ -17,7 +17,6 @@ export * as Transacting from './Transacting.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as Proving from './Proving.js';
-export * as ProvingRecipe from './ProvingRecipe.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
@@ -25,4 +24,4 @@ export * as Simulator from './Simulator.js';
 export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-shielded",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.16",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -28,17 +28,17 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v7": "7.0.0-alpha.1",
+    "@midnight-ntwrk/ledger-v7": "7.0.0-rc.1",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.15",
-    "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0-beta.11",
-    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.12",
-    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.9",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.16",
+    "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0-beta.12",
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.13",
+    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.10",
     "@scure/base": "^1.1.9",
-    "effect": "^3.17.3",
+    "effect": "^3.19.14",
     "isomorphic-ws": "^5.0.0",
     "node-fetch": "3.3.2",
     "rxjs": "^7.5",

package/dist/v1/ProvingRecipe.d.ts

@@ -1,18 +0,0 @@
-import * as ledger from '@midnight-ntwrk/ledger-v7';
-export declare const TRANSACTION_TO_PROVE = "TransactionToProve";
-export declare const BALANCE_TRANSACTION_TO_PROVE = "BalanceTransactionToProve";
-export declare const NOTHING_TO_PROVE = "NothingToProve";
-export type TransactionToProve = {
-    readonly type: typeof TRANSACTION_TO_PROVE;
-    readonly transaction: ledger.UnprovenTransaction;
-};
-export type BalanceTransactionToProve<Transaction> = {
-    readonly type: typeof BALANCE_TRANSACTION_TO_PROVE;
-    readonly transactionToProve: ledger.UnprovenTransaction;
-    readonly transactionToBalance: Transaction;
-};
-export type NothingToProve<Transaction> = {
-    readonly type: typeof NOTHING_TO_PROVE;
-    readonly transaction: Transaction;
-};
-export type ProvingRecipe<Transaction> = TransactionToProve | BalanceTransactionToProve<Transaction> | NothingToProve<Transaction>;

package/dist/v1/ProvingRecipe.js

@@ -1,3 +0,0 @@
-export const TRANSACTION_TO_PROVE = 'TransactionToProve';
-export const BALANCE_TRANSACTION_TO_PROVE = 'BalanceTransactionToProve';
-export const NOTHING_TO_PROVE = 'NothingToProve';