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

package/README.md

@@ -71,7 +71,7 @@ const configuration = {
   provers: {
     // Below `forks.v9`: a proof server built against ledger-v8.
     v8: { kind: 'server', url: new URL('http://localhost:6301') },
-    // From `forks.v9`: proving in this process, with the published circuits.
+    // From `forks.v9`: proving in this process, with ledger-v9's published key material.
     v9: { kind: 'wasm' },
   },
 };
@@ -84,8 +84,9 @@ below the boundary the wallet never authors for; a transaction stamped there the
 One shorthand remains: `provingServerUrl: url` is one proof server under every key, read only when `provers` is absent.
 The SDK drives it with each ledger version on its own side of `forks.v9`, so the same URL frames its requests correctly
 on both. A proof server, though, is built against one ledger version: no published image serves both, so a chain with
-history below the boundary wants `provers` with a server per side. The in-process prover works on bytes and does serve
-both, under both keys.
+history below the boundary wants `provers` with a server per side. The in-process prover serves both: under each key it
+proves with that ledger version's own key material (ledger-v8's circuits are generation 9, ledger-v9's generation 10),
+read from `https://srs.midnight.network/` and checked against the hashes the ledger release declares.
 
 ### Observing Combined State
 

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import type { DefaultUnshieldedConfiguration, SignSegment, UnshieldedWalletAPI }
 import { type UnshieldedWalletState } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 import { Clock } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { type DateTime, Option, Schema } from 'effect';
-import { type AnyTx, type FinalizedTx, ProtocolVersion, TransactionHistoryStorage, type UnboundTx, type UnprovenTx } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type AnyTx, type FinalizedTx, ProtocolVersion, TransactionHistoryStorage, type UnboundTx, type UnprovenTx, WalletTransaction } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import * as ledgerV8 from '@midnight-ntwrk/ledger-v8';
 import { type WalletSeeds } from '@midnight-ntwrk/wallet-sdk-hd';
 import { type Observable } from 'rxjs';
