@midnight-ntwrk/wallet-sdk-dust-wallet 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/DustCoreWallet.js

@@ -52,6 +52,7 @@ export class DustCoreWallet {
     applyEvents(secretKey, events, currentTime) {
         if (!events.length)
             return this;
+        // TODO: replace currentTime with `updatedState.syncTime` introduced in ledger-6.2.0-rc.1
         const updatedState = this.state.replayEvents(secretKey, events).processTtls(currentTime);
         let updatedPending = this.pendingDustTokens;
         if (updatedPending.length) {

package/dist/DustWallet.d.ts

@@ -35,10 +35,10 @@ export declare class DustWalletState {
 export interface DustWallet extends WalletLike.WalletLike<[Variant.VersionedVariant<DefaultV1Variant>]> {
     readonly state: rx.Observable<DustWalletState>;
     start(secretKey: DustSecretKey): Promise<void>;
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: Array<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Promise<UnprovenTransaction>;
+    createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: Array<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Promise<UnprovenTransaction>;
     addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
     calculateFee(transaction: AnyTransaction): Promise<bigint>;
-    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, currentTime: Date, ttl: Date): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
+    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, ttl: Date, currentTime?: Date): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
     finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>): Promise<FinalizedTransaction>;
     readonly submitTransaction: SubmitTransactionMethod<FinalizedTransaction>;
     serializeState(): Promise<string>;

package/dist/DustWallet.js

@@ -110,10 +110,10 @@ export function DustWallet(configuration) {
             })
                 .pipe(Effect.runPromise);
         }
-        addFeePayment(secretKey, transaction, currentTime, ttl) {
+        addFeePayment(secretKey, transaction, ttl, currentTime) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.addFeePayment(secretKey, transaction, currentTime, ttl),
+                [V1Tag]: (v1) => v1.addFeePayment(secretKey, transaction, ttl, currentTime),
             })
                 .pipe(Effect.runPromise);
         }

package/dist/RunningV1Variant.d.ts

@@ -35,10 +35,10 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     constructor(scope: Scope.Scope, context: Variant.VariantContext<DustCoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>);
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError.WalletError, Scope.Scope>;
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
+    createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
     addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
     calculateFee(transaction: AnyTransaction): Effect.Effect<bigint, WalletError.WalletError>;
-    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, currentTime: Date, ttl: Date): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
+    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, ttl: Date, currentTime?: Date): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
     finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError.WalletError>;
     submitTransaction: SubmitTransactionMethod<TTransaction>;
 }

package/dist/RunningV1Variant.js

