@midnight-ntwrk/wallet-sdk-facade 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/transaction.d.ts

@@ -1,6 +1,5 @@
 import { type PendingTransactions } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import * as ledger from '@midnightntwrk/ledger-v9';
-import { type AnyTransaction } from '@midnight-ntwrk/wallet-sdk-dust-wallet/v1';
+import { ProtocolVersion, type FinalizedTx } from '@midnight-ntwrk/wallet-sdk-abstractions';
 /**
  * The key under which a transaction's history entry is stored.
  *
@@ -17,5 +16,18 @@ import { type AnyTransaction } from '@midnight-ntwrk/wallet-sdk-dust-wallet/v1';
  * (Serialization differs across lifecycle states, so this is only stable for a fixed tx — which is exactly the
  * submit→revert flow.)
  */
-export declare const txHistoryHash: (tx: AnyTransaction) => string;
-export declare const finalizedTransactionTrait: PendingTransactions.TransactionTrait<ledger.FinalizedTransaction>;
+export declare const txHistoryHash: (tx: {
+    transactionHash: () => unknown;
+    serialize: () => Uint8Array;
+}) => string;
+/**
+ * The traits pending transactions are read with, split at the protocol version this chain forks at.
+ *
+ * @remarks
+ *   One trait per ledger version, each reading the handle it is registered for and refusing the other's. That is what
+ *   lets a transaction authored before the v9 fork be recognised as stranded once the wallets cross — its bytes can
+ *   never be included afterwards — instead of waiting out a TTL for an inclusion that can never happen.
+ * @param forkVersion The protocol version this chain forks at.
+ * @returns The registry the pending transaction service reads with.
+ */
+export declare const finalizedTransactionTraits: (forkVersion: ProtocolVersion.ProtocolVersion) => PendingTransactions.VersionedTransactionTrait<FinalizedTx>;

package/dist/transaction.js

@@ -12,8 +12,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Array as Arr, DateTime, Duration, HashSet, Option, Order, pipe } from 'effect';
-import * as ledger from '@midnightntwrk/ledger-v9';
+import { Array as Arr, DateTime, Duration, Either, HashSet, Option, Order, pipe } from 'effect';
+import { ProtocolVersion, WalletTransaction, } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import * as ledgerV8 from '@midnight-ntwrk/ledger-v8';
+import * as ledgerV9 from '@midnightntwrk/ledger-v9';
 /**
  * The key under which a transaction's history entry is stored.
  *
@@ -32,26 +34,26 @@ import * as ledger from '@midnightntwrk/ledger-v9';
  */
 export const txHistoryHash = (tx) => {
     try {
-        return tx.transactionHash().toString();
+        return String(tx.transactionHash());
     }
     catch {
         return Buffer.from(tx.serialize()).toString('hex');
     }
 };
