@keetanetwork/keetanet-client 0.14.11 → 0.14.13

package/client/index.js

@@ -59991,7 +59991,7 @@ class UserClient {
         }
         const builder = userClient.initBuilder({ ...options, account: request.from.account });
         builder.send(to.account, from.amount, from.token);
-        builder.receive(to.account, to.amount, to.token, true);
+        builder.receive(to.account, to.amount, to.token, request.to.exact ?? false);
         const blocks = await builder.computeBlocks();
         if (blocks.blocks.length !== 1) {
             throw (new Error('Compute Swap Request Generated more than 1 block'));
@@ -60009,7 +60009,7 @@ class UserClient {
             let userClient;
             if (UserClient.isInstance(builderOrUserClient)) {
                 userClient = builderOrUserClient;
-                account = builderOrUserClient.account;
+                account = options?.account ?? builderOrUserClient.account;
             }
             else {
                 const env_1 = { stack: [], error: void 0, hasError: false };
@@ -60051,13 +60051,41 @@ class UserClient {
         if (!sendOperation.to.comparePublicKey(account)) {
             throw (new client_1.default('CLIENT_SWAP_SEND_ACCOUNT_MISMATCH', 'Swap Request send account does not match'));
         }
-        if (request.expected?.token !== undefined && !sendOperation.token.comparePublicKey(request.expected?.token)) {
-            throw (new client_1.default('CLIENT_SWAP_REQUEST_TOKEN_MISMATCH', 'Swap Request send token does not match expected'));
-        }
-        if (request.expected?.amount !== undefined && sendOperation.amount !== request.expected?.amount) {
-            throw (new client_1.default('CLIENT_SWAP_REQUEST_AMOUNT_MISMATCH', 'Swap Request send amount does not match expected'));
+        let sendAmount = receiveOperation.amount;
+        if (request.expected) {
+            let expectedReceive;
+            let expectedSend;
+            if ('receive' in request.expected || 'send' in request.expected) {
+                expectedReceive = request.expected?.receive;
+                expectedSend = request.expected?.send;
+            }
+            else if ('token' in request.expected || 'amount' in request.expected) {
+                expectedReceive = request.expected;
+            }
+            if (expectedReceive) {
+                if (expectedReceive.token !== undefined && !sendOperation.token.comparePublicKey(expectedReceive.token)) {
+                    throw (new client_1.default('CLIENT_SWAP_REQUEST_TOKEN_MISMATCH', 'Swap Request send token does not match expected'));
+                }
+                if (expectedReceive.amount !== undefined && sendOperation.amount !== expectedReceive.amount) {
+                    throw (new client_1.default('CLIENT_SWAP_REQUEST_AMOUNT_MISMATCH', 'Swap Request send amount does not match expected'));
+                }
+            }
+            if (expectedSend) {
+                if (expectedSend.token !== undefined && !(expectedSend.token.comparePublicKey(receiveOperation.token))) {
+                    throw (new client_1.default('CLIENT_SWAP_SEND_TOKEN_MISMATCH', 'Swap acceptance send token does not match swap request receive token'));
+                }
+                if (expectedSend.amount !== undefined) {
+                    if (expectedSend.amount < receiveOperation.amount) {
+                        throw (new client_1.default('CLIENT_SWAP_SEND_AMOUNT_TOO_LOW', 'Send amount must be at least the receive amount specified in the swap request'));
+                    }
+                    if (receiveOperation.exact && receiveOperation.amount !== expectedSend.amount) {
+                        throw (new client_1.default('CLIENT_SWAP_SEND_AMOUNT_RECEIVE_EXACT_MISMATCH', 'Send value is not allowed to differ from expected receive amount for exact receives'));
+                    }
+                    sendAmount = expectedSend.amount;
+                }
+            }
         }
-        builder.send(request.block.account, receiveOperation.amount, receiveOperation.token);
+        builder.send(request.block.account, sendAmount, receiveOperation.token);
         const blocks = await builder.computeBlocks();
         return ([...blocks.blocks, request.block]);
     }
@@ -62822,7 +62850,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Block_instances, _a, _Block_valueBytes, _Block_valueHash, _Block_getSortedRequiredSigners, _Block_validateOperationsPurpose, _Block_validateSignerField, _Block_validateSignatures, _BlockBuilder_block;
+var _Block_instances, _a, _Block_valueBytes, _Block_valueHash, _Block_getSortedRequiredSigners, _Block_validateBytes, _Block_validateOperationsPurpose, _Block_validateSignerField, _Block_validateSignatures, _BlockBuilder_block;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.BlockBuilder = exports.Block = exports.BlockHash = exports.AdjustMethod = exports.BlockPurpose = void 0;
 exports.toAdjustMethod = toAdjustMethod;
@@ -63501,6 +63529,7 @@ class Block {
         if (this.account.isMultisig()) {
             throw (new block_1.default('BLOCK_NO_MULTISIG_OP', 'Cannot create a block for a multisig account'));
         }
+        __classPrivateFieldGet(this, _Block_instances, "m", _Block_validateBytes).call(this);
         __classPrivateFieldGet(this, _Block_instances, "m", _Block_validateSignerField).call(this);
         __classPrivateFieldGet(this, _Block_instances, "m", _Block_validateOperationsPurpose).call(this);
         __classPrivateFieldGet(this, _Block_instances, "m", _Block_validateSignatures).call(this);
@@ -63508,9 +63537,11 @@ class Block {
     static getAccountOpeningHash(account) {
         return (BlockHash.getAccountOpeningHash(account));
     }
-    toBytes(includeSignatures = true) {
-        if (__classPrivateFieldGet(this, _Block_valueBytes, "f") !== undefined && includeSignatures) {
-            return (__classPrivateFieldGet(this, _Block_valueBytes, "f"));
+    toBytes(includeSignatures = true, useCached = true) {
+        if (useCached) {
+            if (__classPrivateFieldGet(this, _Block_valueBytes, "f") !== undefined && includeSignatures) {
+                return (__classPrivateFieldGet(this, _Block_valueBytes, "f"));
+            }
         }
         const sharedBlockValues = {
             previous: this.previous,
@@ -63712,6 +63743,18 @@ _a = Block, _Block_valueBytes = new WeakMap(), _Block_valueHash = new WeakMap(),
         }
     }
     return (out);
+}, _Block_validateBytes = function _Block_validateBytes() {
+    const existingBytes = __classPrivateFieldGet(this, _Block_valueBytes, "f");
+    if (existingBytes === undefined) {
+        return;
+    }
+    const recalculatedBytesBuffer = Buffer.from(this.toBytes(true, false));
+    const existingBytesBuffer = Buffer.from(existingBytes);
+    if (!recalculatedBytesBuffer.equals(existingBytesBuffer)) {
+        const existingBytesHash = Buffer.from((0, hash_1.Hash)(existingBytesBuffer)).toString('hex').toUpperCase();
+        const recalculatedBytesHash = Buffer.from((0, hash_1.Hash)(recalculatedBytesBuffer)).toString('hex').toUpperCase();
+        throw (new block_1.default('BLOCK_INVALID_SIGNATURE', `Block signed bytes (${existingBytesHash}) do not match calculated bytes (${recalculatedBytesHash})`));
+    }
 }, _Block_validateOperationsPurpose = function _Block_validateOperationsPurpose() {
     /**
      * Do not allow blocks to contain invalid constructions
@@ -63767,7 +63810,7 @@ _a = Block, _Block_valueBytes = new WeakMap(), _Block_valueHash = new WeakMap(),
         const signature = new buffer_1.BufferStorage(this.signatures[i], 64);
         const valid = signers[i].verify(this.hash.get(), signature.get());
         if (valid !== true) {
-            throw (new Error(`Unable to validate signature of ${this.hash.toString()} against signature ${this.signatures[i]} for account ${signers[i].publicKeyString.get()}`));
+            throw (new block_1.default('BLOCK_INVALID_SIGNATURE', `Unable to validate signature of ${this.hash.toString()} against signature ${this.signatures[i].toString('hex')} for account ${signers[i].publicKeyString.get()}`));
         }
     }
 };
@@ -64354,7 +64397,11 @@ class BlockOperation {
         if (amount === undefined || amount === null) {
             throw (new Error('internal error: "amount" is invalid'));
         }
-        return (BigInt(amount));
+        const bigintAmount = BigInt(amount);
+        if (bigintAmount < 0n) {
+            throw (new block_1.default('BLOCK_AMOUNT_BELOW_ZERO', 'value cannot be negative'));
+        }
+        return (bigintAmount);
     }
 }
 BlockOperation.isInstance = (0, helper_1.checkableGenerator)(BlockOperation);
@@ -64550,7 +64597,7 @@ class BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockOperation {
         }
         __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_token, __classPrivateFieldGet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_instances, "m", _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_computeToken).call(this, input.token), "f");
         __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_amount, this.computeAmount(input.amount), "f");
-        __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_method, input.method, "f");
+        __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_method, (0, _1.toAdjustMethod)(input.method), "f");
     }
     set token(token) {
         __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_token, __classPrivateFieldGet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_instances, "m", _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_computeToken).call(this, token), "f");
@@ -64559,7 +64606,7 @@ class BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockOperation {
         return (__classPrivateFieldGet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_token, "f"));
     }
     set method(newMethod) {
-        __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_method, newMethod, "f");
+        __classPrivateFieldSet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_method, (0, _1.toAdjustMethod)(newMethod), "f");
     }
     get method() {
         return (Number(__classPrivateFieldGet(this, _BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_method, "f")));
@@ -64846,7 +64893,7 @@ class BlockOperationMODIFY_PERMISSIONS extends BlockOperation {
         }
         __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_principal, this.computeTo(input.principal), "f");
         __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_target, account_1.default.toAccount(input.target), "f");
-        __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_method, input.method, "f");
+        __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_method, (0, _1.toAdjustMethod)(input.method), "f");
         __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_permissions, __classPrivateFieldGet(this, _BlockOperationMODIFY_PERMISSIONS_instances, "m", _BlockOperationMODIFY_PERMISSIONS_computePermissions).call(this, input.permissions), "f");
     }
     set principal(principal) {
@@ -64868,7 +64915,7 @@ class BlockOperationMODIFY_PERMISSIONS extends BlockOperation {
         return (__classPrivateFieldGet(this, _BlockOperationMODIFY_PERMISSIONS_target, "f"));
     }
     set method(method) {
-        __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_method, method, "f");
+        __classPrivateFieldSet(this, _BlockOperationMODIFY_PERMISSIONS_method, (0, _1.toAdjustMethod)(method), "f");
     }
     get method() {
         return (Number(__classPrivateFieldGet(this, _BlockOperationMODIFY_PERMISSIONS_method, "f")));
@@ -65495,47 +65542,49 @@ const base_1 = __webpack_require__(1096);
 const helper_1 = __webpack_require__(3208);
 const BlockErrorType = 'BLOCK';
 exports.BlockErrorCodes = [
-    'INVALID_TYPE',
-    'INVALID_VERSION',
-    'NO_MULTIPLE_SET_REP',
-    'IDENTIFIER_NEED_DEFAULT_PERMISSIONS',
+    'AMOUNT_BELOW_ZERO',
+    'CANNOT_FORWARD_TO_SELF',
     'CANNOT_SEND_NON_TOKEN',
-    'TOKEN_RECEIVE_DIFFERS',
-    'ONLY_TOKEN_OP',
-    'ONLY_IDENTIFIER_OP',
-    'NO_TOKEN_OP',
-    'NO_IDENTIFIER_OP',
-    'INVALID_SIGNER',
-    'INVALID_PURPOSE_VALIDATION',
+    'CERTIFICATE_SUBJECT_MISMATCH',
+    'EXACT_TRUE_WHEN_FORWARDING',
+    'EXTERNAL_INVALID',
+    'EXTERNAL_MISSING',
+    'EXTERNAL_TOO_LONG',
+    'GENERAL_FIELD_INVALID',
+    'IDENTIFIER_INVALID',
+    'IDENTIFIER_NEED_DEFAULT_PERMISSIONS',
+    'INTERMEDIATE_CERTIFICATES_ONLY_ADD',
+    'INVALID_ACCOUNT_TYPE',
+    'INVALID_CERTIFICATE_VALUE',
+    'INVALID_CREATE_IDENTIFIER_ARGS',
+    'INVALID_IDEMPOTENT_FORMAT',
+    'INVALID_IDEMPOTENT_LENGTH',
     'INVALID_MULTISIG_QUORUM',
-    'INVALID_MULTISIG_SIGNER_DEPTH',
     'INVALID_MULTISIG_SIGNER_COUNT',
+    'INVALID_MULTISIG_SIGNER_DEPTH',
     'INVALID_MULTISIG_SIGNER_DUPLICATE',
-    'INVALID_CREATE_IDENTIFIER_ARGS',
+    'INVALID_PURPOSE_VALIDATION',
+    'INVALID_SIGNATURE',
+    'INVALID_SIGNER',
+    'INVALID_TYPE',
+    'INVALID_VERSION',
+    'NO_ADMIN_ON_TARGET',
+    'NO_DELEGATE_ADMIN',
+    'NO_DUPLICATE_CERTIFICATE_OPERATION',
+    'NO_IDENTIFIER_OP',
+    'NO_MODIFY_PERMISSION_DUPE',
+    'NO_MULTIPLE_SET_REP',
     'NO_MULTISIG_OP',
-    'IDENTIFIER_INVALID',
-    'GENERAL_FIELD_INVALID',
+    'NO_TOKEN_OP',
+    'ONLY_IDENTIFIER_OP',
+    'ONLY_TOKEN_OP',
     'PERMISSIONS_INVALID_DEFAULT',
     'PERMISSIONS_INVALID_ENTITY',
     'PERMISSIONS_INVALID_PRINCIPAL',
     'PERMISSIONS_INVALID_TARGET',
-    'INVALID_ACCOUNT_TYPE',
-    'NO_ADMIN_ON_TARGET',
     'PREVIOUS_SELF',
-    'NO_DELEGATE_ADMIN',
-    'NO_MODIFY_PERMISSION_DUPE',
-    'CANNOT_FORWARD_TO_SELF',
-    'EXACT_TRUE_WHEN_FORWARDING',
-    'CERTIFICATE_SUBJECT_MISMATCH',
-    'NO_DUPLICATE_CERTIFICATE_OPERATION',
-    'INTERMEDIATE_CERTIFICATES_ONLY_ADD',
-    'INVALID_CERTIFICATE_VALUE',
-    'EXTERNAL_TOO_LONG',
-    'EXTERNAL_INVALID',
-    'EXTERNAL_MISSING',
     'SUPPLY_INVALID',
-    'INVALID_IDEMPOTENT_FORMAT',
-    'INVALID_IDEMPOTENT_LENGTH'
+    'TOKEN_RECEIVE_DIFFERS'
 ];
 exports.FullBlockErrorCodes = exports.BlockErrorCodes.map(code => `${BlockErrorType}_${code}`);
 class KeetaNetBlockError extends base_1.KeetaNetErrorBase {
@@ -65611,6 +65660,9 @@ exports.ClientErrorCodes = [
     'SWAP_MISSING_RECEIVE',
     'SWAP_SEND_RECEIVE_ACCOUNT_MISMATCH',
     'SWAP_SEND_ACCOUNT_MISMATCH',
+    'SWAP_SEND_TOKEN_MISMATCH',
+    'SWAP_SEND_AMOUNT_TOO_LOW',
+    'SWAP_SEND_AMOUNT_RECEIVE_EXACT_MISMATCH',
     'SWAP_REQUEST_TOKEN_MISMATCH',
     'SWAP_REQUEST_AMOUNT_MISMATCH'
 ];
@@ -67334,6 +67386,9 @@ function updateAccountInfoInState(state, account, info) {
  * Compute the effect of a SEND operation
  */
 function computeEffectOfOperationSEND(state, block, operation) {
+    if (operation.amount < 0n) {
+        throw (new Error('Internal error: SEND operation with negative amount'));
+    }
     // Decrement sender balance
     const senderChange = {
         state,
@@ -67361,6 +67416,9 @@ function computeEffectOfOperationSEND(state, block, operation) {
  * Compute the effect of a RECEIVE operation
  */
 function computeEffectOfOperationRECEIVE(state, block, operation) {
+    if (operation.amount < 0n) {
+        throw (new Error('Internal error: RECEIVE operation with negative amount'));
+    }
     // Increment recipient balance
     const recipientChange = {
         state,
@@ -67396,6 +67454,9 @@ function computeEffectOfOperationRECEIVE(state, block, operation) {
     }
 }
 function computeEffectOfOperationTOKEN_ADMIN_MODIFY_BALANCE(state, block, operation) {
+    if (operation.amount < 0n) {
+        throw (new Error('Internal error: TOKEN_ADMIN_MODIFY_BALANCE operation with negative amount'));
+    }
     if (operation.method === block_1.Block.AdjustMethod.SET) {
         const setChange = {
             state,
@@ -67465,6 +67526,9 @@ function computeEffectOfOperationCREATE_IDENTIFIER(state, block, operation, cont
             throw (new Error('Invalid identifier creation arguments'));
         }
         updateAccountInfoInState(state, operation.identifier, { multisigQuorum: operation.createArguments.quorum });
+        if (operation.createArguments.quorum < 1n || operation.createArguments.quorum > BigInt(operation.createArguments.signers.length)) {
+            throw (new Error('Internal error: operation.createArguments.quorum is invalid'));
+        }
         for (const multisigSigner of operation.createArguments.signers) {
             state.possibleNewAccounts.add(multisigSigner);
             addPermission(state, {
@@ -67506,6 +67570,9 @@ function computeEffectOfOperationMODIFY_PERMISSIONS(state, block, operation) {
     });
 }
 function computeEffectOfOperationTOKEN_ADMIN_SUPPLY(state, block, operation) {
+    if (operation.amount < 0n) {
+        throw (new Error('Internal error: TOKEN_ADMIN_SUPPLY operation with negative amount'));
+    }
     const tokenPubKey = block.account.publicKeyString.get();
     let value = 0n;
     switch (operation.method) {
@@ -69783,6 +69850,9 @@ class Log {
      * Register a new logging target (sink) to send logs to
      */
     registerTarget(target) {
+        if (__classPrivateFieldGet(this, _Log_destroyed, "f")) {
+            throw (new Error('Cannot register target on destroyed Log instance'));
+        }
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const id = Symbol('LogTargetID');
         __classPrivateFieldGet(this, _Log_targets, "f").set(id, target);
@@ -69802,6 +69872,9 @@ class Log {
      * Unregister a logging target (sink) to stop sending logs to
      */
     unregisterTarget(id) {
+        if (__classPrivateFieldGet(this, _Log_destroyed, "f")) {
+            return;
+        }
         __classPrivateFieldGet(this, _Log_targets, "f").delete(id);
     }
     /**
@@ -69816,6 +69889,9 @@ class Log {
      * Start a timer to periodically sync logs to all targets
      */
     startAutoSync(rate = 100) {
+        if (__classPrivateFieldGet(this, _Log_destroyed, "f")) {
+            throw (new Error('Cannot start auto sync on destroyed Log instance'));
+        }
         this.stopAutoSync();
         __classPrivateFieldSet(this, _Log_autoSyncInterval, setInterval(async () => {
             try {
@@ -69887,6 +69963,9 @@ class Log {
      * Dispose of the logger instance, clearing all logs and targets
      */
     [(_Log_logs = new WeakMap(), _Log_autoSyncInterval = new WeakMap(), _Log_isSyncing = new WeakMap(), _Log_shouldSyncAgain = new WeakMap(), _Log_destroyed = new WeakMap(), _Log_emitOnLog = new WeakMap(), _Log_logDebugTracing = new WeakMap(), _Log_targets = new WeakMap(), _Log_instances = new WeakSet(), _Log_log = function _Log_log(level, options, from, ...args) {
+        if (__classPrivateFieldGet(this, _Log_destroyed, "f")) {
+            return;
+        }
         const log = { options, level, from, args };
         if (__classPrivateFieldGet(this, _Log_logDebugTracing, "f")) {
             log.trace = new Error().stack?.split('\n').slice(2).join('\n') ?? '[No stack trace available]';
@@ -69911,6 +69990,14 @@ class Log {
     }, Symbol.dispose)]() {
         this.destroy();
     }
+    /**
+     * Dispose of the logger instance, syncing all logs, and clearing targets
+     */
+    async [Symbol.asyncDispose]() {
+        __classPrivateFieldSet(this, _Log_destroyed, true, "f");
+        await this.sync();
+        this.destroy();
+    }
     /**
      * Terminate the logger instance, clearing all logs and targets
      */
@@ -70288,7 +70375,12 @@ class RequestTiming {
     constructor() {
         _RequestTiming_timing.set(this, new Map());
         _RequestTiming_counter.set(this, 0);
-        this.log = RequestTiming.defaultLogger;
+        if (RequestTiming.defaultLogger === '@legacy') {
+            this.log = log_1.default.Legacy();
+        }
+        else {
+            this.log = RequestTiming.defaultLogger;
+        }
     }
     /**
      * Start timing a section of code
@@ -70303,12 +70395,17 @@ class RequestTiming {
             start: Date.now()
         };
         __classPrivateFieldGet(this, _RequestTiming_timing, "f").set(id, data);
+        let endCalled = false;
         return ({
-            id,
+            id: id,
             end: () => {
+                endCalled = true;
                 this.endTime(id);
             },
             [Symbol.dispose]: () => {
+                if (endCalled) {
+                    return;
+                }
                 this.endTime(id);
             }
         });
@@ -70323,11 +70420,11 @@ class RequestTiming {
         if (typeof section === 'symbol') {
             const timingInfo = __classPrivateFieldGet(this, _RequestTiming_timing, "f").get(section);
             if (timingInfo === undefined) {
-                this.log.error(`Timing section ${String(section)} does not exist but "end" was called on it!`);
+                this.log.error('timing::endTime', `Timing section ${String(section)} does not exist but "end" was called on it!`);
                 return;
             }
             if (timingInfo.end !== undefined) {
-                this.log.error(`Timing section ${timingInfo.id} already ended but "end" was called on it again!`);
+                this.log.error('timing::endTime', `Timing section ${timingInfo.id} already ended but "end" was called on it again!`);
                 return;
             }
             timingInfo.end = Date.now();
@@ -70425,7 +70522,7 @@ class RequestTiming {
 }
 exports.RequestTiming = RequestTiming;
 _RequestTiming_timing = new WeakMap(), _RequestTiming_counter = new WeakMap();
-RequestTiming.defaultLogger = log_1.default.Legacy();
+RequestTiming.defaultLogger = '@legacy';
 exports["default"] = RequestTiming;
 
 
@@ -74006,7 +74103,8 @@ exports.ASN1BigIntToBuffer = ASN1BigIntToBuffer;
  * - {@link ValidateASN1.IsNull}
  *
  * More complex types are defined as:
- * - Choice: `{ choice: [ schema1, schema2, ... ] }`
+ * - Choice (named): `{ choice: { name1: schema1, name2: schema2, ... } }` - Converts to `{ name1: value }` or `{ name2: value }`
+ * - Choice (legacy array): `{ choice: [ schema1, schema2, ... ] }` - Converts to union type (ambiguous for re-encoding)
  * - Sequence of: `{ sequenceOf: schema }`
  * - Optional: `{ optional: schema }`
  * - Context Tag: `{ type: 'context'; kind: 'implicit' | 'explicit'; contains: schema; value: number }`
@@ -74330,6 +74428,7 @@ class ValidateASN1 {
                     case 'struct': {
                         const outputStruct = {
                             type: 'struct',
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                             fieldNames: schema.fieldNames,
                             contains: {}
                         };
@@ -74362,6 +74461,47 @@ class ValidateASN1 {
                 }
             }
             else if ('choice' in schema) {
+                // Handle named choices: { choice: { a: schema1, b: schema2 } }
+                if (!Array.isArray(schema.choice)) {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    const choiceObj = schema.choice;
+                    // For context tags, match by value and kind
+                    if (isASN1ContextTag(input)) {
+                        const inputAsChoice = input;
+                        for (const choiceName in choiceObj) {
+                            const choice = choiceObj[choiceName];
+                            if (choice === undefined) {
+                                continue;
+                            }
+                            if (!isASN1ContextTag(choice)) {
+                                continue;
+                            }
+                            if (choice.value !== inputAsChoice.value) {
+                                continue;
+                            }
+                            if (choice.kind !== inputAsChoice.kind) {
+                                continue;
+                            }
+                            return (ValidateASN1.againstSchema(input, choice));
+                        }
+                        throw (new Error('No valid choice found'));
+                    }
+                    // Try each choice
+                    for (const choiceName in choiceObj) {
+                        const choice = choiceObj[choiceName];
+                        if (choice === undefined) {
+                            continue;
+                        }
+                        try {
+                            return (ValidateASN1.againstSchema(input, choice));
+                        }
+                        catch (_ignored_checkError) {
+                            /* Ignored error */
+                        }
+                    }
+                    throw (new Error('No valid choice found'));
+                }
+                // Handle array choices (legacy)
                 if (isASN1ContextTag(input)) {
                     const inputAsChoice = input;
                     const matchingSchema = schema.choice.find(function (choice) {
@@ -74383,7 +74523,6 @@ class ValidateASN1 {
                 }
                 for (const choice of schema.choice) {
                     try {
-                        // @ts-ignore
                         return (ValidateASN1.againstSchema(input, choice));
                     }
                     catch (_ignored_checkError) {
@@ -74472,6 +74611,499 @@ class ValidateASN1 {
     validate(input) {
         return (ValidateASN1.againstSchema(input, __classPrivateFieldGet(this, _ValidateASN1_schema, "f")));
     }
+    /**
+     * Convert an ASN.1 object to a JavaScript object (including primitives)
+     * based on the schema.
+     *
+     * Converts ASN1 objects to plain JavaScript objects according to the schema:
+     * - Structs are converted to plain objects with field names as keys
+     * - For ambiguous types (IsAnyString, IsAnyDate), returns ASN.1-like objects: { type: 'string', kind: 'utf8', value: 'text' }
+     * - Arrays/sequences are preserved as arrays
+     * - Primitive types (bigint, string, boolean, null, Buffer, Date) are preserved
+     *
+     * Example schema: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: ValidateASN1.IsAnyString, age: ValidateASN1.IsInteger } }
+     * Input: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n } }
+     * Output: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n }
+     */
+    toJavaScriptObject(input) {
+        this.validate(input);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return ValidateASN1.toPlainObject(input, __classPrivateFieldGet(this, _ValidateASN1_schema, "f"));
+    }
+    /**
+     * Convert a plain JavaScript object back to an ASN.1 object based on the schema.
+     *
+     * Converts plain JavaScript objects back to ASN1 representation according to the schema:
+     * - Plain objects with field names are converted to ASN1Struct
+     * - For ambiguous schemas, recognizes ASN.1-like objects: { type: 'string', kind: 'utf8', value: 'text' }
+     * - Arrays are preserved as sequences
+     * - Primitive types are preserved or wrapped in appropriate ASN1 types
+     *
+     * Example schema: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: ValidateASN1.IsAnyString, age: ValidateASN1.IsInteger } }
+     * Input: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n }
+     * Output: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n } }
+     */
+    fromJavaScriptObject(input) {
+        const retval = ValidateASN1.fromPlainObject(input, __classPrivateFieldGet(this, _ValidateASN1_schema, "f"));
+        this.validate(retval);
+        return (retval);
+    }
+    /**
+     * Convert an ASN.1 object to a plain JavaScript object based on a schema
+     */
+    static toPlainObject(input, schemaIn) {
+        let schema = schemaIn;
+        if (typeof schema === 'function') {
+            schema = schema();
+        }
+        // Handle choice schemas first (before primitive checks)
+        // This ensures named choices wrap their values correctly
+        if (typeof schema === 'object' && schema !== null && 'choice' in schema) {
+            // Handle named choices: { choice: { a: schema1, b: schema2 } }
+            if (!Array.isArray(schema.choice)) {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const choiceObj = schema.choice;
+                for (const choiceName in choiceObj) {
+                    const choiceSchema = choiceObj[choiceName];
+                    if (choiceSchema === undefined) {
+                        continue;
+                    }
+                    try {
+                        // Validate that the input matches this choice schema
+                        ValidateASN1.againstSchema(input, choiceSchema);
+                        // If validation passes, convert and wrap in named object
+                        const converted = ValidateASN1.toPlainObject(input, choiceSchema);
+                        return ({ [choiceName]: converted });
+                    }
+                    catch {
+                        // Try next choice
+                    }
+                }
+                throw (new Error('No valid choice found'));
+            }
+            // Handle array choices (legacy): { choice: [schema1, schema2] }
+            // For choices, recursively convert the selected choice
+            for (const choice of schema.choice) {
+                try {
+                    return (ValidateASN1.toPlainObject(input, choice));
+                }
+                catch {
+                    // Try next choice
+                }
+            }
+            throw (new Error('No valid choice found'));
+        }
+        // Handle primitives that don't need conversion
+        if (typeof input === 'bigint' || typeof input === 'boolean' || input === null || (0, helper_1.isBuffer)(input) || util_1.types.isDate(input)) {
+            return (input);
+        }
+        // Handle plain strings
+        if (typeof input === 'string') {
+            return (input);
+        }
+        // Handle basic schema types
+        if (typeof schema === 'symbol') {
+            switch (schema) {
+                case ValidateASN1.IsInteger:
+                case ValidateASN1.IsBoolean:
+                case ValidateASN1.IsNull:
+                case ValidateASN1.IsOctetString:
+                case ValidateASN1.IsString:
+                case ValidateASN1.IsDate:
+                    return (input);
+                case ValidateASN1.IsAnyString:
+                    if (isASN1String(input)) {
+                        // For ambiguous schemas, return ASN.1-like object
+                        return ({ type: 'string', kind: input.kind, value: input.value });
+                    }
+                    return (input);
+                case ValidateASN1.IsAnyDate:
+                    if (isASN1Date(input)) {
+                        // For ambiguous schemas, return ASN.1-like object
+                        return ({ type: 'date', kind: input.kind, value: input.date });
+                    }
+                    return (input);
+                case ValidateASN1.IsBitString:
+                    if (isASN1BitString(input)) {
+                        // Use expanded form to preserve unusedBits information
+                        // This distinguishes between bit strings like 111 and 0111
+                        return ({ type: 'bitstring', value: input.value, unusedBits: input.unusedBits });
+                    }
+                    return (input);
+                case ValidateASN1.IsOID:
+                    if (isASN1OID(input)) {
+                        return (input.oid);
+                    }
+                    return (input);
+                case ValidateASN1.IsSet:
+                    return (input);
+                case ValidateASN1.IsAny:
+                case ValidateASN1.IsUnknown:
+                    return (input);
+            }
+        }
+        // Handle bigint schema (fixed value)
+        if (typeof schema === 'bigint') {
+            return (input);
+        }
+        // Handle object schemas
+        if (typeof schema === 'object' && schema !== null) {
+            if ('type' in schema) {
+                switch (schema.type) {
+                    case 'struct': {
+                        if (!isASN1Struct(input)) {
+                            throw (new Error('Expected ASN1Struct'));
+                        }
+                        const result = {};
+                        for (const fieldName of schema.fieldNames) {
+                            const fieldValue = input.contains[fieldName];
+                            if (fieldValue === undefined) {
+                                continue;
+                            }
+                            const fieldSchema = schema.contains[fieldName];
+                            if (isASN1ContextTag(fieldValue)) {
+                                // Context tags are metadata like optional - unwrap them completely
+                                // Need to unwrap optional and get the context tag schema
+                                let contextSchema = fieldSchema;
+                                if (typeof contextSchema === 'object' && contextSchema !== null && 'optional' in contextSchema) {
+                                    contextSchema = contextSchema.optional;
+                                }
+                                // For implicit context tags with ArrayBuffer, can't convert further
+                                if (fieldValue.kind === 'implicit' && util_1.types.isArrayBuffer(fieldValue.contains)) {
+                                    result[fieldName] = fieldValue.contains;
+                                }
+                                else if (typeof contextSchema === 'object' && contextSchema !== null && 'type' in contextSchema && contextSchema.type === 'context' && 'contains' in contextSchema) {
+                                    // Unwrap the context tag - just convert the inner value
+                                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                                    result[fieldName] = ValidateASN1.toPlainObject(fieldValue.contains, contextSchema.contains);
+                                }
+                                else {
+                                    // Fallback: convert the inner value with full field schema
+                                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                                    result[fieldName] = ValidateASN1.toPlainObject(fieldValue.contains, fieldSchema);
+                                }
+                            }
+                            else {
+                                // For all other types (including strings and dates), recursively convert
+                                const plainValue = ValidateASN1.toPlainObject(fieldValue, fieldSchema);
+                                result[fieldName] = plainValue;
+                            }
+                        }
+                        return (result);
+                    }
+                    case 'string':
+                        if (isASN1String(input)) {
+                            return (input.value);
+                        }
+                        return (input);
+                    case 'date':
+                        if (isASN1Date(input)) {
+                            return (input.date);
+                        }
+                        return (input);
+                    case 'oid':
+                        if (isASN1OID(input)) {
+                            return (input.oid);
+                        }
+                        return (input);
+                    case 'context':
+                        if (isASN1ContextTag(input)) {
+                            // For implicit context tags with ArrayBuffer, we can't convert further
+                            if (input.kind === 'implicit' && util_1.types.isArrayBuffer(input.contains)) {
+                                return (input.contains);
+                            }
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            return (ValidateASN1.toPlainObject(input.contains, schema.contains));
+                        }
+                        return (input);
+                }
+            }
+            if ('sequenceOf' in schema) {
+                if (!Array.isArray(input)) {
+                    throw (new Error('Expected array for sequenceOf'));
+                }
+                return (input.map(item => ValidateASN1.toPlainObject(item, schema.sequenceOf)));
+            }
+            if ('optional' in schema) {
+                if (input === undefined) {
+                    return (undefined);
+                }
+                return (ValidateASN1.toPlainObject(input, schema.optional));
+            }
+            if (Array.isArray(schema)) {
+                if (!Array.isArray(input)) {
+                    throw (new Error('Expected array'));
+                }
+                const result = [];
+                for (let i = 0; i < Math.min(input.length, schema.length); i++) {
+                    const item = input[i];
+                    if (item === undefined) {
+                        result.push(undefined);
+                    }
+                    else {
+                        result.push(ValidateASN1.toPlainObject(item, schema[i]));
+                    }
+                }
+                return (result);
+            }
+        }
+        return (input);
+    }
+    /**
+     * Convert a plain JavaScript object to an ASN.1 object based on a schema
+     */
+    static fromPlainObject(input, schemaIn) {
+        let schema = schemaIn;
+        if (typeof schema === 'function') {
+            schema = schema();
+        }
+        // Handle null/undefined
+        if (input === null || input === undefined) {
+            /* Verify that the schema for this is actually is nullable */
+            let nullable = false;
+            if (schema === ValidateASN1.IsNull) {
+                nullable = true;
+            }
+            else if (typeof schema === 'object' && schema !== null) {
+                if ('optional' in schema) {
+                    nullable = true;
+                }
+            }
+            if (!nullable) {
+                throw (new Error(`Expected non-null value, got ${input}`));
+            }
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return input;
+        }
+        // For ambiguous schemas (IsAnyString, IsAnyDate), check if input is already in ASN.1-like format
+        // These are objects like { type: 'string', kind: 'utf8', value: 'text' } or { type: 'date', kind: 'general', value: Date }
+        // Also handle expanded bitstring format: { type: 'bitstring', value: Buffer, unusedBits: number }
+        if (typeof input === 'object' && input !== null && !(0, helper_1.isBuffer)(input) && !util_1.types.isDate(input) && !Array.isArray(input)) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const inputObj = input;
+            // Check for string-like format: { type: 'string', kind, value }
+            if (inputObj.type === 'string' && typeof inputObj.kind === 'string' && 'value' in inputObj) {
+                const kind = inputObj.kind;
+                if (kind === 'printable' || kind === 'ia5' || kind === 'utf8') {
+                    if (typeof inputObj.value === 'string') {
+                        return ({ type: 'string', kind, value: inputObj.value });
+                    }
+                }
+            }
+            // Check for date-like format: { type: 'date', kind, value }
+            if (inputObj.type === 'date' && typeof inputObj.kind === 'string' && 'value' in inputObj) {
+                const kind = inputObj.kind;
+                if (kind === 'utc' || kind === 'general') {
+                    if (util_1.types.isDate(inputObj.value)) {
+                        return ({ type: 'date', kind, date: inputObj.value });
+                    }
+                }
+            }
+            // Check for bitstring format: { type: 'bitstring', value, unusedBits }
+            if (inputObj.type === 'bitstring' && 'value' in inputObj && 'unusedBits' in inputObj) {
+                if ((0, helper_1.isBuffer)(inputObj.value) && typeof inputObj.unusedBits === 'number') {
+                    return ({ type: 'bitstring', value: inputObj.value, unusedBits: inputObj.unusedBits });
+                }
+            }
+        }
+        // Check schema FIRST before doing any primitive handling
+        // This is important for context tags and other wrappers
+        // Handle object schemas
+        if (typeof schema === 'object' && schema !== null) {
+            if ('type' in schema) {
+                switch (schema.type) {
+                    case 'context': {
+                        // Context tags: reconstruct from schema definition (metadata like optional)
+                        // Schema has the kind and value, input is the plain value
+                        // At this point we know schema.type === 'context', so it must have kind, value, contains
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const contextTagSchema = schema;
+                        return ({
+                            type: 'context',
+                            kind: contextTagSchema.kind,
+                            value: contextTagSchema.value,
+                            contains: ValidateASN1.fromPlainObject(input, contextTagSchema.contains)
+                        });
+                    }
+                    case 'struct': {
+                        if (typeof input !== 'object' || input === null) {
+                            throw (new Error('Expected object for struct'));
+                        }
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const inputObj = input;
+                        const result = {
+                            type: 'struct',
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            fieldNames: schema.fieldNames,
+                            contains: {}
+                        };
+                        for (const fieldName of schema.fieldNames) {
+                            const fieldValue = inputObj[fieldName];
+                            if (fieldValue === undefined) {
+                                continue;
+                            }
+                            const fieldSchema = schema.contains[fieldName];
+                            result.contains[fieldName] = ValidateASN1.fromPlainObject(fieldValue, fieldSchema);
+                        }
+                        return (result);
+                    }
+                    case 'string':
+                        if (typeof input === 'string') {
+                            return ({ type: 'string', kind: schema.kind, value: input });
+                        }
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        return input;
+                    case 'date':
+                        if (util_1.types.isDate(input)) {
+                            return ({ type: 'date', kind: schema.kind, date: input });
+                        }
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        return input;
+                    case 'oid':
+                        if (typeof input === 'string') {
+                            return ({ type: 'oid', oid: input });
+                        }
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        return input;
+                }
+            }
+            if ('choice' in schema) {
+                // Handle named choices: { choice: { a: schema1, b: schema2 } }
+                if (!Array.isArray(schema.choice)) {
+                    if (typeof input === 'object' && input !== null && !(0, helper_1.isBuffer)(input) && !util_1.types.isDate(input)) {
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const inputObj = input;
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const choiceObj = schema.choice;
+                        // Find which choice name is present in the input
+                        for (const choiceName in choiceObj) {
+                            if (choiceName in inputObj) {
+                                const choiceSchema = choiceObj[choiceName];
+                                if (choiceSchema === undefined) {
+                                    continue;
+                                }
+                                const choiceValue = inputObj[choiceName];
+                                return (ValidateASN1.fromPlainObject(choiceValue, choiceSchema));
+                            }
+                        }
+                    }
+                    throw (new Error('No valid choice found for input - expected object with one of: ' + Object.keys(schema.choice).join(', ')));
+                }
+                // Handle array choices (legacy): { choice: [schema1, schema2] }
+                // For choices, try to convert with each choice schema
+                for (const choice of schema.choice) {
+                    try {
+                        return (ValidateASN1.fromPlainObject(input, choice));
+                    }
+                    catch {
+                        // Try next choice
+                    }
+                }
+                throw (new Error('No valid choice found for input'));
+            }
+            if ('sequenceOf' in schema) {
+                if (!Array.isArray(input)) {
+                    throw (new Error('Expected array for sequenceOf'));
+                }
+                return (input.map(item => ValidateASN1.fromPlainObject(item, schema.sequenceOf)));
+            }
+            if ('optional' in schema) {
+                return (ValidateASN1.fromPlainObject(input, schema.optional));
+            }
+            if (Array.isArray(schema)) {
+                if (!Array.isArray(input)) {
+                    throw (new Error('Expected array'));
+                }
+                const result = [];
+                for (let i = 0; i < schema.length; i++) {
+                    if (i < input.length && input[i] !== undefined) {
+                        result.push(ValidateASN1.fromPlainObject(input[i], schema[i]));
+                    }
+                    else if (isASN1ModifierOptional(schema[i])) {
+                        result.push(undefined);
+                    }
+                    else {
+                        throw (new Error(`Missing required field at index ${i}`));
+                    }
+                }
+                return (result);
+            }
+        }
+        // Handle symbol schemas (basic types)
+        if (typeof schema === 'symbol') {
+            switch (schema) {
+                case ValidateASN1.IsInteger:
+                case ValidateASN1.IsBoolean:
+                case ValidateASN1.IsNull:
+                case ValidateASN1.IsDate:
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsOctetString:
+                    // OctetString can accept a Buffer directly
+                    if ((0, helper_1.isBuffer)(input)) {
+                        return (input);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsString:
+                    if (typeof input === 'string') {
+                        return (input);
+                    }
+                    throw (new Error('Expected string'));
+                case ValidateASN1.IsAnyString:
+                    if (typeof input === 'string') {
+                        // Determine appropriate string kind
+                        if (isStringValidForKind(input, 'printable')) {
+                            return ({ type: 'string', kind: 'printable', value: input });
+                        }
+                        else if (isStringValidForKind(input, 'ia5')) {
+                            return ({ type: 'string', kind: 'ia5', value: input });
+                        }
+                        else {
+                            return ({ type: 'string', kind: 'utf8', value: input });
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsAnyDate:
+                    if (util_1.types.isDate(input)) {
+                        if (input.getUTCFullYear() < 2050) {
+                            return ({ type: 'date', kind: 'utc', date: input });
+                        }
+                        else {
+                            return ({ type: 'date', kind: 'general', date: input });
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsBitString:
+                    if ((0, helper_1.isBuffer)(input)) {
+                        return ({ type: 'bitstring', value: input, unusedBits: 0 });
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsOID:
+                    if (typeof input === 'string') {
+                        return ({ type: 'oid', oid: input });
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+                case ValidateASN1.IsSet:
+                case ValidateASN1.IsAny:
+                case ValidateASN1.IsUnknown:
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    return input;
+            }
+        }
+        // Handle bigint schema (fixed value)
+        if (typeof schema === 'bigint') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return input;
+        }
+        // Default: return input as-is
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return input;
+    }
 }
 exports.ValidateASN1 = ValidateASN1;
 _ValidateASN1_schema = new WeakMap();
@@ -79134,7 +79766,7 @@ exports.Testing = { findRDN, blockHashesFromVote, feeFromVote };
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.version = void 0;
-exports.version = '0.14.11+gfb27e304d06f586fd5f3532fae4f1504a46d359b';
+exports.version = '0.14.13+g566b8de2c01660608e6eb5257113db271d7fc075';
 exports["default"] = exports.version;