@midnight-ntwrk/wallet-sdk-shielded 1.0.0 → 2.0.0-rc.0

package/README.md

@@ -54,7 +54,7 @@ await shieldedWallet.start(shieldedSecretKeys);
 
 ```typescript
 // Start directly with a shielded seed
-const shieldedWallet = ShieldedWallet(configuration).startWithShieldedSeed(seed);
+const shieldedWallet = ShieldedWallet(configuration).startWithSeed(seed);
 await shieldedWallet.start(ledger.ZswapSecretKeys.fromSeed(seed));
 ```
 

package/dist/ShieldedWallet.d.ts

@@ -1,17 +1,16 @@
-import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
+import { type ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type BaseV1Configuration, type DefaultV1Configuration, type V1Variant, CoreWallet } from './v1/index.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
-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';
-import { KeysCapability } from './v1/Keys.js';
-import { ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { SubmissionEvent, SubmissionEventCases } from './v1/Submission.js';
-import { TokenTransfer } from './v1/Transacting.js';
-import { WalletSyncUpdate } from './v1/Sync.js';
-import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type BalancingResult } from './v1/Transacting.js';
+import { type SerializationCapability } from './v1/Serialization.js';
+import { type ProgressUpdate, type TransactionHistoryCapability } from './v1/TransactionHistory.js';
+import { type AvailableCoin, type CoinsAndBalancesCapability, type PendingCoin } from './v1/CoinsAndBalances.js';
+import { type KeysCapability } from './v1/Keys.js';
+import { type ShieldedAddress, type ShieldedCoinPublicKey, type ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type TokenTransfer } from './v1/Transacting.js';
+import { type WalletSyncUpdate } from './v1/Sync.js';
+import { type Variant, type VariantBuilder, type WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 export type ShieldedWalletCapabilities<TSerialized = string, TTransaction = ledger.FinalizedTransaction> = {
     serialization: SerializationCapability<CoreWallet, null, TSerialized>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
@@ -32,38 +31,36 @@ export declare class ShieldedWalletState<TSerialized = string, TTransaction = le
     get encryptionPublicKey(): ShieldedEncryptionPublicKey;
     get address(): ShieldedAddress;
     get progress(): ProgressUpdate;
-    get transactionHistory(): readonly TTransaction[];
+    /**
+     * Transaction history for the wallet.
+     * @throws Error - Not yet implemented
+     */
+    get transactionHistory(): never;
     constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>);
     serialize(): TSerialized;
 }
-export type SubmitTransactionMethod<TTransaction> = {
-    (transaction: TTransaction, waitForStatus: 'Submitted'): Promise<SubmissionEventCases.Submitted>;
-    (transaction: TTransaction, waitForStatus: 'InBlock'): Promise<SubmissionEventCases.InBlock>;
-    (transaction: TTransaction, waitForStatus: 'Finalized'): Promise<SubmissionEventCases.Finalized>;
-    (transaction: TTransaction): Promise<SubmissionEventCases.InBlock>;
-    (transaction: TTransaction, waitForStatus?: 'Submitted' | 'InBlock' | 'Finalized'): Promise<SubmissionEvent>;
-};
 export type ShieldedWallet = CustomizedShieldedWallet<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
 export type ShieldedWalletClass = CustomizedShieldedWalletClass<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export interface CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[
-    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
-]> {
+export type ShieldedWalletAPI<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSerialized = string> = {
     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>): 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>>;
     getAddress(): Promise<ShieldedAddress>;
-}
-export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<void>;
+    stop(): Promise<void>;
+};
+export type CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> = ShieldedWalletAPI<TStartAux, TTransaction, TSerialized> & WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>]>;
+export type DefaultShieldedConfiguration = DefaultV1Configuration;
+export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultShieldedConfiguration> extends WalletLike.BaseWalletClass<[
     Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
 ]> {
     configuration: TConfig;
-    startWithShieldedSeed(seed: Uint8Array): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    startWithSeed(seed: Uint8Array): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
     startWithSecretKeys(secretKeys: ledger.ZswapSecretKeys): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
     restore(serializedState: TSerialized): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
 }