-export const finalizedTransactionTrait = {
+const v9FinalizedTransactionTrait = {
     areAllTxIdsIncluded(tx, txIds) {
         const txIdsSet = HashSet.fromIterable(tx.identifiers());
         const expectedIdSet = HashSet.fromIterable(txIds);
         return HashSet.isSubset(txIdsSet, expectedIdSet);
     },
     deserialize(serialized) {
-        return ledger.Transaction.deserialize('signature', 'proof', 'binding', serialized);
+        return ledgerV9.Transaction.deserialize('signature', 'proof', 'binding', serialized);
     },
     firstId(tx) {
         return tx.identifiers()[0];
     },
     hasTTLExpired(tx, creationTime, now) {
-        const defaultShieldedGracePeriod = ledger.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
+        const defaultShieldedGracePeriod = ledgerV9.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
         const intentTTLs = pipe(tx.intents?.values().toArray() ?? [], Arr.map((i) => i.ttl), Arr.filterMap(DateTime.make));
         const hasDustPayments = pipe(tx.intents?.values().toArray() ?? [], Arr.flatMap((i) => i.dustActions?.spends ?? []), Arr.isNonEmptyArray);
         const hasShieldedOffers = tx.guaranteedOffer != null || (tx.fallibleOffer?.size ?? 0) == 0;
@@ -76,9 +78,115 @@ export const finalizedTransactionTrait = {
         return HashSet.size(intersection) == smallerSize;
     },
     isTx(tx) {
-        return tx instanceof ledger.Transaction;
+        return tx instanceof ledgerV9.Transaction;
     },
     serialize(tx) {
         return tx.serialize();
     },
 };
+/**
+ * The ledger-v8's reading of a pending transaction.
+ *
+ * @remarks
+ *   Structurally the same as ledger-v9's — identifiers, a TTL, bytes — against a different ledger version's classes. It
+ *   is the classes that make this a separate trait: `instanceof` distinguishes them, each deserializer refuses the
+ *   other's bytes, and a grace period is read off that version's own initial parameters.
+ */
+const v8FinalizedTransactionTrait = {
+    areAllTxIdsIncluded(tx, txIds) {
+        return HashSet.isSubset(HashSet.fromIterable(tx.identifiers()), HashSet.fromIterable(txIds));
+    },
+    deserialize(serialized) {
+        return ledgerV8.Transaction.deserialize('signature', 'proof', 'binding', serialized);
+    },
+    firstId(tx) {
+        return tx.identifiers()[0];
+    },
+    hasTTLExpired(tx, creationTime, now) {
+        const defaultShieldedGracePeriod = ledgerV8.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
+        const intentTTLs = pipe(tx.intents?.values().toArray() ?? [], Arr.map((i) => i.ttl), Arr.filterMap(DateTime.make));
+        const hasDustPayments = pipe(tx.intents?.values().toArray() ?? [], Arr.flatMap((i) => i.dustActions?.spends ?? []), Arr.isNonEmptyArray);
+        const hasShieldedOffers = tx.guaranteedOffer != null || (tx.fallibleOffer?.size ?? 0) == 0;
+        const maybeShieldedTTL = hasDustPayments || hasShieldedOffers
+            ? pipe(creationTime, DateTime.addDuration(Duration.seconds(Number(defaultShieldedGracePeriod))), Arr.of)
+            : Arr.empty();
+        return pipe(intentTTLs, Arr.appendAll(maybeShieldedTTL), (arr) => Arr.isNonEmptyReadonlyArray(arr)
+            ? Option.some(Arr.min(arr, Order.mapInput(Order.Date, DateTime.toDate)))
+            : Option.none(), Option.match({
+            onNone: () => false,
+            onSome: (finalTTL) => DateTime.distance(finalTTL, now) > 0,
+        }));
+    },
+    ids(tx) {
+        return tx.identifiers();
+    },
+    isOneIncludedInOther(tx, otherTx) {
+        const txIds = HashSet.fromIterable(tx.identifiers());
+        const otherTxIds = HashSet.fromIterable(otherTx.identifiers());
+        const smallerSize = Order.min(Order.number)(HashSet.size(txIds), HashSet.size(otherTxIds));
+        return HashSet.size(HashSet.intersection(txIds, otherTxIds)) == smallerSize;
+    },
+    isTx(tx) {
+        return tx instanceof ledgerV8.Transaction;
+    },
+    serialize(tx) {
+        return tx.serialize();
+    },
+};
+/**
+ * Lifts one ledger version's trait onto the handle the facade actually carries.
+ *
+ * @remarks
+ *   The router has already chosen this trait by the version stamped on the handle, so unwrapping at the same epoch is a
+ *   restatement of the choice rather than a second one — but it is where a handle that does not belong is refused
+ *   rather than handed to a reader that would misread it. A handle it cannot read is reported as not being its
+ *   transaction at all, which is precisely what `isTx` is for.
+ * @param trait The ledger version's own reading of a transaction.
+ * @param epoch The range of protocol versions that ledger version answers for.
+ * @returns The same reading, in terms of handles.
+ */
+const overHandles = (trait, epoch) => {
+    const [stamp] = epoch;
+    const carried = (handle) => Either.getOrThrow(WalletTransaction.unwrapWithin(handle, epoch));
+    return {
+        ids: (tx) => trait.ids(carried(tx)),
+        firstId: (tx) => trait.firstId(carried(tx)),
+        areAllTxIdsIncluded: (tx, txIds) => trait.areAllTxIdsIncluded(carried(tx), txIds),
+        isOneIncludedInOther: (tx, otherTx) => trait.isOneIncludedInOther(carried(tx), carried(otherTx)),
+        hasTTLExpired: (tx, creationTime, now) => trait.hasTTLExpired(carried(tx), creationTime, now),
+        serialize: (tx) => trait.serialize(carried(tx)),
+        deserialize: (serialized) => WalletTransaction.adopt('Finalized', trait.deserialize(serialized), stamp),
+        isTx: (tx) => WalletTransaction.is(tx) &&
+            Either.match(WalletTransaction.unwrapWithin(tx, epoch), {
+                onLeft: () => false,
+                onRight: (carried) => trait.isTx(carried),
+            }),
+    };
+};
+/**
+ * The traits pending transactions are read with, split at the protocol version this chain forks at.
+ *
+ * @remarks
+ *   One trait per ledger version, each reading the handle it is registered for and refusing the other's. That is what
+ *   lets a transaction authored before the v9 fork be recognised as stranded once the wallets cross — its bytes can
+ *   never be included afterwards — instead of waiting out a TTL for an inclusion that can never happen.
+ * @param forkVersion The protocol version this chain forks at.
+ * @returns The registry the pending transaction service reads with.
+ */
+export const finalizedTransactionTraits = (forkVersion) => Either.getOrThrow(ProtocolVersion.makeRegistryFromActivations(forkVersion > ProtocolVersion.MinSupportedVersion
+    ? [
+        {
+            sinceVersion: ProtocolVersion.MinSupportedVersion,
+            value: overHandles(v8FinalizedTransactionTrait, ProtocolVersion.epochOf(ProtocolVersion.MinSupportedVersion, forkVersion)),
+        },
+        {
+            sinceVersion: forkVersion,
+            value: overHandles(v9FinalizedTransactionTrait, ProtocolVersion.epochOf(forkVersion, forkVersion)),
+        },
+    ]
+    : [
+        {
+            sinceVersion: ProtocolVersion.MinSupportedVersion,
+            value: overHandles(v9FinalizedTransactionTrait, ProtocolVersion.epochOf(ProtocolVersion.MinSupportedVersion, ProtocolVersion.MinSupportedVersion)),
+        },
+    ]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.3",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -26,20 +26,20 @@
     }
   },
   "dependencies": {
-    "@midnightntwrk/ledger-v9": "1.0.0-rc.3",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "3.0.0-beta.0",
-    "@midnight-ntwrk/wallet-sdk-address-format": "4.0.0-beta.2",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "4.0.0-beta.2",
-    "@midnight-ntwrk/wallet-sdk-dust-wallet": "5.0.0-beta.2",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.3.0-beta.1",
-    "@midnight-ntwrk/wallet-sdk-shielded": "4.0.0-beta.2",
-    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "4.0.0-beta.2",
+    "@midnightntwrk/ledger-v9": "1.0.0-rc.4",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "3.0.0-beta.1",
+    "@midnight-ntwrk/wallet-sdk-address-format": "4.0.0-beta.3",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "4.0.0-beta.3",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "5.0.0-beta.3",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "2.0.0-beta.2",
+    "@midnight-ntwrk/wallet-sdk-shielded": "4.0.0-beta.3",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "4.0.0-beta.3",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@midnight-ntwrk/wallet-sdk-hd": "^3.1.0-beta.1",
-    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.0"
+    "@midnight-ntwrk/wallet-sdk-hd": "^3.1.0-beta.2",
+    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.2-beta.0"
   },
   "scripts": {
     "typecheck": "tsc -b ./tsconfig.json --noEmit --force",