@midnight-ntwrk/wallet-sdk-capabilities 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/pendingTransactions/pendingTransactions.js

@@ -12,16 +12,76 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Array as Arr, Either, Order, pipe, Schema } from 'effect';
-export const has = (transactions, transaction, txTrait) => {
-    return transactions.all.some((item) => txTrait.areAllTxIdsIncluded(transaction, txTrait.ids(item.tx)));
-};
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Buffer } from 'buffer';
+import { Array as Arr, Either, Option, Order, ParseResult, pipe, Schema } from 'effect';
+/** Registers one trait for every protocol version: the shape a wallet that speaks a single ledger version has. */
+export const singleTrait = (trait) => ({
+    entries: [
+        {
+            range: ProtocolVersion.makeRange(ProtocolVersion.MinSupportedVersion, ProtocolVersion.MaxSupportedVersion),
+            value: trait,
+        },
+    ],
+});
+/** The oldest registered trait: what an envelope that carries no version stamp is read with. */
+export const headTrait = (traits) => Option.fromNullable(traits.entries.at(0)).pipe(Option.map((entry) => entry.value));
+/**
+ * The trait registered for a protocol version, or the oldest trait when nothing says which version applies.
+ *
+ * @remarks
+ *   Falling back to the oldest trait is the same convention snapshot restore uses for an envelope written before versions
+ *   were recorded: the only envelopes without a stamp are ones written before stamping existed, and those necessarily
+ *   predate every version boundary since.
+ * @param traits The registered traits.
+ * @param protocolVersion The version the transaction was authored for, when one is known.
+ * @returns The trait to read with, or `Option.none()` when the version falls outside every registered range.
+ */
+export const traitForVersion = (traits, protocolVersion) => Option.match(protocolVersion, {
+    onNone: () => headTrait(traits),
+    onSome: (version) => ProtocolVersion.select(traits, version),
+});
+/** The registered trait that recognises a transaction object as its own, if any does. */
+export const recognisingTrait = (traits, tx) => Option.fromNullable(traits.entries.find((entry) => entry.value.isTx(tx))).pipe(Option.map((entry) => entry.value));
+/**
+ * The trait to read an incoming transaction with: the one that recognises it, or the oldest as a last resort.
+ *
+ * @param traits The registered traits.
+ * @param tx The transaction to place.
+ * @returns The trait that owns `tx`, the oldest trait when none claims it, or `Option.none()` when nothing is
+ *   registered at all.
+ */
+export const traitForTx = (traits, tx) => Option.orElse(recognisingTrait(traits, tx), () => headTrait(traits));
+const traitOfItem = (traits, item) => traitForVersion(traits, item.protocolVersion);
+/** Two versions are in the same epoch when the registry answers them with the same trait. */
+const sameEpoch = (a, b) => Option.getEquivalence((left, right) => left === right)(a, b);
+const idsOf = (traits, tx) => traitForTx(traits, tx).pipe(Option.map((trait) => trait.ids(tx)), Option.getOrElse(() => []));
+/** A stored item's identifiers, read with the trait registered for the version it was stamped with. */
+const idsOfItem = (traits, item) => traitOfItem(traits, item).pipe(Option.map((trait) => trait.ids(item.tx)), Option.getOrElse(() => []));
+/** Whether a stored item is covered by the identifiers of an incoming transaction, each read with its own trait. */
+const isCoveredBy = (traits, item, txIds) => traitOfItem(traits, item).pipe(Option.map((trait) => trait.areAllTxIdsIncluded(item.tx, txIds)), Option.getOrElse(() => false));
+export const has = (transactions, transaction, traits) => traitForTx(traits, transaction).pipe(Option.map((trait) => transactions.all.some((item) => trait.areAllTxIdsIncluded(transaction, idsOfItem(traits, item)))), Option.getOrElse(() => false));
 export const all = (transactions) => {
     return transactions.all.map((item) => item.tx);
 };