package/dist/ShieldedWallet.js

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { V1Builder, V1Tag, CoreWallet } from './v1/index.js';
+import { V1Builder, V1Tag, CoreWallet, } from './v1/index.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
@@ -47,8 +47,12 @@ export class ShieldedWalletState {
     get progress() {
         return this.capabilities.transactionHistory.progress(this.state);
     }
+    /**
+     * Transaction history for the wallet.
+     * @throws Error - Not yet implemented
+     */
     get transactionHistory() {
-        return this.capabilities.transactionHistory.transactionHistory(this.state);
+        throw new Error('Transaction history is not yet implemented for ShieldedWallet');
     }
     constructor(state, capabilities) {
         this.protocolVersion = state.version;
@@ -71,7 +75,7 @@ export function CustomShieldedWallet(configuration, builder) {
         static startWithSecretKeys(secretKeys) {
             return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, CoreWallet.initEmpty(secretKeys, CustomShieldedWalletImplementation.configuration.networkId));
         }
-        static startWithShieldedSeed(seed) {
+        static startWithSeed(seed) {
             const secretKeys = ledger.ZswapSecretKeys.fromSeed(seed);
             return CustomShieldedWalletImplementation.startWithSecretKeys(secretKeys);
         }
@@ -114,11 +118,13 @@ export function CustomShieldedWallet(configuration, builder) {
             })
                 .pipe(Effect.runPromise);
         }
-        submitTransaction = ((tx, waitForStatus = 'InBlock') => {
+        revertTransaction(transaction) {
             return this.runtime
-                .dispatch({ [V1Tag]: (v1) => v1.submitTransaction(tx, waitForStatus) })
+                .dispatch({
+                [V1Tag]: (v1) => v1.revertTransaction(transaction),
+            })
                 .pipe(Effect.runPromise);
-        });
+        }
         waitForSyncedState(allowedGap = 0n) {
             return rx.firstValueFrom(this.state.pipe(rx.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
         }

package/dist/v1/CoreWallet.d.ts

@@ -28,22 +28,21 @@ export type CoreWallet = Readonly<{
     protocolVersion: ProtocolVersion.ProtocolVersion;
     progress: SyncProgress;
     networkId: string;
-    txHistoryArray: readonly ledger.FinalizedTransaction[];
     coinHashes: CoinHashesMap;
 }>;
 export declare const CoreWallet: {
     init(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
     empty(publicKeys: PublicKeys, networkId: string): CoreWallet;
-    restore(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, txHistory: readonly ledger.FinalizedTransaction[], syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
-    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, txHistory: readonly ledger.FinalizedTransaction[], coinHashes: CoinHashesMap, syncProgress: SyncProgressData, protocolVersion: bigint, networkId: string): Either.Either<CoreWallet, WalletError>;
+    restore(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
+    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, coinHashes: CoinHashesMap, syncProgress: SyncProgressData, protocolVersion: bigint, networkId: string): Either.Either<CoreWallet, WalletError>;
     initEmpty(keys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
     applyCollapsedUpdate(wallet: CoreWallet, collapsed: ledger.MerkleTreeCollapsedUpdate): CoreWallet;
     apply<TOffer extends ledger.ZswapOffer<ledger.Proofish>>(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, offer: TOffer): CoreWallet;
     replayEvents(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, events: ledger.Event[]): CoreWallet;
     updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgressData>): CoreWallet;
-    addTransaction(wallet: CoreWallet, tx: ledger.FinalizedTransaction): CoreWallet;
+    addTransaction(wallet: CoreWallet, _tx: ledger.FinalizedTransaction): CoreWallet;
     revertTransaction<TTx extends ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>>(wallet: CoreWallet, _tx: TTx): CoreWallet;
-    updateTxHistory(wallet: CoreWallet, newTxs: readonly ledger.FinalizedTransaction[]): CoreWallet;
+    updateTxHistory(wallet: CoreWallet, _newTxs: readonly ledger.FinalizedTransaction[]): CoreWallet;
     spendCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.QualifiedShieldedCoinInfo>, segment: number): [ReadonlyArray<ledger.ZswapOffer<ledger.PreProof>>, CoreWallet];
     watchCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.ShieldedCoinInfo>): CoreWallet;
 };

package/dist/v1/CoreWallet.js

@@ -58,7 +58,7 @@ export const CoreWallet = {
         const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
         const progress = createSyncProgress();
         const protocolVersion = ProtocolVersion.MinSupportedVersion;
-        return { state: localState, publicKeys, networkId, coinHashes, txHistoryArray: [], progress, protocolVersion };
+        return { state: localState, publicKeys, networkId, coinHashes, progress, protocolVersion };
     },
     empty(publicKeys, networkId) {
         return {
@@ -66,12 +66,11 @@ export const CoreWallet = {
             publicKeys,
             networkId,
             coinHashes: CoinHashesMap.empty,
-            txHistoryArray: [],
             progress: createSyncProgress(),
             protocolVersion: ProtocolVersion.MinSupportedVersion,
         };
     },
-    restore(localState, secretKeys, txHistory, syncProgress, protocolVersion, networkId) {
+    restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
         const publicKeys = PublicKeys.fromSecretKeys(secretKeys);
         const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
         return {
@@ -79,12 +78,11 @@ export const CoreWallet = {
             publicKeys,
             networkId,
             coinHashes,
-            txHistoryArray: txHistory,
             progress: createSyncProgress(syncProgress),
             protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
         };
     },
-    restoreWithCoinHashes(publicKeys, localState, txHistory, coinHashes, syncProgress, protocolVersion, networkId) {
+    restoreWithCoinHashes(publicKeys, localState, coinHashes, syncProgress, protocolVersion, networkId) {
         return CoinHashesMap.assertValid(coinHashes, localState).pipe(Either.mapBoth({
             onLeft: (missingNonces) => new InvalidCoinHashesError({ message: 'Missing coin hashes for coins present in the state', missingNonces }),
             onRight: () => ({
@@ -92,7 +90,6 @@ export const CoreWallet = {
                 publicKeys,
                 networkId,
                 coinHashes,
-                txHistoryArray: txHistory,
                 progress: createSyncProgress(syncProgress),
                 protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
             }),
@@ -125,15 +122,17 @@ export const CoreWallet = {
         });
         return { ...wallet, progress: updatedProgress };
     },
-    addTransaction(wallet, tx) {
-        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, tx] };
+    // TODO: Remove after tx history is implemented
+    addTransaction(wallet, _tx) {
+        return wallet;
     },
     /* not implemented until this is done https://shielded.atlassian.net/browse/PM-19678 */
     revertTransaction(wallet, _tx) {
         return wallet;
     },
-    updateTxHistory(wallet, newTxs) {
-        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, ...newTxs] };
+    // TODO: Remove after tx history is implemented
+    updateTxHistory(wallet, _newTxs) {
+        return wallet;
     },
     spendCoins(wallet, secretKeys, coins, segment) {
         const [offers, newLocalState] = pipe(coins, Arr.reduce([[], wallet.state], ([accOffers, localState], coinToSpend) => {

package/dist/v1/Proving.d.ts

@@ -1,11 +1,21 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Effect } from 'effect';
+import type { KeyMaterialProvider } from '@midnight-ntwrk/zkir-v2';
+import { ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
+import { InvalidProtocolSchemeError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { Effect, Layer } from 'effect';
 import { WalletError } from './WalletError.js';
 export interface ProvingService<TTransaction> {
     prove(transaction: ledger.UnprovenTransaction): Effect.Effect<TTransaction, WalletError>;
 }
-export type DefaultProvingConfiguration = {
+export declare const makeProvingService: (clientLayer: Layer.Layer<ProverClient.ProverClient, InvalidProtocolSchemeError>) => ProvingService<ledger.FinalizedTransaction>;
+export type WasmProvingConfiguration = {
+    keyMaterialProvider?: KeyMaterialProvider;
+};
+export type ProvingServerConfiguration = {
     provingServerUrl: URL;
 };
+export type DefaultProvingConfiguration = ProvingServerConfiguration;
 export declare const makeDefaultProvingService: (configuration: DefaultProvingConfiguration) => ProvingService<ledger.FinalizedTransaction>;
+export declare const makeServerProvingService: (configuration: ProvingServerConfiguration) => ProvingService<ledger.FinalizedTransaction>;
+export declare const makeWasmProvingService: (configuration: WasmProvingConfiguration) => ProvingService<ledger.FinalizedTransaction>;
 export declare const makeSimulatorProvingService: () => ProvingService<ledger.ProofErasedTransaction>;

package/dist/v1/Proving.js

@@ -10,14 +10,11 @@
 // 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 { HttpProverClient, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { HttpProverClient, WasmProver, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
 import { Effect, pipe } from 'effect';
 import { ProvingError } from './WalletError.js';
-export const makeDefaultProvingService = (configuration) => {
-    const clientLayer = HttpProverClient.layer({
-        url: configuration.provingServerUrl,
-    });
+export const makeProvingService = (clientLayer) => {
     return {
         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({
@@ -27,6 +24,19 @@ export const makeDefaultProvingService = (configuration) => {
         },
     };
 };
+export const makeDefaultProvingService = (configuration) => makeServerProvingService(configuration);
+export const makeServerProvingService = (configuration) => {
+    const clientLayer = HttpProverClient.layer({
+        url: configuration.provingServerUrl,
+    });
+    return makeProvingService(clientLayer);
+};
+export const makeWasmProvingService = (configuration) => {
+    const proverLayer = WasmProver.layer({
+        keyMaterialProvider: configuration.keyMaterialProvider ?? WasmProver.makeDefaultKeyMaterialProvider(),
+    });
+    return makeProvingService(proverLayer);
+};
 export const makeSimulatorProvingService = () => {
     return {
         prove(transaction) {

package/dist/v1/RunningV1Variant.d.ts

@@ -1,17 +1,16 @@
-import * as ledger from '@midnight-ntwrk/ledger-v7';
+import type * 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 { SerializationCapability } from './Serialization.js';
-import { EventsSyncUpdate, SyncCapability, SyncService } from './Sync.js';
-import { TransactingCapability, TokenTransfer, BalancingResult } from './Transacting.js';
-import { WalletError } from './WalletError.js';
-import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
-import { KeysCapability } from './Keys.js';
-import { SubmissionService, SubmitTransactionMethod } from './Submission.js';
-import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { CoreWallet } from './CoreWallet.js';
-import { TransactionHistoryCapability } from './TransactionHistory.js';
+import { type WalletRuntimeError, type Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type ProvingService } from './Proving.js';
+import { type SerializationCapability } from './Serialization.js';
+import { type EventsSyncUpdate, type SyncCapability, type SyncService } from './Sync.js';
+import { type TransactingCapability, type TokenTransfer, type BalancingResult } from './Transacting.js';
+import { type WalletError } from './WalletError.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { type CoreWallet } from './CoreWallet.js';
+import { type TransactionHistoryCapability } from './TransactionHistory.js';
 export declare namespace RunningV1Variant {
     type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
         serializationCapability: SerializationCapability<CoreWallet, null, TSerialized>;
@@ -21,7 +20,6 @@ export declare namespace RunningV1Variant {
         provingService: ProvingService<TTransaction>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
-        submissionService: SubmissionService<TTransaction>;
         coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>;
         transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, TTransaction>;
     };
@@ -40,6 +38,6 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     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>;
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<void, WalletError>;
     serializeState(state: CoreWallet): TSerialized;
 }

package/dist/v1/RunningV1Variant.js

@@ -84,11 +84,11 @@ export class RunningV1Variant {
             .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.revertTransaction(state, transaction)))));
-    });
+    revertTransaction(transaction) {
+        return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), EitherOps.toEffect);
+        });
+    }
     serializeState(state) {
         return this.#v1Context.serializationCapability.serialize(state);
     }

package/dist/v1/Serialization.js

@@ -14,33 +14,12 @@ import { Effect, ParseResult, Either, pipe, Schema } from 'effect';
 import { WalletError } from './WalletError.js';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { CoreWallet } from './CoreWallet.js';
-const TxSchema = Schema.declare((input) => input instanceof ledger.Transaction).annotations({
-    identifier: 'ledger.Transaction',
-});
 const StateSchema = Schema.declare((input) => input instanceof ledger.ZswapLocalState).annotations({
     identifier: 'ledger.ZswapLocalState',
 });
 const Uint8ArraySchema = Schema.declare((input) => input instanceof Uint8Array).annotations({
     identifier: 'Uint8Array',
 });
-const TxFromUint8Array = () => Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, TxSchema, {
-    encode: (tx) => {
-        return Effect.try({
-            try: () => {
-                return tx.serialize();
-            },
-            catch: (err) => {
-                return new ParseResult.Unexpected(err, 'Could not serialize transaction');
-            },
-        });
-    },
-    decode: (bytes) => Effect.try({
-        try: () => ledger.Transaction.deserialize('signature', 'proof', 'binding', bytes),
-        catch: (err) => {
-            return new ParseResult.Unexpected(err, 'Could not deserialize transaction');
-        },
-    }),
-}));
 const StateFromUInt8Array = () => Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, StateSchema, {
     encode: (state) => {
         return Effect.try({
@@ -59,7 +38,6 @@ const StateFromUInt8Array = () => Schema.asSchema(Schema.transformOrFail(Uint8Ar
         },
     }),
 }));
-const HexedTx = () => pipe(Schema.Uint8ArrayFromHex, Schema.compose(TxFromUint8Array()));
 const HexedState = () => pipe(Schema.Uint8ArrayFromHex, Schema.compose(StateFromUInt8Array()));
 export const makeDefaultV1SerializationCapability = () => {
     const SnapshotSchema = Schema.Struct({
@@ -67,7 +45,6 @@ export const makeDefaultV1SerializationCapability = () => {
             coinPublicKey: Schema.String,
             encryptionPublicKey: Schema.String,
         }),
-        txHistory: Schema.Array(HexedTx()),
         state: HexedState(),
         protocolVersion: Schema.BigInt,
         offset: Schema.optional(Schema.BigInt),
@@ -81,7 +58,6 @@ export const makeDefaultV1SerializationCapability = () => {
         serialize: (wallet) => {
             const buildSnapshot = (w) => ({
                 publicKeys: w.publicKeys,
-                txHistory: w.txHistoryArray,
                 state: w.state,
                 protocolVersion: w.protocolVersion,
                 networkId: w.networkId,
@@ -91,7 +67,7 @@ export const makeDefaultV1SerializationCapability = () => {
             return pipe(wallet, buildSnapshot, Schema.encodeSync(SnapshotSchema), JSON.stringify);
         },
         deserialize: (aux, serialized) => {
-            return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SnapshotSchema)), Either.mapLeft((err) => WalletError.other(err)), Either.flatMap((snapshot) => CoreWallet.restoreWithCoinHashes(snapshot.publicKeys, snapshot.state, snapshot.txHistory, snapshot.coinHashes, {
+            return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SnapshotSchema)), Either.mapLeft((err) => WalletError.other(err)), Either.flatMap((snapshot) => CoreWallet.restoreWithCoinHashes(snapshot.publicKeys, snapshot.state, snapshot.coinHashes, {
                 appliedIndex: snapshot.offset ?? 0n,
                 highestRelevantWalletIndex: 0n,
                 highestIndex: 0n,

package/dist/v1/Simulator.d.ts

@@ -1,5 +1,5 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Array as Arr, Effect, Scope, Stream, SubscriptionRef } from 'effect';
+import { Array as Arr, Effect, type Scope, Stream, SubscriptionRef } from 'effect';
 export type SimulatorState = Readonly<{
     ledger: ledger.LedgerState;
     lastTxResult: ledger.TransactionResult;
@@ -15,7 +15,7 @@ export declare class Simulator {
     }>>): Effect.Effect<Simulator, never, Scope.Scope>;
     readonly state$: Stream.Stream<SimulatorState>;
     constructor(stateRef: SubscriptionRef.SubscriptionRef<SimulatorState>, state$: Stream.Stream<SimulatorState>);
-    submitRegularTx(tx: ledger.ProofErasedTransaction): Effect.Effect<{
+    submitTransaction(tx: ledger.ProofErasedTransaction): Effect.Effect<{
         blockNumber: bigint;
         blockHash: string;
     }>;

package/dist/v1/Simulator.js

@@ -76,7 +76,7 @@ export class Simulator {
         this.#stateRef = stateRef;
         this.state$ = state$;
     }
-    submitRegularTx(tx) {
+    submitTransaction(tx) {
         return pipe(this.#stateRef, SubscriptionRef.modifyEffect((simulatorState) => Effect.gen(function* () {
             const nextNumber = simulatorState.lastTxNumber + 1n;
             const context = yield* Simulator.nextBlockContext(nextNumber);

package/dist/v1/Transacting.d.ts

@@ -4,6 +4,7 @@ import { Array as Arr, Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { WalletError } from './WalletError.js';
 import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { TransactionImbalances } from './TransactionImbalances.js';
 import { TransactionOps } from './TransactionOps.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
@@ -11,14 +12,14 @@ import { KeysCapability } from './Keys.js';
 export interface TokenTransfer {
     readonly amount: bigint;
     readonly type: ledger.RawTokenType;
-    readonly receiverAddress: string;
+    readonly receiverAddress: ShieldedAddress;
 }
 export type BalancingResult = ledger.UnprovenTransaction | undefined;
-export interface TransactingCapability<TSecrets, TState, TTransaction> {
+export interface TransactingCapability<TSecrets, TState, _TTransaction> {
     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>;
+    revertTransaction(state: TState, transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Either.Either<TState, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId.NetworkId;

package/dist/v1/Transacting.js

@@ -14,9 +14,8 @@ 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 { CoreWallet } from './CoreWallet.js';
-import { AddressError, InsufficientFundsError, OtherWalletError } from './WalletError.js';
+import { 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 { TransactionOps } from './TransactionOps.js';
 export const makeDefaultTransactingCapability = (config, getContext) => {
@@ -197,44 +196,36 @@ export class TransactingCapabilityImplementation {
             }));
         });
     }
-    #parseAddress(addr) {
+    #processDesiredOutputs(state, transfers) {
         return Either.try({
             try: () => {
-                const repr = MidnightBech32m.parse(addr);
-                return ShieldedAddress.codec.decode(this.networkId, repr);
-            },
-            catch: (err) => {
-                return new AddressError({
-                    message: `Address parsing error: ${addr}`,
-                    originalAddress: addr,
-                    cause: err,
-                });
-            },
-        });
-    }
-    #processDesiredOutputs(state, transfers) {
-        return Either.gen(this, function* () {
-            const initialOffersAndCoins = yield* pipe(transfers, Arr.map((transfer) => {
-                return pipe(this.#parseAddress(transfer.receiverAddress), Either.map((address) => {
-                    const coin = ledger.createShieldedCoinInfo(transfer.type, transfer.amount);
-                    const output = ledger.ZswapOutput.new(coin, 0, address.coinPublicKey.toHexString(), address.encryptionPublicKey.toHexString());
-                    const outputOffer = ledger.ZswapOffer.fromOutput(output, transfer.type, transfer.amount);
+                const initialOffersAndCoins = pipe(transfers, Arr.map((transfer) => {
+                    const { receiverAddress, type, amount } = transfer;
+                    const coin = ledger.createShieldedCoinInfo(type, amount);
+                    const output = ledger.ZswapOutput.new(coin, 0, receiverAddress.coinPublicKey.toHexString(), receiverAddress.encryptionPublicKey.toHexString());
+                    const outputOffer = ledger.ZswapOffer.fromOutput(output, type, amount);
                     return {
                         coin,
                         outputOffer,
-                        isForSelf: address.coinPublicKey.equals(this.getKeys().getCoinPublicKey(state)),
+                        isForSelf: receiverAddress.coinPublicKey.equals(this.getKeys().getCoinPublicKey(state)),
                     };
                 }));
-            }), Either.all);
-            const selfCoins = Arr.flatMap(initialOffersAndCoins, ({ coin, isForSelf }) => {
-                if (isForSelf) {
-                    return [coin];
-                }
-                else {
-                    return [];
-                }
-            });
-            return { initialOffersAndCoins, selfCoins };
+                const selfCoins = Arr.flatMap(initialOffersAndCoins, ({ coin, isForSelf }) => {
+                    if (isForSelf) {
+                        return [coin];
+                    }
+                    else {
+                        return [];
+                    }
+                });
+                return { initialOffersAndCoins, selfCoins };
+            },
+            catch: (err) => {
+                return new OtherWalletError({
+                    message: 'Failed to process desired outputs',
+                    cause: err,
+                });
+            },
         });
     }
     #processDesiredOutputsPossiblyEmpty(state, desiredOutputs) {

package/dist/v1/TransactionHistory.js

@@ -4,8 +4,8 @@ export const makeDefaultTransactionHistoryCapability = () => {
         updateTxHistory: (state, newTxs) => {
             return newTxs.reduce((acc, tx) => CoreWallet.addTransaction(acc, tx), state);
         },
-        transactionHistory: (state) => {
-            return state.txHistoryArray;
+        transactionHistory: (_state) => {
+            return [];
         },
         progress: (state) => {
             return {
@@ -22,8 +22,8 @@ export const makeSimulatorTransactionHistoryCapability = () => {
         updateTxHistory: (state, newTxs) => {
             return CoreWallet.updateTxHistory(state, newTxs); // @TODO fix this cast
         },
-        transactionHistory: (state) => {
-            return state.txHistoryArray; // @TODO fix this cast
+        transactionHistory: (_state) => {
+            return [];
         },
         progress: (state) => {
             return {
@@ -40,8 +40,8 @@ export const makeDiscardTransactionHistoryCapability = () => {
         updateTxHistory: (state) => {
             return state;
         },
-        transactionHistory: (state) => {
-            return state.txHistoryArray;
+        transactionHistory: (_state) => {
+            return [];
         },
         progress: (state) => {
             return {

package/dist/v1/V1Builder.d.ts

@@ -1,23 +1,22 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { Either, Types } from 'effect';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { Variant, VariantBuilder } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
-import { DefaultProvingConfiguration, ProvingService } from './Proving.js';
+import { type Either, type Types } from 'effect';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type Variant, type VariantBuilder } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type DefaultProvingConfiguration, type ProvingService } from './Proving.js';
 import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
-import { SerializationCapability } from './Serialization.js';
-import { DefaultSyncContext, DefaultSyncConfiguration, SyncCapability, SyncService, WalletSyncUpdate } from './Sync.js';
-import { DefaultTransactingConfiguration, DefaultTransactingContext, TransactingCapability } from './Transacting.js';
-import { WalletError } from './WalletError.js';
-import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
-import { KeysCapability } from './Keys.js';
-import { DefaultSubmissionConfiguration, SubmissionService } from './Submission.js';
-import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { type SerializationCapability } from './Serialization.js';
+import { type DefaultSyncContext, type DefaultSyncConfiguration, type SyncCapability, type SyncService, type WalletSyncUpdate } from './Sync.js';
+import { type DefaultTransactingConfiguration, type DefaultTransactingContext, type TransactingCapability } from './Transacting.js';
+import { type WalletError } from './WalletError.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { CoreWallet } from './CoreWallet.js';
-import { TransactionHistoryCapability } from './TransactionHistory.js';
+import { type TransactionHistoryCapability } from './TransactionHistory.js';
 export type BaseV1Configuration = {
     networkId: NetworkId.NetworkId;
 };
-export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultProvingConfiguration & DefaultTransactingConfiguration & DefaultSubmissionConfiguration;
+export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultProvingConfiguration & DefaultTransactingConfiguration;
 declare const V1BuilderSymbol: {
     readonly typeId: unique symbol;
 };
@@ -56,8 +55,6 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
     withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryCapability: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryCapability<CoreWallet, TTransaction>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
-    withSubmission<TSubmissionConfig, TSubmissionContext extends Partial<RunningV1Variant.AnyContext>>(submissionService: (config: TSubmissionConfig, getContext: () => TSubmissionContext) => SubmissionService<TTransaction>): V1Builder<TConfig & TSubmissionConfig, TContext & TSubmissionContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
-    withSubmissionDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultSubmissionConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
     build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TSerialized, TSyncUpdate, TTransaction, TStartAux>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>;
 }
 /** @internal */
@@ -87,13 +84,10 @@ declare namespace V1Builder {
     type HasKeys<TConfig, TContext> = {
         readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<CoreWallet>;
     };
-    type HasSubmission<TConfig, TContext, TTransaction> = {
-        readonly submissionService: (configuration: TConfig, getContext: () => TContext) => SubmissionService<TTransaction>;
-    };
     /**
      * The internal build state of {@link V1Builder}.
      */
-    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasProving<TConfig, TContext, TTransaction> & HasSubmission<TConfig, TContext, TTransaction> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext, TTransaction>>;
+    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasProving<TConfig, TContext, TTransaction> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext, TTransaction>>;
     type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never, TTransaction = never, TStartAux = object> = {
         [K in keyof FullBuildState<never, never, never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>[K] | undefined;
     };

package/dist/v1/V1Builder.js

@@ -20,7 +20,6 @@ import { makeEventsSyncService, makeEventsSyncCapability, } from './Sync.js';
 import { makeDefaultTransactingCapability, } from './Transacting.js';
 import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { makeDefaultKeysCapability } from './Keys.js';
-import { makeDefaultSubmissionService } from './Submission.js';
 import { chooseCoin } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { CoreWallet, PublicKeys } from './CoreWallet.js';
 import { makeDefaultTransactionHistoryCapability } from './TransactionHistory.js';
@@ -41,7 +40,6 @@ export class V1Builder {
             .withTransactionHistoryDefaults()
             .withKeysDefaults()
             .withProvingDefaults()
-            .withSubmissionDefaults()
             .withCoinSelectionDefaults();
     }
     withTransactionType() {
@@ -49,7 +47,6 @@ export class V1Builder {
             ...this.#buildState,
             provingService: undefined,
             transactingCapability: undefined,
-            submissionService: undefined,
             transactionHistoryCapability: undefined,
         });
     }
@@ -129,15 +126,6 @@ export class V1Builder {
             keysCapability,
         });
     }
-    withSubmission(submissionService) {
-        return new V1Builder({
-            ...this.#buildState,
-            submissionService,
-        });
-    }
-    withSubmissionDefaults() {
-        return this.withSubmission(makeDefaultSubmissionService);
-    }
     build(configuration) {
         const v1Context = this.#buildContextFromBuildState(configuration);
         const { networkId } = configuration;
@@ -149,7 +137,6 @@ export class V1Builder {
             transactionHistory: v1Context.transactionHistoryCapability,
             start(context) {
                 return Effect.gen(function* () {
-                    yield* Effect.addFinalizer(() => v1Context.submissionService.close());
                     const scope = yield* Scope.Scope;
                     return new RunningV1Variant(scope, context, v1Context);
                 });
@@ -167,7 +154,7 @@ export class V1Builder {
         if (!isBuildStateFull(this.#buildState)) {
             throw new Error('Not all components are configured in V1 Builder');
         }
-        const { syncCapability, syncService, transactingCapability, serializationCapability, provingService, coinSelection, coinsAndBalancesCapability, keysCapability, submissionService, transactionHistoryCapability, } = this.#buildState;
+        const { syncCapability, syncService, transactingCapability, serializationCapability, provingService, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryCapability, } = this.#buildState;
         const getContext = () => context;
         const context = {
             serializationCapability: serializationCapability(configuration, getContext),
@@ -178,7 +165,6 @@ export class V1Builder {
             keysCapability: keysCapability(configuration, getContext),
             provingService: provingService(configuration, getContext),
             coinSelection: coinSelection(configuration, getContext),
-            submissionService: submissionService(configuration, getContext),
             transactionHistoryCapability: transactionHistoryCapability(configuration, getContext),
         };
         return context;
@@ -194,7 +180,6 @@ const isBuildStateFull = (buildState) => {
         'provingService',
         'coinsAndBalancesCapability',
         'keysCapability',
-        'submissionService',
         'transactionHistoryCapability',
     ];
     return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');

package/dist/v1/index.d.ts

@@ -9,7 +9,6 @@ export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
 export * as Simulator from './Simulator.js';
-export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
 export * from './TransactionOps.js';

package/dist/v1/index.js

@@ -21,7 +21,6 @@ export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
 export * as Simulator from './Simulator.js';
-export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
 export * from './TransactionOps.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-shielded",
-  "version": "1.0.0",
+  "version": "2.0.0-rc.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -31,12 +31,13 @@
     "@midnight-ntwrk/ledger-v7": "7.0.0",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0",
     "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.1.0-rc.0",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.1.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0",
-    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.1.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-runtime": "1.0.0",
     "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0",
+    "@midnight-ntwrk/zkir-v2": "2.1.0",
     "@scure/base": "^1.1.9",
     "effect": "^3.19.14",
     "isomorphic-ws": "^5.0.0",
@@ -46,7 +47,7 @@
     "ws": "^8.18.3"
   },
   "scripts": {
-    "typecheck": "tsc -b ./tsconfig.json --noEmit",
+    "typecheck": "tsc -b ./tsconfig.json --noEmit --force",
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
     "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",

package/dist/v1/Submission.d.ts

@@ -1,31 +0,0 @@
-import { Effect } from 'effect';
-import * as ledger from '@midnight-ntwrk/ledger-v7';
-import { WalletError } from './WalletError.js';
-import { Simulator } from './Simulator.js';
-import { SubmissionEvent as SubmissionEventImported } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
-export declare const SubmissionEvent: typeof SubmissionEventImported;
-export type SubmissionEvent = SubmissionEventImported.SubmissionEvent;
-export declare namespace SubmissionEventCases {
-    type Finalized = SubmissionEventImported.Cases.Finalized;
-    type Submitted = SubmissionEventImported.Cases.Submitted;
-    type InBlock = SubmissionEventImported.Cases.InBlock;
-}
-export type SubmitTransactionMethod<TTransaction> = {
-    (transaction: TTransaction, waitForStatus: 'Submitted'): Effect.Effect<SubmissionEventCases.Submitted, WalletError>;
-    (transaction: TTransaction, waitForStatus: 'InBlock'): Effect.Effect<SubmissionEventCases.InBlock, WalletError>;
-    (transaction: TTransaction, waitForStatus: 'Finalized'): Effect.Effect<SubmissionEventCases.Finalized, WalletError>;
-    (transaction: TTransaction): Effect.Effect<SubmissionEventCases.InBlock, WalletError>;
-    (transaction: TTransaction, waitForStatus?: 'Submitted' | 'InBlock' | 'Finalized'): Effect.Effect<SubmissionEvent, WalletError>;
-};
-export interface SubmissionService<TTransaction> {
-    submitTransaction: SubmitTransactionMethod<TTransaction>;
-    close(): Effect.Effect<void>;
-}
-export type DefaultSubmissionConfiguration = {
-    relayURL: URL;
-};
-export declare const makeDefaultSubmissionService: (config: DefaultSubmissionConfiguration) => SubmissionService<ledger.FinalizedTransaction>;
-export type SimulatorSubmissionConfiguration = {
-    simulator: Simulator;
-};
-export declare const makeSimulatorSubmissionService: (waitForStatus?: "Submitted" | "InBlock" | "Finalized") => (config: SimulatorSubmissionConfiguration) => SubmissionService<ledger.ProofErasedTransaction>;

package/dist/v1/Submission.js

@@ -1,69 +0,0 @@
-// This file is part of MIDNIGHT-WALLET-SDK.
-// Copyright (C) 2025 Midnight Foundation
-// SPDX-License-Identifier: Apache-2.0
-// Licensed under the Apache License, Version 2.0 (the "License");
-// You may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Deferred, Effect, Encoding, Exit, pipe, Scope } from 'effect';
-import { WalletError } from './WalletError.js';
-import { NodeClient, PolkadotNodeClient, SubmissionEvent as SubmissionEventImported, } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
-export const SubmissionEvent = SubmissionEventImported;
-export const makeDefaultSubmissionService = (config) => {
-    const scopeAndClientDeferred = Deferred.make().pipe(Effect.runSync);
-    const makeScopeAndClient = Effect.gen(function* () {
-        const scope = yield* Scope.make();
-        const client = yield* PolkadotNodeClient.make({
-            nodeURL: config.relayURL,
-        }).pipe(Effect.provideService(Scope.Scope, scope));
-        return { scope, client };
-    });
-    void pipe(scopeAndClientDeferred, Deferred.complete(makeScopeAndClient), Effect.runPromise);
-    const submit = (transaction, waitForStatus = 'InBlock') => {
-        return pipe(NodeClient.sendMidnightTransactionAndWait(transaction.serialize(), waitForStatus), Effect.provideServiceEffect(NodeClient.NodeClient, pipe(scopeAndClientDeferred, Deferred.await, Effect.map(({ client }) => client))), Effect.mapError((err) => WalletError.submission(err)));
-    };
-    return {
-        submitTransaction: submit,
-        close() {
-            return pipe(scopeAndClientDeferred, Deferred.await, Effect.flatMap(({ scope }) => Scope.close(scope, Exit.void)), Effect.ignoreLogged);
-        },
-    };
-};
-export const makeSimulatorSubmissionService = (waitForStatus = 'InBlock') => (config) => {
-    const submit = (transaction) => {
-        const serializedTx = transaction.serialize();
-        return config.simulator.submitRegularTx(transaction).pipe(Effect.map((output) => {
-            // Let's mimic node's client behavior here
-            switch (waitForStatus) {
-                case 'Submitted':
-                    return SubmissionEvent.Submitted({
-                        tx: serializedTx,
-                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
-                    });
-                case 'InBlock':
-                    return SubmissionEvent.InBlock({
-                        tx: serializedTx,
-                        blockHash: output.blockHash,
-                        blockHeight: output.blockNumber,
-                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
-                    });
-                case 'Finalized':
-                    return SubmissionEvent.Finalized({
-                        tx: serializedTx,
-                        blockHash: output.blockHash,
-                        blockHeight: output.blockNumber,
-                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
-                    });
-            }
-        }));
-    };
-    return {
-        submitTransaction: submit,
-        close: () => Effect.void,
-    };
-};