@@ -81,7 +81,7 @@ export class RunningV1Variant {
         if (nightUtxos.some((utxo) => utxo.type !== nativeToken().raw)) {
             return Effect.fail(WalletError.WalletError.other('Token of a non-Night type received'));
         }
-        return Effect.Do.pipe(Effect.bind('currentState', () => SubscriptionRef.get(this.#context.stateRef)), Effect.bind('utxosWithDustValue', ({ currentState }) => LedgerOps.ledgerTry(() => {
+        return Effect.Do.pipe(Effect.bind('currentState', () => SubscriptionRef.get(this.#context.stateRef)), Effect.bind('blockData', () => this.#v1Context.syncService.blockData()), Effect.bind('utxosWithDustValue', ({ currentState, blockData }) => LedgerOps.ledgerTry(() => {
             const dustPublicKey = this.#v1Context.keysCapability.getDustPublicKey(currentState);
             return nightUtxos.map((utxo) => {
                 const genInfo = {
@@ -90,12 +90,12 @@ export class RunningV1Variant {
                     nonce: LedgerOps.randomNonce(),
                     dtime: undefined,
                 };
-                const dustValue = updatedValue(utxo.ctime, 0n, genInfo, currentTime, currentState.state.params);
+                const dustValue = updatedValue(utxo.ctime, 0n, genInfo, currentTime ?? blockData.timestamp, currentState.state.params);
                 return { token: utxo, value: dustValue };
             });
-        })), Effect.flatMap(({ utxosWithDustValue }) => {
+        })), Effect.flatMap(({ utxosWithDustValue, blockData }) => {
             return this.#v1Context.transactingCapability
-                .createDustGenerationTransaction(currentTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
+                .createDustGenerationTransaction(currentTime ?? blockData.timestamp, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
                 .pipe(EitherOps.toEffect);
         }));
     }
@@ -105,11 +105,11 @@ export class RunningV1Variant {
             .pipe(EitherOps.toEffect);
     }
     calculateFee(transaction) {
-        return pipe(this.#v1Context.syncService.ledgerParameters(), Effect.map((params) => this.#v1Context.transactingCapability.calculateFee(transaction, params)));
+        return pipe(this.#v1Context.syncService.blockData(), Effect.map((blockData) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)));
     }
-    addFeePayment(secretKey, transaction, currentTime, ttl) {
+    addFeePayment(secretKey, transaction, ttl, currentTime) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.syncService.ledgerParameters(), Effect.flatMap((params) => this.#v1Context.transactingCapability.addFeePayment(secretKey, state, transaction, currentTime, ttl, params)), Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.syncService.blockData(), Effect.flatMap((blockData) => this.#v1Context.transactingCapability.addFeePayment(secretKey, state, transaction, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)), Effect.map(({ recipe, newState }) => [recipe, newState]));
         });
     }
     finalizeTransaction(recipe) {

package/dist/Simulator.d.ts

@@ -11,6 +11,7 @@ export type SimulatorState = Readonly<{
 }>;
 export declare class Simulator {
     #private;
+    static blockHash: (blockTime: Date) => Effect.Effect<string>;
     static nextBlockContext: (blockTime: Date) => Effect.Effect<BlockContext>;
     static init(networkId: NetworkId): Effect.Effect<Simulator, never, Scope.Scope>;
     static apply(simulatorState: SimulatorState, tx: ProofErasedTransaction, strictness: WellFormedStrictness, blockContext: BlockContext, blockFullness?: SyntheticCost): Either.Either<[{

package/dist/Simulator.js

@@ -18,7 +18,8 @@ const simpleHash = (input) => {
     return Encoding.decodeHex(input).pipe(EitherOps.toEffect, Effect.andThen((parsed) => Effect.promise(() => crypto.subtle.digest('SHA-256', parsed))), Effect.andThen((out) => Encoding.encodeHex(new Uint8Array(out))), Effect.orDie);
 };
 export class Simulator {
-    static nextBlockContext = (blockTime) => pipe(DateOps.dateToSeconds(blockTime).toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash, Effect.map((hash) => ({
+    static blockHash = (blockTime) => pipe(DateOps.dateToSeconds(blockTime).toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash);
+    static nextBlockContext = (blockTime) => pipe(Simulator.blockHash(blockTime), Effect.map((hash) => ({
         parentBlockHash: hash,
         secondsSinceEpoch: DateOps.dateToSeconds(blockTime),
         secondsSinceEpochErr: 1,

package/dist/Sync.d.ts

@@ -7,7 +7,13 @@ import { DustCoreWallet } from './DustCoreWallet.js';
 import { NetworkId } from './types/ledger.js';
 export interface SyncService<TState, TStartAux, TUpdate> {
     updates: (state: TState, auxData: TStartAux) => Stream.Stream<TUpdate, WalletError.WalletError, Scope.Scope>;
-    ledgerParameters: () => Effect.Effect<LedgerParameters, WalletError.WalletError>;
+    blockData: () => Effect.Effect<BlockData, WalletError.WalletError>;
+}
+export interface BlockData {
+    hash: string;
+    height: number;
+    ledgerParameters: LedgerParameters;
+    timestamp: Date;
 }
 export interface SyncCapability<TState, TUpdate> {
     applyUpdate: (state: TState, update: TUpdate) => TState;

package/dist/Sync.js

@@ -17,6 +17,7 @@ import { WsSubscriptionClient, HttpQueryClient, ConnectionHelper, } from '@midni
 import { DateOps, EitherOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { WsURL } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
 import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { Simulator } from './Simulator.js';
 import { Uint8ArraySchema } from './Serialization.js';
 export const SecretKeysResource = {
     create: (secretKey) => {
@@ -70,16 +71,22 @@ export const makeDefaultSyncService = (config) => {
         updates: (state, secretKey) => {
             return pipe(indexerSyncService.subscribeWallet(state), Stream.map((data) => WalletSyncUpdate.create(data, secretKey)), Stream.provideSomeLayer(indexerSyncService.connectionLayer()));
         },
-        ledgerParameters: () => {
+        blockData: () => {
             return Effect.gen(function* () {
                 const query = yield* BlockHash;
                 const result = yield* query({ offset: null });
-                return result.block?.ledgerParameters;
-            }).pipe(Effect.provide(indexerSyncService.queryClient()), Effect.scoped, Effect.catchAll((err) => Effect.fail(WalletError.WalletError.other(`Encountered unexpected error: ${err.message}`))), Effect.flatMap((ledgerParameters) => {
-                if (ledgerParameters === undefined) {
-                    return Effect.fail(WalletError.WalletError.other('Unable to fetch ledger parameters'));
+                return result.block;
+            }).pipe(Effect.provide(indexerSyncService.queryClient()), Effect.scoped, Effect.catchAll((err) => Effect.fail(WalletError.WalletError.other(`Encountered unexpected error: ${err.message}`))), Effect.flatMap((blockData) => {
+                if (!blockData) {
+                    return Effect.fail(WalletError.WalletError.other('Unable to fetch block data'));
                 }
-                return LedgerOps.ledgerTry(() => LedgerParameters.deserialize(Buffer.from(ledgerParameters, 'hex')));
+                // TODO: convert to schema
+                return LedgerOps.ledgerTry(() => ({
+                    hash: blockData.hash,
+                    height: blockData.height,
+                    ledgerParameters: LedgerParameters.deserialize(Buffer.from(blockData.ledgerParameters, 'hex')),
+                    timestamp: new Date(blockData.timestamp),
+                }));
             }));
         },
     };
@@ -125,7 +132,18 @@ export const makeDefaultSyncCapability = () => {
 export const makeSimulatorSyncService = (config) => {
     return {
         updates: (_state, secretKey) => config.simulator.state$.pipe(Stream.map((state) => ({ update: state, secretKey }))),
-        ledgerParameters: () => pipe(config.simulator.getLatestState(), Effect.map((state) => state.ledger.parameters)),
+        blockData: () => {
+            return Effect.gen(function* () {
+                const state = yield* config.simulator.getLatestState();
+                const timestamp = DateOps.secondsToDate(state.lastTxNumber);
+                return {
+                    hash: yield* Simulator.blockHash(timestamp),
+                    height: Number(state.lastTxNumber),
+                    ledgerParameters: state.ledger.parameters,
+                    timestamp,
+                };
+            });
+        },
     };
 };
 export const makeSimulatorSyncCapability = () => ({

package/dist/Transacting.d.ts

@@ -11,7 +11,7 @@ export interface TransactingCapability<TSecrets, TState, TTransaction> {
     createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<CoinWithValue<Utxo>>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Either.Either<UnprovenTransaction, WalletError.WalletError>;
     addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Either.Either<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
     calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
-    addFeePayment(secretKey: TSecrets, state: TState, transaction: UnprovenTransaction, currentTime: Date, ttl: Date, ledgerParams: LedgerParameters): Either.Either<{
+    addFeePayment(secretKey: TSecrets, state: TState, transaction: UnprovenTransaction, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<{
         recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>;
         newState: TState;
     }, WalletError.WalletError>;
@@ -41,7 +41,7 @@ export declare class TransactingCapabilityImplementation<TTransaction extends An
     addDustGenerationSignature(transaction: UnprovenTransaction, signatureData: Signature): Either.Either<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
     calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
     static feeImbalance(transaction: AnyTransaction, totalFee: bigint): bigint;
-    addFeePayment(secretKey: DustSecretKey, state: DustCoreWallet, transaction: UnprovenTransaction, currentTime: Date, ttl: Date, ledgerParams: LedgerParameters): Either.Either<{
+    addFeePayment(secretKey: DustSecretKey, state: DustCoreWallet, transaction: UnprovenTransaction, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<{
         recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>;
         newState: DustCoreWallet;
     }, WalletError.WalletError>;

package/dist/Transacting.js

@@ -108,7 +108,7 @@ export class TransactingCapabilityImplementation {
             .find(([tt, _]) => tt.tag === 'dust');
         return dustImbalance ? -dustImbalance[1] : totalFee;
     }
-    addFeePayment(secretKey, state, transaction, currentTime, ttl, ledgerParams) {
+    addFeePayment(secretKey, state, transaction, ttl, currentTime, ledgerParams) {
         const network = this.networkId;
         const feeLeft = TransactingCapabilityImplementation.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams));
         const dustTokens = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
@@ -119,8 +119,7 @@ export class TransactingCapabilityImplementation {
         const totalFeeInSelected = selectedTokens.reduce((total, { value }) => total + value, 0n);
         const feeDiff = totalFeeInSelected - feeLeft;
         if (feeDiff < 0n) {
-            // A sanity-check, should never happen
-            return Either.left(new WalletError.TransactingError({ message: 'Error in tokens selection algorithm' }));
+            return Either.left(new WalletError.TransactingError({ message: 'Not enough Dust generated to pay the fee' }));
         }
         // reduce the largest token's value by `feeDiff`
         const tokensWithFeeToTake = selectedTokens.toSorted((a, b) => Number(b.value - a.value));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-dust-wallet",
-  "version": "1.0.0-beta.10",
+  "version": "1.0.0-beta.11",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,10 +28,10 @@
     "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.9",
     "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.9",
     "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.12",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.13",
     "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0-beta.10",
     "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.11",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.12",
     "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.7",
     "effect": "^3.17.3",
     "rxjs": "^7.5"
@@ -40,8 +40,8 @@
     "typecheck": "tsc -b ./tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
-    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
-    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml}\"",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml,md}\"",
     "dist": "tsc -b ./tsconfig.build.json",
     "dist:publish": "tsc -b ./tsconfig.publish.json",
     "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",