@@ -589,6 +589,37 @@ export declare class WalletFacade {
     private seal;
     /** The ledger primitives the facade signs with on its current side of the boundary. */
     private authoring;
+    /**
+     * Reads a transaction from bytes that name no protocol version, at the version the facade is acting at.
+     *
+     * @remarks
+     *   For bytes that reach the wallet from outside the SDK — a dApp connector's serialized transaction above all, whose
+     *   contract carries no version alongside them. The bytes cannot say which ledger version wrote them, so this answers
+     *   with the only version the facade could act at anyway, and reads them with that version's ledger. Bytes the other
+     *   ledger version wrote are refused here rather than misread, because the markers a stage names are part of what the
+     *   ledger checks as it reads.
+     *
+     *   The version is the facade's rather than the caller's, which is the point: a caller that reads
+     *   {@link FacadeState.activeProtocolVersion} and seals a handle itself is answering the same question a moment
+     *   earlier, with a crossing able to land in between. It is still only the version at the moment of the call — a
+     *   crossing can land before the handle is used, and {@link ProtocolVersionMismatchError} from the operation that uses
+     *   it is what says so.
+     * @example
+     *   Balancing a transaction a dApp connector handed over as hex:
+     *
+     *   ```typescript
+     *   const handle = facade.adoptTransaction(Buffer.from(txHex, 'hex'), 'Unbound');
+     *   const recipe = await facade.balanceUnboundTransaction(handle, { ttl });
+     *   ```;
+     *
+     * @param bytes The transaction's own serialization, as the ledger version that wrote it produced it.
+     * @param stage How far along the building of the transaction these bytes are, which decides the markers they are read
+     *   with.
+     * @returns The sealed handle, stamped with the protocol version the facade is acting at.
+     * @throws {@link WireFormatError} When the bytes are not a transaction of that version at that stage — which is what
+     *   a transaction authored on the other side of a protocol boundary looks like from here.
+     */
+    adoptTransaction<TStage extends WalletTransaction.Stage>(bytes: Uint8Array, stage: TStage): WalletTransaction<TStage>;
     private defaultTtl;
     /**
      * Checks whether a transaction is structurally well-formed before passing it to a balance or submit method.

package/dist/index.js

@@ -20,7 +20,7 @@ import { Clock } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { FetchTermsAndConditions as FetchTermsAndConditionsQuery } from '@midnight-ntwrk/wallet-sdk-indexer-client';
 import { QueryRunner } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 import { Array as Arr, Either, Option, pipe, Schema } from 'effect';
-import { ProtocolVersion, TransactionHistoryStorage, WalletTransaction, } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { ProtocolVersion, TransactionHistoryStorage, WalletTransaction, WireFormatError, } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import * as ledgerV8 from '@midnight-ntwrk/ledger-v8';
 import * as Signatures from '@midnight-ntwrk/wallet-sdk-capabilities/signatures';
 import { BehaviorSubject, combineLatest, concatMap, distinctUntilChanged, firstValueFrom, map, tap, } from 'rxjs';
@@ -114,11 +114,21 @@ const v9Authoring = {
     sampleSigningKey: () => ledgerV9.sampleSigningKey(),
     signatureVerifyingKey: (signingKey) => ledgerV9.signatureVerifyingKey(signingKey),
     signData: (signingKey, data) => ledgerV9.signData(signingKey, data),
+    deserializers: {
+        Unproven: (bytes) => ledgerV9.Transaction.deserialize('signature', 'pre-proof', 'pre-binding', bytes),
+        Unbound: (bytes) => ledgerV9.Transaction.deserialize('signature', 'proof', 'pre-binding', bytes),
+        Finalized: (bytes) => ledgerV9.Transaction.deserialize('signature', 'proof', 'binding', bytes),
+    },
 };
 const v8Authoring = {
     sampleSigningKey: () => ledgerV8.sampleSigningKey(),
     signatureVerifyingKey: (signingKey) => Signatures.liftSignatureVerifyingKey(ledgerV8.signatureVerifyingKey(signingKey)),
     signData: (signingKey, data) => Signatures.liftSignature(ledgerV8.signData(signingKey, data)),
+    deserializers: {
+        Unproven: (bytes) => ledgerV8.Transaction.deserialize('signature', 'pre-proof', 'pre-binding', bytes),
+        Unbound: (bytes) => ledgerV8.Transaction.deserialize('signature', 'proof', 'pre-binding', bytes),
+        Finalized: (bytes) => ledgerV8.Transaction.deserialize('signature', 'proof', 'binding', bytes),
+    },
 };
 const TokenKindsToBalance = new (class {
     allTokenKinds = ['shielded', 'unshielded', 'dust'];
@@ -541,6 +551,48 @@ export class WalletFacade {
     authoring() {
         return this.currentVersion() < this.#forkVersion ? v8Authoring : v9Authoring;
     }
+    /**
+     * Reads a transaction from bytes that name no protocol version, at the version the facade is acting at.
+     *
+     * @remarks
+     *   For bytes that reach the wallet from outside the SDK — a dApp connector's serialized transaction above all, whose
+     *   contract carries no version alongside them. The bytes cannot say which ledger version wrote them, so this answers
+     *   with the only version the facade could act at anyway, and reads them with that version's ledger. Bytes the other
+     *   ledger version wrote are refused here rather than misread, because the markers a stage names are part of what the
+     *   ledger checks as it reads.
+     *
+     *   The version is the facade's rather than the caller's, which is the point: a caller that reads
+     *   {@link FacadeState.activeProtocolVersion} and seals a handle itself is answering the same question a moment
+     *   earlier, with a crossing able to land in between. It is still only the version at the moment of the call — a
+     *   crossing can land before the handle is used, and {@link ProtocolVersionMismatchError} from the operation that uses
+     *   it is what says so.
+     * @example
+     *   Balancing a transaction a dApp connector handed over as hex:
+     *
+     *   ```typescript
+     *   const handle = facade.adoptTransaction(Buffer.from(txHex, 'hex'), 'Unbound');
+     *   const recipe = await facade.balanceUnboundTransaction(handle, { ttl });
+     *   ```;
+     *
+     * @param bytes The transaction's own serialization, as the ledger version that wrote it produced it.
+     * @param stage How far along the building of the transaction these bytes are, which decides the markers they are read
+     *   with.
+     * @returns The sealed handle, stamped with the protocol version the facade is acting at.
+     * @throws {@link WireFormatError} When the bytes are not a transaction of that version at that stage — which is what
+     *   a transaction authored on the other side of a protocol boundary looks like from here.
+     */
+    adoptTransaction(bytes, stage) {
+        const protocolVersion = this.currentVersion();
+        return Either.getOrThrowWith(Either.try({
+            try: () => this.authoring().deserializers[stage](bytes),
+            catch: (cause) => new WireFormatError({
+                message: `These bytes are not a transaction of protocol version ${protocolVersion} at stage ${stage} — that is ` +
+                    `the version this wallet is acting at, and a transaction built for another one has to be built again ` +
+                    `for it.`,
+                cause,
+            }),
+        }).pipe(Either.map((transaction) => WalletTransaction.adopt(stage, transaction, protocolVersion))), (error) => error);
+    }
     defaultTtl() {
         return new Date(this.clock.now().getTime() + DEFAULT_TTL_MS);
     }
@@ -1051,11 +1103,12 @@ export class WalletFacade {
         if (!hasShieldedPart && !hasUnshieldedPart) {
             throw Error('At least one shielded or unshielded swap is required.');
         }
-        const shieldedTx = hasShieldedPart && shieldedInputs !== undefined
-            ? await this.shielded.initSwap(shieldedInputs, shieldedOutputs)
+        // Build each leg if the swap involves that token kind, even when it has outputs but no inputs.
+        const shieldedTx = hasShieldedPart
+            ? await this.shielded.initSwap(shieldedInputs ?? {}, shieldedOutputs)
             : undefined;
-        const unshieldedTx = hasUnshieldedPart && unshieldedInputs !== undefined
-            ? await this.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl)
+        const unshieldedTx = hasUnshieldedPart
+            ? await this.unshielded.initSwap(unshieldedInputs ?? {}, unshieldedOutputs, ttl)
             : undefined;
         const combinedTx = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
         if (!combinedTx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.4",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -26,19 +26,19 @@
     }
   },
   "dependencies": {
-    "@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",
+    "@midnightntwrk/ledger-v9": "1.0.0-rc.5",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "3.0.0-beta.2",
+    "@midnight-ntwrk/wallet-sdk-address-format": "4.0.0-beta.4",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "4.0.0-beta.4",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "5.0.0-beta.4",
     "@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",
+    "@midnight-ntwrk/wallet-sdk-shielded": "4.0.0-beta.4",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "4.0.0-beta.4",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@midnight-ntwrk/wallet-sdk-hd": "^3.1.0-beta.2",
+    "@midnight-ntwrk/wallet-sdk-hd": "^3.1.0-beta.3",
     "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.2-beta.0"
   },
   "scripts": {