+const resultOf = (item) => 'result' in item ? Option.fromNullable(item.result) : Option.none();
 export const allFailed = (transactions) => {
     return transactions.all.filter((item) => 'result' in item && (item.result?.status === 'FAILURE' || item.result?.status === 'PARTIAL_SUCCESS'));
 };
+/** Transactions a protocol upgrade stranded: they were authored for a version the chain has moved past. */
+export const allOrphaned = (transactions) => {
+    return transactions.all.filter((item) => 'result' in item && item.result?.status === 'ORPHANED_BY_FORK');
+};
+/**
+ * Everything the wallet has given up on, in the order it was added: reported failures and orphaned transactions alike.
+ * Both need the same treatment — unbook the coins, record the rejection — so both belong on one list.
+ */
+export const allRejected = (transactions) => {
+    return transactions.all.filter((item) => 'result' in item &&
+        (item.result?.status === 'FAILURE' ||
+            item.result?.status === 'PARTIAL_SUCCESS' ||
+            item.result?.status === 'ORPHANED_BY_FORK'));
+};
 export const allPending = (state) => {
     return state.all.filter((item) => !('result' in item) || item.result === undefined);
 };
@@ -30,47 +90,104 @@ export const empty = () => {
         all: [],
     };
 };
-export const addPendingTransaction = (state, tx, now, txTrait) => {
-    const [rest, foundMatching] = pipe(state.all, Arr.partition((item) => txTrait.isOneIncludedInOther(tx, item.tx)));
-    const allMatchingTransactions = Arr.append(foundMatching, { tx, creationTime: now });
-    const theBiggestMatchingTx = Arr.max(allMatchingTransactions, pipe(Order.number, Order.mapInput((input) => txTrait.ids(input).length), Order.mapInput((input) => input.tx)));
+/**
+ * Records a transaction as pending, stamped with the protocol version it was authored for.
+ *
+ * @param state The pending transactions.
+ * @param tx The transaction to record.
+ * @param now The time it was authored.
+ * @param traits The traits pending transactions are read with.
+ * @param protocolVersion The version the chain had reached when it was authored, when the wallet knew one.
+ * @returns The pending transactions including `tx`, with any superseded entry from the same version epoch replaced.
+ */
+export const addPendingTransaction = (state, tx, now, traits, protocolVersion) => {
+    const trait = traitForVersion(traits, protocolVersion);
+    const item = { tx, creationTime: now, protocolVersion };
+    // Whether one transaction supersedes another is a question only a single ledger version can answer — across a
+    // version boundary the two were authored against different rules, so they are simply different transactions.
+    const [rest, foundMatching] = pipe(state.all, Arr.partition((existing) => sameEpoch(traitOfItem(traits, existing), trait) &&
+        Option.match(trait, {
+            onNone: () => false,
+            onSome: (found) => found.isOneIncludedInOther(tx, existing.tx),
+        })));
+    const idCount = (candidate) => Option.match(trait, { onNone: () => 0, onSome: (found) => found.ids(candidate.tx).length });
+    const theBiggestMatchingTx = Arr.max(Arr.append(foundMatching, item), pipe(Order.number, Order.mapInput(idCount)));
     return {
         ...state,
         all: Arr.append(rest, theBiggestMatchingTx),
     };
 };
-export const clear = (state, tx, txTrait) => {
+export const clear = (state, tx, traits) => {
+    const txIds = idsOf(traits, tx);
     return {
         ...state,
-        all: Arr.filter(state.all, (item) => !txTrait.areAllTxIdsIncluded(item.tx, txTrait.ids(tx))),
+        all: Arr.filter(state.all, (item) => !isCoveredBy(traits, item, txIds)),
     };
 };
-export const saveResult = (state, tx, result, txTrait) => {
+export const saveResult = (state, tx, result, traits) => {
+    const txIds = idsOf(traits, tx);
     return {
         ...state,
-        all: Arr.map(state.all, (item) => {
-            return txTrait.areAllTxIdsIncluded(item.tx, txTrait.ids(tx)) ? { ...item, result } : item;
-        }),
+        all: Arr.map(state.all, (item) => (isCoveredBy(traits, item, txIds) ? { ...item, result } : item)),
     };
 };
-export const SerializedSchema = (txTrait) => {
-    const TxSchema = Schema.declare((tx) => txTrait.isTx(tx));
-    const TxFromHex = Schema.transform(Schema.Uint8ArrayFromHex, TxSchema, {
-        encode: (tx) => txTrait.serialize(tx),
-        decode: (bytes) => txTrait.deserialize(bytes),
-    });
-    const TxItemSchema = Schema.Struct({
-        tx: TxFromHex,
+/**
+ * Gives up on every unresolved transaction whose version epoch the chain has moved past.
+ *
+ * @remarks
+ *   The epochs are the registry's own ranges, so "the chain has moved past" means exactly "a different trait answers for
+ *   the chain now than answered for this transaction". A transaction authored under the previous protocol version can
+ *   never be included afterwards, so waiting for its TTL only delays the inevitable and holds its coins hostage
+ *   meanwhile.
+ * @param state The pending transactions.
+ * @param traits The traits pending transactions are read with, whose ranges define the epochs.
+ * @param chainNow The protocol version the wallets have reached.
+ * @returns The pending transactions with the stranded ones given an {@link OrphanedByForkResult}.
+ */
+export const orphanBeyond = (state, traits, chainNow) => ({
+    ...state,
+    all: Arr.map(state.all, (item) => Option.isSome(resultOf(item))
+        ? item
+        : Option.match(item.protocolVersion, {
+            onNone: () => item,
+            onSome: (authoredFor) => hasEpochEnded(traits, authoredFor, chainNow)
+                ? { ...item, result: { status: 'ORPHANED_BY_FORK', authoredFor, chainNow } }
+                : item,
+        })),
+});
+const hasEpochEnded = (traits, authoredFor, chainNow) => ProtocolVersion.selectEntry(traits, authoredFor).pipe(Option.map((entry) => chainNow >= entry.range[1]), Option.getOrElse(() => false));
+const WireItemSchema = Schema.Struct({
+    tx: Schema.String,
+    creationTime: Schema.DateTimeUtc,
+    // Additive: envelopes written before transactions were stamped simply omit it, and decode to `Option.none()`.
+    protocolVersion: Schema.optionalWith(ProtocolVersion.ProtocolVersionSchema, { as: 'Option' }),
+});
+const PendingItemSchema = (traits) => {
+    const TxSchema = Schema.declare((tx) => Option.isSome(recognisingTrait(traits, tx)));
+    const DomainSchema = Schema.typeSchema(Schema.Struct({
+        tx: TxSchema,
         creationTime: Schema.DateTimeUtc,
-    });
-    return Schema.Struct({
-        version: Schema.Literal('v1'),
-        transactions: Schema.Array(TxItemSchema),
-    });
+        protocolVersion: Schema.OptionFromSelf(ProtocolVersion.ProtocolVersionSchema),
+    }));
+    return Schema.asSchema(Schema.transformOrFail(WireItemSchema, DomainSchema, {
+        strict: true,
+        decode: (wire, _options, ast) => pipe(traitForVersion(traits, wire.protocolVersion), Either.fromOption(() => new ParseResult.Type(ast, wire, `No transaction trait is registered for protocol version ${Option.getOrElse(wire.protocolVersion, () => 'unknown')}.`)), Either.flatMap((trait) => Either.try({
+            try: () => trait.deserialize(Buffer.from(wire.tx, 'hex')),
+            catch: (cause) => new ParseResult.Type(ast, wire, `Could not read the pending transaction: ${String(cause)}`),
+        })), Either.map((tx) => ({ tx, creationTime: wire.creationTime, protocolVersion: wire.protocolVersion }))),
+        encode: (item, _options, ast) => pipe(traitForTx(traits, item.tx), Either.fromOption(() => new ParseResult.Type(ast, item, 'No transaction trait is registered.')), Either.flatMap((trait) => Either.try({
+            try: () => Buffer.from(trait.serialize(item.tx)).toString('hex'),
+            catch: (cause) => new ParseResult.Type(ast, item, `Could not write the pending transaction: ${String(cause)}`),
+        })), Either.map((tx) => ({ tx, creationTime: item.creationTime, protocolVersion: item.protocolVersion }))),
+    }));
 };
-export const serialize = (state, txTrait) => pipe(state, toSerialized, Schema.encodeSync(SerializedSchema(txTrait)), JSON.stringify);
-export const deserialize = (serialized, txTrait) => {
-    return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SerializedSchema(txTrait))), Either.map((data) => fromSerialized(data)));
+export const SerializedSchema = (traits) => Schema.Struct({
+    version: Schema.Literal('v1'),
+    transactions: Schema.Array(PendingItemSchema(traits)),
+});
+export const serialize = (state, traits) => pipe(state, toSerialized, Schema.encodeSync(SerializedSchema(traits)), JSON.stringify);
+export const deserialize = (serialized, traits) => {
+    return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SerializedSchema(traits))), Either.map((data) => fromSerialized(data)));
 };
 export const toSerialized = (pendingTransactions) => {
     return {

package/dist/pendingTransactions/pendingTransactionsService.d.ts

@@ -1,13 +1,26 @@
-import { type Clock, Effect, type ParseResult, Scope, Stream } from 'effect';
+import { type Clock, Effect, Option, type ParseResult, Scope, Stream } from 'effect';
 import * as PendingTransactions from './pendingTransactions.js';
+import { type ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import type * as rx from 'rxjs';
 import { type QueryClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 export type PendingTransactionsService<TTransaction> = {
     start: () => Promise<void>;
     stop: () => Promise<void>;
     state: () => rx.Observable<PendingTransactions.PendingTransactions<TTransaction>>;
-    addPendingTransaction: (tx: TTransaction) => Promise<void>;
+    /**
+     * Records a transaction as pending, stamped with the protocol version the chain had reached when it was authored.
+     *
+     * @param tx The transaction.
+     * @param protocolVersion The observed chain version, or `Option.none()` when no wallet has reported one yet.
+     */
+    addPendingTransaction: (tx: TTransaction, protocolVersion: Option.Option<ProtocolVersion.ProtocolVersion>) => Promise<void>;
     clear: (tx: TTransaction) => Promise<void>;
+    /**
+     * Gives up on every pending transaction whose protocol version epoch the chain has moved past.
+     *
+     * @param chainNow The protocol version the wallets have reached.
+     */
+    orphanBeyond: (chainNow: ProtocolVersion.ProtocolVersion) => Promise<void>;
 };
 export type IndexerClientConnection = {
     indexerHttpUrl: string;
@@ -17,18 +30,19 @@ export type DefaultPendingTransactionsServiceConfiguration = {
     indexerClientConnection: IndexerClientConnection;
 };
 export type InitParams<TTransaction> = {
-    txTrait: PendingTransactions.TransactionTrait<TTransaction>;
+    txTraits: PendingTransactions.VersionedTransactionTrait<TTransaction>;
     initialState?: PendingTransactions.PendingTransactions<TTransaction>;
     configuration: DefaultPendingTransactionsServiceConfiguration;
 };
 export declare class PendingTransactionsServiceImpl<TTransaction> implements PendingTransactionsService<TTransaction> {
     #private;
     static init<TTransaction>(initParams: InitParams<TTransaction>): Promise<PendingTransactionsServiceImpl<TTransaction>>;
-    static restore<TTransaction>(data: string, txTrait: PendingTransactions.TransactionTrait<TTransaction>, configuration: DefaultPendingTransactionsServiceConfiguration): Promise<PendingTransactionsServiceImpl<TTransaction>>;
+    static restore<TTransaction>(data: string, txTraits: PendingTransactions.VersionedTransactionTrait<TTransaction>, configuration: DefaultPendingTransactionsServiceConfiguration): Promise<PendingTransactionsServiceImpl<TTransaction>>;
     private static initEffect;
     constructor(effectService: PendingTransactionsServiceEffect<TTransaction>, scope: Scope.CloseableScope, configuration: DefaultPendingTransactionsServiceConfiguration);
-    addPendingTransaction(tx: TTransaction): Promise<void>;
+    addPendingTransaction(tx: TTransaction, protocolVersion: Option.Option<ProtocolVersion.ProtocolVersion>): Promise<void>;
     clear(tx: TTransaction): Promise<void>;
+    orphanBeyond(chainNow: ProtocolVersion.ProtocolVersion): Promise<void>;
     start(): Promise<void>;
     state(): rx.Observable<PendingTransactions.PendingTransactions<TTransaction>>;
     stop(): Promise<void>;
@@ -36,17 +50,19 @@ export declare class PendingTransactionsServiceImpl<TTransaction> implements Pen
 export type PendingTransactionsServiceEffect<TTransaction> = {
     startPolling: (ticks: Stream.Stream<unknown>) => Effect.Effect<void, Error, QueryClient | Scope.Scope | Clock.Clock>;
     state: () => Stream.Stream<PendingTransactions.PendingTransactions<TTransaction>>;
-    addPendingTransaction: (tx: TTransaction) => Effect.Effect<void, never, never>;
+    addPendingTransaction: (tx: TTransaction, protocolVersion: Option.Option<ProtocolVersion.ProtocolVersion>) => Effect.Effect<void, never, never>;
     clear: (tx: TTransaction) => Effect.Effect<void, never, never>;
+    orphanBeyond: (chainNow: ProtocolVersion.ProtocolVersion) => Effect.Effect<void, never, never>;
 };
 export declare class PendingTransactionsServiceEffectImpl<TTransaction> implements PendingTransactionsServiceEffect<TTransaction> {
     #private;
-    static restore<TTransaction>(data: string, txTrait: PendingTransactions.TransactionTrait<TTransaction>): Effect.Effect<PendingTransactionsServiceEffectImpl<TTransaction>, ParseResult.ParseError>;
-    constructor(txTrait: PendingTransactions.TransactionTrait<TTransaction>, initialState?: PendingTransactions.PendingTransactions<TTransaction>);
+    static restore<TTransaction>(data: string, txTraits: PendingTransactions.VersionedTransactionTrait<TTransaction>): Effect.Effect<PendingTransactionsServiceEffectImpl<TTransaction>, ParseResult.ParseError>;
+    constructor(txTraits: PendingTransactions.VersionedTransactionTrait<TTransaction>, initialState?: PendingTransactions.PendingTransactions<TTransaction>);
     state(): Stream.Stream<PendingTransactions.PendingTransactions<TTransaction>>;
     startPolling(ticks: Stream.Stream<unknown>): Effect.Effect<void, Error, QueryClient | Scope.Scope>;
-    addPendingTransaction(tx: TTransaction): Effect.Effect<void>;
+    addPendingTransaction(tx: TTransaction, protocolVersion: Option.Option<ProtocolVersion.ProtocolVersion>): Effect.Effect<void>;
     clear(tx: TTransaction): Effect.Effect<void>;
+    orphanBeyond(chainNow: ProtocolVersion.ProtocolVersion): Effect.Effect<void>;
     private saveResult;
     private queryForStatus;
 }

package/dist/pendingTransactions/pendingTransactionsService.js

@@ -21,12 +21,12 @@ export class PendingTransactionsServiceImpl {
     static init(initParams) {
         return PendingTransactionsServiceImpl.initEffect(initParams).pipe(Effect.runPromise);
     }
-    static restore(data, txTrait, configuration) {
-        return pipe(PendingTransactions.deserialize(data, txTrait), EitherOps.toEffect, Effect.andThen((state) => PendingTransactionsServiceImpl.initEffect({ txTrait, initialState: state, configuration })), Effect.runPromise);
+    static restore(data, txTraits, configuration) {
+        return pipe(PendingTransactions.deserialize(data, txTraits), EitherOps.toEffect, Effect.andThen((state) => PendingTransactionsServiceImpl.initEffect({ txTraits, initialState: state, configuration })), Effect.runPromise);
     }
     static initEffect(initParams) {
         return Effect.gen(function* () {
-            const service = new PendingTransactionsServiceEffectImpl(initParams.txTrait, initParams.initialState);
+            const service = new PendingTransactionsServiceEffectImpl(initParams.txTraits, initParams.initialState);
             const scope = yield* Scope.make();
             return new PendingTransactionsServiceImpl(service, scope, initParams.configuration);
         });
@@ -39,12 +39,15 @@ export class PendingTransactionsServiceImpl {
         this.#scope = scope;
         this.#configuration = configuration;
     }
-    addPendingTransaction(tx) {
-        return this.#effectService.addPendingTransaction(tx).pipe(Effect.runPromise);
+    addPendingTransaction(tx, protocolVersion) {
+        return this.#effectService.addPendingTransaction(tx, protocolVersion).pipe(Effect.runPromise);
     }
     clear(tx) {
         return this.#effectService.clear(tx).pipe(Effect.runPromise);
     }
+    orphanBeyond(chainNow) {
+        return this.#effectService.orphanBeyond(chainNow).pipe(Effect.runPromise);
+    }
     start() {
         return this.#effectService.startPolling(Stream.tick(Duration.seconds(1))).pipe(Effect.provide(HttpQueryClient.layer({
             url: this.#configuration.indexerClientConnection.indexerHttpUrl,
@@ -59,12 +62,12 @@ export class PendingTransactionsServiceImpl {
 }
 export class PendingTransactionsServiceEffectImpl {
     #state;
-    #txTrait;
-    static restore(data, txTrait) {
-        return pipe(data, (data) => PendingTransactions.deserialize(data, txTrait), EitherOps.toEffect, Effect.map((state) => new PendingTransactionsServiceEffectImpl(txTrait, state)));
+    #txTraits;
+    static restore(data, txTraits) {
+        return pipe(data, (data) => PendingTransactions.deserialize(data, txTraits), EitherOps.toEffect, Effect.map((state) => new PendingTransactionsServiceEffectImpl(txTraits, state)));
     }
-    constructor(txTrait, initialState) {
-        this.#txTrait = txTrait;
+    constructor(txTraits, initialState) {
+        this.#txTraits = txTraits;
         this.#state = SubscriptionRef.make(initialState ?? PendingTransactions.empty()).pipe(Effect.runSync); // Should not be here, but otherwise initialization would be too involved
     }
     state() {
@@ -74,7 +77,10 @@ export class PendingTransactionsServiceEffectImpl {
         return ticks.pipe(Stream.mapEffect(() => SubscriptionRef.get(this.#state)), Stream.mapConcat(PendingTransactions.allPending), Stream.mapConcatEffect((item) => {
             return Effect.gen(this, function* () {
                 const now = yield* DateTime.now;
-                const result = yield* this.queryForStatus(item.tx);
+                const trait = PendingTransactions.traitForVersion(this.#txTraits, item.protocolVersion);
+                if (Option.isNone(trait))
+                    return [];
+                const result = yield* this.queryForStatus(item.tx, trait.value);
                 return Option.match(result, {
                     onSome: (status) => [{ ...item, result: status }],
                     onNone: () => {
@@ -82,7 +88,7 @@ export class PendingTransactionsServiceEffectImpl {
                             status: 'FAILURE',
                             segments: [],
                         };
-                        return this.#txTrait.hasTTLExpired(item.tx, item.creationTime, now)
+                        return trait.value.hasTTLExpired(item.tx, item.creationTime, now)
                             ? [{ ...item, result: failedResult }]
                             : [];
                     },
@@ -94,14 +100,19 @@ export class PendingTransactionsServiceEffectImpl {
             return this.saveResult(item.tx, item.result);
         }));
     }
-    addPendingTransaction(tx) {
+    addPendingTransaction(tx, protocolVersion) {
         return SubscriptionRef.updateEffect(this.#state, (state) => {
-            return DateTime.now.pipe(Effect.andThen((now) => PendingTransactions.addPendingTransaction(state, tx, now, this.#txTrait)));
+            return DateTime.now.pipe(Effect.andThen((now) => PendingTransactions.addPendingTransaction(state, tx, now, this.#txTraits, protocolVersion)));
         });
     }
     clear(tx) {
         return SubscriptionRef.update(this.#state, (state) => {
-            return PendingTransactions.clear(state, tx, this.#txTrait);
+            return PendingTransactions.clear(state, tx, this.#txTraits);
+        });
+    }
+    orphanBeyond(chainNow) {
+        return SubscriptionRef.update(this.#state, (state) => {
+            return PendingTransactions.orphanBeyond(state, this.#txTraits, chainNow);
         });
     }
     saveResult(tx, result) {
@@ -110,20 +121,21 @@ export class PendingTransactionsServiceEffectImpl {
                 return this.clear(tx);
             case 'FAILURE':
             case 'PARTIAL_SUCCESS':
+            case 'ORPHANED_BY_FORK':
                 return SubscriptionRef.update(this.#state, (state) => {
-                    return PendingTransactions.saveResult(state, tx, result, this.#txTrait);
+                    return PendingTransactions.saveResult(state, tx, result, this.#txTraits);
                 });
         }
     }
-    queryForStatus(tx) {
-        return Effect.gen(this, function* () {
+    queryForStatus(tx, txTrait) {
+        return Effect.gen(function* () {
             const statusQuery = yield* TransactionStatus;
-            const result = yield* statusQuery({ transactionId: this.#txTrait.firstId(tx) }).pipe(Effect.catchAll((error) => {
+            const result = yield* statusQuery({ transactionId: txTrait.firstId(tx) }).pipe(Effect.catchAll((error) => {
                 const fallback = { transactions: [] };
                 return pipe(Effect.logWarning(error, 'Observed error in PendingTransactionsService, retrying'), Effect.as(fallback));
             }));
             return pipe(result.transactions, Iterable.filterMap((res) => {
-                if (res.__typename == 'SystemTransaction') {
+                if (res.__typename !== 'RegularTransaction') {
                     return Option.none();
                 }
                 if (res.transactionResult.status != 'SUCCESS' &&
@@ -131,7 +143,7 @@ export class PendingTransactionsServiceEffectImpl {
                     res.transactionResult.status != 'PARTIAL_SUCCESS') {
                     return Option.none();
                 }
-                if (this.#txTrait.areAllTxIdsIncluded(tx, res.identifiers)) {
+                if (txTrait.areAllTxIdsIncluded(tx, res.identifiers)) {
                     return Option.some({
                         status: res.transactionResult.status,
                         segments: res.transactionResult.segments ?? [],

package/dist/proving/index.d.ts

@@ -1 +1,3 @@
+export * from './v8ProvingService.js';
 export * from './provingService.js';
+export * from './versionedProving.js';

package/dist/proving/index.js

@@ -12,4 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export * from './v8ProvingService.js';
 export * from './provingService.js';
+export * from './versionedProving.js';