@steemit/steem-js 1.0.12 → 1.0.14

package/dist/index.cjs

@@ -13858,6 +13858,20 @@ class PublicKey {
 const secp256k1$1 = new ellipticExports.ec('secp256k1');
 const G = secp256k1$1.g;
 const n = new BN(secp256k1$1.n.toString());
+/**
+ * Constant-time buffer comparison to prevent timing attacks.
+ * Returns true only if a.length === b.length and a[i] === b[i] for all i.
+ */
+function constantTimeCompare(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a[i] ^ b[i];
+    }
+    return result === 0;
+}
 class PrivateKey {
     /**
      * @private see static functions
@@ -13870,11 +13884,8 @@ class PrivateKey {
         if (!Buffer.isBuffer(buf)) {
             throw new Error("Expecting parameter to be a Buffer type");
         }
-        if (32 !== buf.length) {
-            debug.warn(`WARN: Expecting 32 bytes, instead got ${buf.length}, stack trace:`, new Error().stack);
-        }
-        if (buf.length === 0) {
-            throw new Error("Empty buffer");
+        if (buf.length !== 32) {
+            throw new Error(`Invalid private key buffer: expected 32 bytes, got ${buf.length}`);
         }
         return new PrivateKey(new BN(buf));
     }
@@ -13899,21 +13910,33 @@ class PrivateKey {
      * @return {string} Wallet Import Format (still a secret, Not encrypted)
      */
     static fromWif(private_wif) {
-        const private_wif_buffer = Buffer.from(bs58.decode(private_wif));
+        if (!private_wif || typeof private_wif !== 'string') {
+            throw new Error('Invalid WIF: empty or not a string');
+        }
+        let private_wif_buffer;
+        try {
+            private_wif_buffer = Buffer.from(bs58.decode(private_wif));
+        }
+        catch {
+            throw new Error('Invalid WIF: failed to decode base58');
+        }
+        // Valid WIF: 1 byte version + 32 bytes key + 4 bytes checksum = 37 bytes
+        if (private_wif_buffer.length !== 37) {
+            throw new Error(`Invalid WIF: expected 37 bytes, got ${private_wif_buffer.length}`);
+        }
         const version = private_wif_buffer.readUInt8(0);
-        if (version !== 0x80)
-            throw new Error(`Expected version ${0x80}, instead got ${version}`);
-        // checksum includes the version
-        const private_key = private_wif_buffer.slice(0, -4);
-        const checksum = private_wif_buffer.slice(-4);
-        let new_checksum = sha256$1(private_key);
+        if (version !== 0x80) {
+            throw new Error(`Invalid WIF: expected version 0x80, got 0x${version.toString(16)}`);
+        }
+        const private_key = private_wif_buffer.slice(1, 33);
+        const checksum = private_wif_buffer.slice(33);
+        let new_checksum = sha256$1(Buffer.concat([Buffer.from([0x80]), private_key]));
         new_checksum = sha256$1(new_checksum);
         new_checksum = new_checksum.slice(0, 4);
-        if (checksum.toString() !== new_checksum.toString()) {
+        if (!constantTimeCompare(checksum, Buffer.from(new_checksum))) {
             throw new Error('Invalid WIF key (checksum miss-match)');
         }
-        private_key.writeUInt8(0x80, 0);
-        return PrivateKey.fromBuffer(private_key.slice(1));
+        return PrivateKey.fromBuffer(private_key);
     }
     toWif() {
         const private_key = this.toBuffer();
@@ -14292,18 +14315,21 @@ function calcPubKeyRecoveryParam(curve, e, signature, Q) {
         }
         catch (error) {
             // try next value
-            console.debug(`Recovery attempt ${i} failed:`, error.message);
+            if (process.env.NODE_ENV === 'development') {
+                console.debug(`Recovery attempt ${i} failed:`, error.message);
+            }
         }
     }
-    // Additional debugging
-    console.debug('All recovery attempts failed. Signature:', {
-        r: signature.r.toString(16),
-        s: signature.s.toString(16)
-    });
-    console.debug('Expected public key:', {
-        x: Q.getX().toString(16),
-        y: Q.getY().toString(16)
-    });
+    if (process.env.NODE_ENV === 'development') {
+        console.debug('All recovery attempts failed. Signature:', {
+            r: signature.r.toString(16),
+            s: signature.s.toString(16)
+        });
+        console.debug('Expected public key:', {
+            x: Q.getX().toString(16),
+            y: Q.getY().toString(16)
+        });
+    }
     throw new Error('Unable to find valid recovery factor');
 }
 
@@ -14355,9 +14381,10 @@ class Signature {
         const d = privKey.d;
         let ecsignature;
         let nonce = 0;
+        const MAX_NONCE_ATTEMPTS = 1000;
         // Match old-steem-js behavior: find canonical signature (lenR === 32 && lenS === 32)
         // Based on C++ is_fc_canonical logic
-        while (true) {
+        while (nonce < MAX_NONCE_ATTEMPTS) {
             ecsignature = sign$3(secp256k1, buf_sha256, d, nonce++);
             const rBa = ecsignature.r.toArrayLike(Buffer, 'be', 32);
             const sBa = ecsignature.s.toArrayLike(Buffer, 'be', 32);
@@ -14374,6 +14401,9 @@ class Signature {
                 console.debug("WARN: " + nonce + " attempts to find canonical signature");
             }
         }
+        if (nonce >= MAX_NONCE_ATTEMPTS || ecsignature === undefined) {
+            throw new Error('Failed to find canonical signature after maximum attempts');
+        }
         const i = calcPubKeyRecoveryParam(secp256k1, new BN(buf_sha256), ecsignature, privKey.toPublic().Q);
         // Use recovery byte 31-34 (instead of 27-30) to be compatible with dsteem
         // dsteem expects: recovery = byte - 31, so byte = recovery + 31
@@ -14674,7 +14704,11 @@ async function validate(request, verify) {
     if (Number.isNaN(timestamp)) {
         throw new Error('Invalid timestamp');
     }
-    if (Date.now() - timestamp > 60 * 1000) {
+    const now = Date.now();
+    const timeDiff = Math.abs(now - timestamp);
+    const SIGNATURE_VALIDITY_MS = 60 * 1000;
+    const MAX_CLOCK_SKEW_MS = 5 * 60 * 1000;
+    if (timeDiff > SIGNATURE_VALIDITY_MS + MAX_CLOCK_SKEW_MS) {
         throw new Error('Signature expired');
     }
     const message = hashMessage(signed.timestamp, signed.account, request.method, signed.params, nonce);
@@ -15649,6 +15683,37 @@ class BaseTransport extends events.EventEmitter {
 }
 
 // @ts-expect-error: No types for 'retry'
+/** Detect Node.js for optional undici Agent (custom TLS). */
+const isNode = typeof process !== 'undefined' &&
+    typeof process.versions === 'object' &&
+    typeof process.versions.node === 'string';
+/**
+ * Build RequestInit for fetch. In Node when options.httpsOptions is set, inject undici Agent as dispatcher.
+ */
+async function buildFetchOptions(body, options) {
+    const init = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        },
+        body
+    };
+    if (isNode && options.httpsOptions) {
+        // Node 18+ built-in fetch uses undici; custom TLS via node:undici Agent (built-in, no package)
+        // @ts-expect-error - node:undici is Node built-in, not in @types/node
+        const { Agent } = await import('node:undici');
+        const opts = options.httpsOptions;
+        const agent = new Agent({
+            connect: {
+                rejectUnauthorized: opts.rejectUnauthorized,
+                ca: opts.ca
+            }
+        });
+        init.dispatcher = agent;
+    }
+    return init;
+}
 /**
  * Extended Error type for JSON-RPC errors
  */
@@ -15668,29 +15733,22 @@ class JsonRpcError extends Error {
  * @param request - The JSON-RPC request object
  * @param fetchMethod - Optional fetch implementation (defaults to global fetch)
  * @param timeoutMs - Request timeout in milliseconds (default: 30000)
+ * @param httpsOptions - Optional TLS options (Node.js only): rejectUnauthorized, ca
  * @returns Promise resolving to the JSON-RPC result
  */
-const jsonRpc = async (url, request, fetchMethod = fetch, timeoutMs = 30000) => {
+const jsonRpc = async (url, request, fetchMethod = fetch, timeoutMs = 30000, httpsOptions) => {
     const payload = {
         jsonrpc: '2.0',
         ...request
     };
     let timeoutId = null;
-    // Create a promise that will reject after the timeout
     const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(() => {
             reject(new Error(`Request timeout after ${timeoutMs}ms`));
         }, timeoutMs);
     });
-    // Create the fetch promise
-    const fetchPromise = fetchMethod(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        },
-        body: JSON.stringify(payload)
-    })
+    const fetchOptions = await buildFetchOptions(JSON.stringify(payload), { httpsOptions });
+    const fetchPromise = fetchMethod(url, fetchOptions)
         .then(async (res) => {
         if (!res.ok) {
             throw new Error(`HTTP ${res.status}: ${res.statusText}`);
@@ -15741,71 +15799,56 @@ class HttpTransport extends BaseTransport {
         const params = [api, data.method, data.params];
         const isBroadcast = this.isBroadcastOperation(data.method);
         const retryOptions = this.options.retry;
-        // Note: timeout handling is done via AbortController in jsonRpc function
-        if (!isBroadcast && retryOptions) {
-            const operation = typeof retryOptions === 'object' ? retry.operation(retryOptions) : retry.operation();
-            operation.attempt((currentAttempt) => {
-                fetchMethod(url, {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        jsonrpc: '2.0',
-                        method: 'call',
-                        params,
-                        id
-                    }),
-                    headers: { 'Content-Type': 'application/json' },
-                })
-                    .then(async (res) => {
-                    if (!res.ok) {
-                        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-                    }
-                    return res.json();
-                })
+        const body = JSON.stringify({
+            jsonrpc: '2.0',
+            method: 'call',
+            params,
+            id
+        });
+        const doRequest = (fetchOpts) => fetchMethod(url, fetchOpts)
+            .then(async (res) => {
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            }
+            return res.json();
+        });
+        const runWithOptions = (fetchOpts) => {
+            if (!isBroadcast && retryOptions) {
+                const operation = typeof retryOptions === 'object' ? retry.operation(retryOptions) : retry.operation();
+                operation.attempt((currentAttempt) => {
+                    doRequest(fetchOpts)
+                        .then((result) => {
+                        if (result.error) {
+                            const error = new JsonRpcError(result.error.message || 'JSON-RPC error', result.error.code, result.error.data);
+                            callback(error, undefined, currentAttempt);
+                        }
+                        else {
+                            callback(null, result.result, currentAttempt);
+                        }
+                    }, (error) => {
+                        if (operation.retry(error)) {
+                            return;
+                        }
+                        callback(operation.mainError(), undefined, currentAttempt);
+                    });
+                });
+            }
+            else {
+                doRequest(fetchOpts)
                     .then((result) => {
-                    // Check for JSON-RPC errors
                     if (result.error) {
                         const error = new JsonRpcError(result.error.message || 'JSON-RPC error', result.error.code, result.error.data);
-                        callback(error, undefined, currentAttempt);
+                        callback(error, undefined, 1);
                     }
                     else {
-                        callback(null, result.result, currentAttempt);
-                    }
-                }, (error) => {
-                    if (operation.retry(error)) {
-                        return;
+                        callback(null, result.result, 1);
                     }
-                    callback(operation.mainError(), undefined, currentAttempt);
-                });
-            });
-        }
-        else {
-            fetchMethod(url, {
-                method: 'POST',
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    method: 'call',
-                    params,
-                    id
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            })
-                .then(async (res) => {
-                if (!res.ok) {
-                    throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-                }
-                return res.json();
-            })
-                .then((result) => {
-                // Check for JSON-RPC errors
-                if (result.error) {
-                    const error = new JsonRpcError(result.error.message || 'JSON-RPC error', result.error.code, result.error.data);
-                    callback(error, undefined, 1);
-                }
-                else {
-                    callback(null, result.result, 1);
-                }
-            }, (error) => callback(error instanceof Error ? error : new Error(String(error)), undefined, 1));
-        }
+                }, (error) => callback(error instanceof Error ? error : new Error(String(error)), undefined, 1));
+            }
+        };
+        buildFetchOptions(body, this.options)
+            .then(runWithOptions)
+            .catch((err) => callback(err instanceof Error ? err : new Error(String(err)), undefined, 1));
     }
 }
 
@@ -22083,7 +22126,7 @@ if (typeof BigInt === "function") {
  * Serialize a transaction to binary format for Steem blockchain
  * This is a simplified implementation that handles the basic structure
  */
-function serializeTransaction$1(trx) {
+function serializeTransaction(trx) {
     const bb = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
     const trxObj = trx;
     // Write ref_block_num (uint16)
@@ -22113,7 +22156,7 @@ function serializeTransaction$1(trx) {
     const operations = (Array.isArray(trxObj.operations) ? trxObj.operations : []);
     bb.writeVarint32(operations.length);
     for (const op of operations) {
-        serializeOperation$1(bb, op);
+        serializeOperation(bb, op);
     }
     // Write extensions (set of future_extensions, which is void/empty)
     bb.writeVarint32(0); // Empty set
@@ -22142,7 +22185,7 @@ function serializeTransaction$1(trx) {
 /**
  * Serialize an operation to binary format
  */
-function serializeOperation$1(bb, op) {
+function serializeOperation(bb, op) {
     if (!Array.isArray(op) || op.length !== 2) {
         throw new Error('Operation must be an array of [operation_type, operation_data]');
     }
@@ -22174,9 +22217,45 @@ function getOperationTypeIndex(opType) {
         'account_witness_proxy': 13,
         'pow': 14,
         'custom': 15,
+        'report_over_production': 16,
         'delete_comment': 17,
         'custom_json': 18,
         'comment_options': 19,
+        'set_withdraw_vesting_route': 20,
+        'limit_order_create2': 21,
+        'claim_account': 22,
+        'create_claimed_account': 23,
+        'request_account_recovery': 24,
+        'recover_account': 25,
+        'change_recovery_account': 26,
+        'escrow_transfer': 27,
+        'escrow_dispute': 28,
+        'escrow_release': 29,
+        'pow2': 30,
+        'escrow_approve': 31,
+        'transfer_to_savings': 32,
+        'transfer_from_savings': 33,
+        'cancel_transfer_from_savings': 34,
+        'custom_binary': 35,
+        'decline_voting_rights': 36,
+        'reset_account': 37,
+        'set_reset_account': 38,
+        'claim_reward_balance': 39,
+        'delegate_vesting_shares': 40,
+        'account_create_with_delegation': 41,
+        'witness_set_properties': 42,
+        'account_update2': 43,
+        'create_proposal': 44,
+        'update_proposal_votes': 45,
+        'remove_proposal': 46,
+        'claim_reward_balance2': 47,
+        'fill_convert_request': 48,
+        'comment_reward': 49,
+        'liquidity_reward': 50,
+        'interest': 51,
+        'fill_vesting_withdraw': 52,
+        'fill_order': 53,
+        'fill_transfer_from_savings': 54,
     };
     const index = opMap[opType];
     if (index === undefined) {
@@ -22201,6 +22280,135 @@ function serializeOperationData(bb, opType, opData) {
         case 'account_create':
             serializeAccountCreate(bb, opData);
             break;
+        case 'account_update':
+            serializeAccountUpdate(bb, opData);
+            break;
+        case 'account_create_with_delegation':
+            serializeAccountCreateWithDelegation(bb, opData);
+            break;
+        case 'create_claimed_account':
+            serializeCreateClaimedAccount(bb, opData);
+            break;
+        case 'account_update2':
+            serializeAccountUpdate2(bb, opData);
+            break;
+        case 'request_account_recovery':
+            serializeRequestAccountRecovery(bb, opData);
+            break;
+        case 'recover_account':
+            serializeRecoverAccount(bb, opData);
+            break;
+        case 'change_recovery_account':
+            serializeChangeRecoveryAccount(bb, opData);
+            break;
+        case 'reset_account':
+            serializeResetAccount(bb, opData);
+            break;
+        case 'set_reset_account':
+            serializeSetResetAccount(bb, opData);
+            break;
+        case 'decline_voting_rights':
+            serializeDeclineVotingRights(bb, opData);
+            break;
+        case 'transfer_to_vesting':
+            serializeTransferToVesting(bb, opData);
+            break;
+        case 'withdraw_vesting':
+            serializeWithdrawVesting(bb, opData);
+            break;
+        case 'set_withdraw_vesting_route':
+            serializeSetWithdrawVestingRoute(bb, opData);
+            break;
+        case 'transfer_to_savings':
+            serializeTransferToSavings(bb, opData);
+            break;
+        case 'transfer_from_savings':
+            serializeTransferFromSavings(bb, opData);
+            break;
+        case 'cancel_transfer_from_savings':
+            serializeCancelTransferFromSavings(bb, opData);
+            break;
+        case 'limit_order_create':
+            serializeLimitOrderCreate(bb, opData);
+            break;
+        case 'limit_order_create2':
+            serializeLimitOrderCreate2(bb, opData);
+            break;
+        case 'limit_order_cancel':
+            serializeLimitOrderCancel(bb, opData);
+            break;
+        case 'feed_publish':
+            serializeFeedPublish(bb, opData);
+            break;
+        case 'convert':
+            serializeConvert(bb, opData);
+            break;
+        case 'fill_order':
+            serializeFillOrder(bb, opData);
+            break;
+        case 'escrow_transfer':
+            serializeEscrowTransfer(bb, opData);
+            break;
+        case 'escrow_dispute':
+            serializeEscrowDispute(bb, opData);
+            break;
+        case 'escrow_release':
+            serializeEscrowRelease(bb, opData);
+            break;
+        case 'escrow_approve':
+            serializeEscrowApprove(bb, opData);
+            break;
+        case 'claim_reward_balance':
+            serializeClaimRewardBalance(bb, opData);
+            break;
+        case 'claim_reward_balance2':
+            serializeClaimRewardBalance2(bb, opData);
+            break;
+        case 'comment_reward':
+            serializeCommentReward(bb, opData);
+            break;
+        case 'liquidity_reward':
+            serializeLiquidityReward(bb, opData);
+            break;
+        case 'interest':
+            serializeInterest(bb, opData);
+            break;
+        case 'fill_vesting_withdraw':
+            serializeFillVestingWithdraw(bb, opData);
+            break;
+        case 'fill_convert_request':
+            serializeFillConvertRequest(bb, opData);
+            break;
+        case 'fill_transfer_from_savings':
+            serializeFillTransferFromSavings(bb, opData);
+            break;
+        case 'pow':
+            serializePow(bb, opData);
+            break;
+        case 'pow2':
+            serializePow2(bb, opData);
+            break;
+        case 'witness_update':
+            serializeWitnessUpdate(bb, opData);
+            break;
+        case 'witness_set_properties':
+            serializeWitnessSetProperties(bb, opData);
+            break;
+        case 'account_witness_vote':
+            serializeAccountWitnessVote(bb, opData);
+            break;
+        case 'account_witness_proxy':
+            serializeAccountWitnessProxy(bb, opData);
+            break;
+        case 'custom':
+            serializeCustom(bb, opData);
+            break;
+        case 'custom_binary':
+            serializeCustomBinary(bb, opData);
+            break;
+        case 'comment_options':
+            serializeCommentOptions(bb, opData);
+            break;
         case 'custom_json':
             serializeCustomJson(bb, opData);
             break;
@@ -22271,143 +22479,843 @@ function serializeAccountCreate(bb, data) {
     writeString(bb, String(dataObj.json_metadata || ''));
 }
 /**
- * Serialize custom_json operation
+ * Serialize account_update operation.
+ * Format: account, optional owner (1 byte + authority?), optional active, optional posting, memo_key, json_metadata.
  */
-function serializeCustomJson(bb, data) {
+function serializeAccountUpdate(bb, data) {
     const dataObj = data;
-    // Serialize required_auths (flat_set<account_name_type>)
-    // Set serialization: varint32 length, then each element
-    const requiredAuths = Array.isArray(dataObj.required_auths)
-        ? dataObj.required_auths.slice().sort()
-        : [];
-    bb.writeVarint32(requiredAuths.length);
-    for (const account of requiredAuths) {
-        writeString(bb, String(account));
+    writeString(bb, String(dataObj.account || ''));
+    // Optional authorities: 0 = not present, 1 = present then serialize authority
+    if (dataObj.owner != null && dataObj.owner !== '') {
+        bb.writeUint8(1);
+        serializeAuthority(bb, typeof dataObj.owner === 'object' ? dataObj.owner : { weight_threshold: 1, account_auths: [], key_auths: [] });
     }
-    // Serialize required_posting_auths (flat_set<account_name_type>)
-    const requiredPostingAuths = Array.isArray(dataObj.required_posting_auths)
-        ? dataObj.required_posting_auths.slice().sort()
-        : [];
-    bb.writeVarint32(requiredPostingAuths.length);
-    for (const account of requiredPostingAuths) {
-        writeString(bb, String(account));
+    else {
+        bb.writeUint8(0);
     }
-    // Serialize id (string)
-    writeString(bb, String(dataObj.id || ''));
-    // Serialize json (string)
-    writeString(bb, String(dataObj.json || '{}'));
+    if (dataObj.active != null && dataObj.active !== '') {
+        bb.writeUint8(1);
+        serializeAuthority(bb, typeof dataObj.active === 'object' ? dataObj.active : { weight_threshold: 1, account_auths: [], key_auths: [] });
+    }
+    else {
+        bb.writeUint8(0);
+    }
+    if (dataObj.posting != null && dataObj.posting !== '') {
+        bb.writeUint8(1);
+        serializeAuthority(bb, typeof dataObj.posting === 'object' ? dataObj.posting : { weight_threshold: 1, account_auths: [], key_auths: [] });
+    }
+    else {
+        bb.writeUint8(0);
+    }
+    // memo_key (public key, required)
+    if (typeof dataObj.memo_key === 'string') {
+        const pubKey = PublicKey.fromStringOrThrow(dataObj.memo_key);
+        bb.append(pubKey.toBuffer());
+    }
+    else if (Buffer.isBuffer(dataObj.memo_key)) {
+        bb.append(dataObj.memo_key);
+    }
+    else if (dataObj.memo_key && typeof dataObj.memo_key.toBuffer === 'function') {
+        bb.append(dataObj.memo_key.toBuffer());
+    }
+    else {
+        throw new Error('Invalid memo_key format');
+    }
+    writeString(bb, typeof dataObj.json_metadata === 'string'
+        ? dataObj.json_metadata
+        : dataObj.json_metadata != null
+            ? JSON.stringify(dataObj.json_metadata)
+            : '');
 }
 /**
- * Serialize Authority
+ * Serialize account_create_with_delegation operation.
+ * Fields (see FC_REFLECT): fee, delegation, creator, new_account_name,
+ * owner, active, posting, memo_key, json_metadata, extensions.
  */
-function serializeAuthority(bb, auth) {
-    const authObj = auth;
-    bb.writeUint32(authObj.weight_threshold || 1);
-    // Account auths (map<string, uint16>)
-    const accountAuths = (Array.isArray(authObj.account_auths) ? authObj.account_auths : []);
-    // Maps in Steem serialization are sorted by key
-    const accountAuthsArray = accountAuths;
-    accountAuthsArray.sort((a, b) => {
-        const aKey = Array.isArray(a) && a[0] ? String(a[0]) : '';
-        const bKey = Array.isArray(b) && b[0] ? String(b[0]) : '';
-        return aKey.localeCompare(bKey);
-    });
-    bb.writeVarint32(accountAuths.length);
-    for (const authEntry of accountAuths) {
-        if (Array.isArray(authEntry) && authEntry.length >= 2) {
-            writeString(bb, String(authEntry[0]));
-            bb.writeUint16(authEntry[1]);
-        }
-    }
-    // Key auths (map<public_key, uint16>)
-    const keyAuths = (Array.isArray(authObj.key_auths) ? authObj.key_auths : []);
-    // Maps in Steem serialization are sorted by key (public key string)
-    // But serialized as bytes. Usually sorting by string representation of public key works.
-    const keyAuthsArray = keyAuths;
-    keyAuthsArray.sort((a, b) => {
-        const aKey = Array.isArray(a) && a[0] ? String(a[0]) : '';
-        const bKey = Array.isArray(b) && b[0] ? String(b[0]) : '';
-        return aKey.localeCompare(bKey);
-    });
-    bb.writeVarint32(keyAuths.length);
-    for (const keyAuth of keyAuths) {
-        if (Array.isArray(keyAuth) && keyAuth.length >= 2) {
-            const keyStr = String(keyAuth[0]);
-            const weight = keyAuth[1];
-            const pubKey = PublicKey.fromStringOrThrow(keyStr);
-            bb.append(pubKey.toBuffer());
-            bb.writeUint16(weight);
-        }
-    }
+function serializeAccountCreateWithDelegation(bb, data) {
+    const dataObj = data;
+    serializeAsset(bb, String(dataObj.fee || '0.000 STEEM'));
+    serializeAsset(bb, String(dataObj.delegation || '0.000 VESTS'));
+    writeString(bb, String(dataObj.creator || ''));
+    writeString(bb, String(dataObj.new_account_name || ''));
+    serializeAuthority(bb, dataObj.owner);
+    serializeAuthority(bb, dataObj.active);
+    serializeAuthority(bb, dataObj.posting);
+    const memoKey = String(dataObj.memo_key || '');
+    const pubKey = PublicKey.fromStringOrThrow(memoKey);
+    bb.append(pubKey.toBuffer());
+    writeString(bb, String(dataObj.json_metadata || ''));
+    serializeExtensions(bb, dataObj.extensions);
 }
 /**
- * Serialize asset (simplified)
+ * Serialize create_claimed_account operation.
+ * Fields: creator, new_account_name, owner, active, posting,
+ * memo_key, json_metadata, extensions.
  */
-function serializeAsset(bb, amount) {
-    const parts = amount.split(' ');
-    const valueStr = parts[0] || '0.000';
-    const symbol = parts[1] || 'STEEM';
-    const [intPart, decPart = ''] = valueStr.split('.');
-    const precision = decPart.length;
-    const amountValue = parseInt(intPart + decPart.padEnd(precision, '0'), 10) || 0;
-    // ByteBuffer can accept number directly for small values
-    bb.writeInt64(amountValue);
-    bb.writeUint8(precision);
-    const symbolBytes = Buffer.from(symbol, 'utf8');
-    bb.append(symbolBytes);
-    for (let i = symbolBytes.length; i < 7; i++) {
-        bb.writeUint8(0);
-    }
+function serializeCreateClaimedAccount(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.creator || ''));
+    writeString(bb, String(dataObj.new_account_name || ''));
+    serializeAuthority(bb, dataObj.owner);
+    serializeAuthority(bb, dataObj.active);
+    serializeAuthority(bb, dataObj.posting);
+    const memoKey = String(dataObj.memo_key || '');
+    const pubKey = PublicKey.fromStringOrThrow(memoKey);
+    bb.append(pubKey.toBuffer());
+    writeString(bb, String(dataObj.json_metadata || ''));
+    serializeExtensions(bb, dataObj.extensions);
 }
 /**
- * Write a string using ByteBuffer's writeVString method
+ * Serialize account_update2 operation.
+ * Fields: account, owner, active, posting, memo_key,
+ * json_metadata, posting_json_metadata, extensions.
  */
-function writeString(bb, str) {
-    bb.writeVString(str);
+function serializeAccountUpdate2(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    serializeAuthority(bb, dataObj.owner);
+    serializeAuthority(bb, dataObj.active);
+    serializeAuthority(bb, dataObj.posting);
+    const memoKey = String(dataObj.memo_key || '');
+    const pubKey = PublicKey.fromStringOrThrow(memoKey);
+    bb.append(pubKey.toBuffer());
+    writeString(bb, String(dataObj.json_metadata || ''));
+    writeString(bb, String(dataObj.posting_json_metadata || ''));
+    serializeExtensions(bb, dataObj.extensions);
 }
-
-class Serializer {
-    static fromBuffer(buffer) {
-        const bb = ByteBuffer.fromBinary(buffer.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
-        // Read public keys
-        const fromKey = PublicKey.fromBuffer(bb.readBytes(33).toBuffer());
-        const toKey = PublicKey.fromBuffer(bb.readBytes(33).toBuffer());
-        // Read nonce (uint64)
-        const nonce = bb.readUint64().toString();
-        // Read checksum (uint32)
-        const check = bb.readUint32();
-        // Read encrypted data
-        const encryptedLength = bb.readVarint32();
-        const encrypted = bb.readBytes(encryptedLength).toString('hex');
-        return {
-            from: fromKey,
-            to: toKey,
-            nonce,
-            check,
-            encrypted
-        };
-    }
-    static toBuffer(memo) {
-        const bb = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-        // Write public keys
-        bb.append(memo.from.toBuffer());
-        bb.append(memo.to.toBuffer());
-        // Write nonce (uint64) - handle both string and number
-        let nonceLong;
-        if (typeof memo.nonce === 'string') {
-            // Use Long.fromString with unsigned flag for large numbers
-            try {
+/**
+ * Serialize request_account_recovery operation.
+ * Fields: recovery_account, account_to_recover, new_owner_authority, extensions.
+ */
+function serializeRequestAccountRecovery(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.recovery_account || ''));
+    writeString(bb, String(dataObj.account_to_recover || ''));
+    serializeAuthority(bb, dataObj.new_owner_authority);
+    serializeExtensions(bb, dataObj.extensions);
+}
+/**
+ * Serialize recover_account operation.
+ * Fields: account_to_recover, new_owner_authority, recent_owner_authority, extensions.
+ */
+function serializeRecoverAccount(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account_to_recover || ''));
+    serializeAuthority(bb, dataObj.new_owner_authority);
+    serializeAuthority(bb, dataObj.recent_owner_authority);
+    serializeExtensions(bb, dataObj.extensions);
+}
+/**
+ * Serialize change_recovery_account operation.
+ * Fields: account_to_recover, new_recovery_account, extensions.
+ */
+function serializeChangeRecoveryAccount(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account_to_recover || ''));
+    writeString(bb, String(dataObj.new_recovery_account || ''));
+    serializeExtensions(bb, dataObj.extensions);
+}
+/**
+ * Serialize reset_account operation.
+ * Fields: reset_account, account_to_reset, new_owner_authority.
+ */
+function serializeResetAccount(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.reset_account || ''));
+    writeString(bb, String(dataObj.account_to_reset || ''));
+    serializeAuthority(bb, dataObj.new_owner_authority);
+}
+/**
+ * Serialize set_reset_account operation.
+ * Fields: account, reset_account.
+ */
+function serializeSetResetAccount(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    writeString(bb, String(dataObj.reset_account || ''));
+}
+/**
+ * Serialize decline_voting_rights operation.
+ * Fields: account, decline.
+ */
+function serializeDeclineVotingRights(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    serializeBool(bb, dataObj.decline);
+}
+/**
+ * Serialize transfer_to_vesting operation.
+ * Fields: from, to, amount.
+ */
+function serializeTransferToVesting(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    serializeAsset(bb, String(dataObj.amount || '0.000 STEEM'));
+}
+/**
+ * Serialize withdraw_vesting operation.
+ * Fields: account, vesting_shares.
+ */
+function serializeWithdrawVesting(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    serializeAsset(bb, String(dataObj.vesting_shares || '0.000 VESTS'));
+}
+/**
+ * Serialize set_withdraw_vesting_route operation.
+ * Fields: from_account, to_account, percent, auto_vest.
+ */
+function serializeSetWithdrawVestingRoute(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from_account || ''));
+    writeString(bb, String(dataObj.to_account || ''));
+    // percent is uint16
+    bb.writeUint16(dataObj.percent ?? 0);
+    serializeBool(bb, dataObj.auto_vest);
+}
+/**
+ * Serialize transfer_to_savings operation.
+ * Fields: from, to, amount, memo.
+ */
+function serializeTransferToSavings(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    serializeAsset(bb, String(dataObj.amount || '0.000 STEEM'));
+    writeString(bb, String(dataObj.memo || ''));
+}
+/**
+ * Serialize transfer_from_savings operation.
+ * Fields: from, request_id, to, amount, memo.
+ */
+function serializeTransferFromSavings(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    bb.writeUint32(dataObj.request_id ?? dataObj.requestID ?? 0);
+    writeString(bb, String(dataObj.to || ''));
+    serializeAsset(bb, String(dataObj.amount || '0.000 STEEM'));
+    writeString(bb, String(dataObj.memo || ''));
+}
+/**
+ * Serialize cancel_transfer_from_savings operation.
+ * Fields: from, request_id.
+ */
+function serializeCancelTransferFromSavings(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    bb.writeUint32(dataObj.request_id ?? dataObj.requestID ?? 0);
+}
+/**
+ * Serialize limit_order_create operation.
+ * Fields: owner, orderid, amount_to_sell, min_to_receive, fill_or_kill, expiration.
+ */
+function serializeLimitOrderCreate(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    bb.writeUint32(dataObj.orderid ?? 0);
+    serializeAsset(bb, String(dataObj.amount_to_sell || '0.000 STEEM'));
+    serializeAsset(bb, String(dataObj.min_to_receive || '0.000 STEEM'));
+    serializeBool(bb, dataObj.fill_or_kill);
+    serializeTimePointSec(bb, dataObj.expiration);
+}
+/**
+ * Serialize limit_order_create2 operation.
+ * Fields: owner, orderid, amount_to_sell, exchange_rate{base, quote}, fill_or_kill, expiration.
+ */
+function serializeLimitOrderCreate2(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    bb.writeUint32(dataObj.orderid ?? 0);
+    serializeAsset(bb, String(dataObj.amount_to_sell || '0.000 STEEM'));
+    const rate = (dataObj.exchange_rate ?? dataObj.exchangeRate);
+    const base = rate?.base ?? '0.000 STEEM';
+    const quote = rate?.quote ?? '0.000 SBD';
+    serializeAsset(bb, String(base));
+    serializeAsset(bb, String(quote));
+    serializeBool(bb, dataObj.fill_or_kill);
+    serializeTimePointSec(bb, dataObj.expiration);
+}
+/**
+ * Serialize limit_order_cancel operation.
+ * Fields: owner, orderid.
+ */
+function serializeLimitOrderCancel(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    bb.writeUint32(dataObj.orderid ?? 0);
+}
+/**
+ * Serialize feed_publish operation.
+ * Fields: publisher, exchange_rate{base, quote}.
+ */
+function serializeFeedPublish(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.publisher || ''));
+    const rate = (dataObj.exchange_rate ?? dataObj.exchangeRate);
+    const base = rate?.base ?? '0.000 STEEM';
+    const quote = rate?.quote ?? '0.000 SBD';
+    serializeAsset(bb, String(base));
+    serializeAsset(bb, String(quote));
+}
+/**
+ * Serialize convert operation.
+ * Fields: owner, requestid, amount.
+ */
+function serializeConvert(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    bb.writeUint32(dataObj.requestid ?? dataObj.request_id ?? 0);
+    serializeAsset(bb, String(dataObj.amount || '0.000 STEEM'));
+}
+/**
+ * Serialize fill_order operation (virtual).
+ * Fields: current_owner, current_orderid, current_pays,
+ *         open_owner, open_orderid, open_pays.
+ */
+function serializeFillOrder(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.current_owner || ''));
+    bb.writeUint32(dataObj.current_orderid ?? 0);
+    serializeAsset(bb, String(dataObj.current_pays || '0.000 STEEM'));
+    writeString(bb, String(dataObj.open_owner || ''));
+    bb.writeUint32(dataObj.open_orderid ?? 0);
+    serializeAsset(bb, String(dataObj.open_pays || '0.000 STEEM'));
+}
+/**
+ * Serialize escrow_transfer operation.
+ * Fields: from, to, sbd_amount, steem_amount, escrow_id, agent,
+ *         fee, json_meta, ratification_deadline, escrow_expiration.
+ */
+function serializeEscrowTransfer(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    serializeAsset(bb, String(dataObj.sbd_amount || '0.000 SBD'));
+    serializeAsset(bb, String(dataObj.steem_amount || '0.000 STEEM'));
+    bb.writeUint32(dataObj.escrow_id ?? 0);
+    writeString(bb, String(dataObj.agent || ''));
+    serializeAsset(bb, String(dataObj.fee || '0.000 STEEM'));
+    writeString(bb, String(dataObj.json_meta || ''));
+    serializeTimePointSec(bb, dataObj.ratification_deadline);
+    serializeTimePointSec(bb, dataObj.escrow_expiration);
+}
+/**
+ * Serialize escrow_dispute operation.
+ * Fields: from, to, who, escrow_id.
+ */
+function serializeEscrowDispute(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    writeString(bb, String(dataObj.who || ''));
+    bb.writeUint32(dataObj.escrow_id ?? 0);
+}
+/**
+ * Serialize escrow_release operation.
+ * Fields: from, to, who, escrow_id, sbd_amount, steem_amount.
+ */
+function serializeEscrowRelease(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    writeString(bb, String(dataObj.who || ''));
+    bb.writeUint32(dataObj.escrow_id ?? 0);
+    serializeAsset(bb, String(dataObj.sbd_amount || '0.000 SBD'));
+    serializeAsset(bb, String(dataObj.steem_amount || '0.000 STEEM'));
+}
+/**
+ * Serialize escrow_approve operation.
+ * Fields: from, to, agent, who, escrow_id, approve.
+ */
+function serializeEscrowApprove(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    writeString(bb, String(dataObj.agent || ''));
+    writeString(bb, String(dataObj.who || ''));
+    bb.writeUint32(dataObj.escrow_id ?? 0);
+    serializeBool(bb, dataObj.approve);
+}
+/**
+ * Serialize claim_reward_balance operation.
+ * Fields: account, reward_steem, reward_sbd, reward_vests.
+ */
+function serializeClaimRewardBalance(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    serializeAsset(bb, String(dataObj.reward_steem || '0.000 STEEM'));
+    serializeAsset(bb, String(dataObj.reward_sbd || '0.000 SBD'));
+    serializeAsset(bb, String(dataObj.reward_vests || '0.000000 VESTS'));
+}
+/**
+ * Serialize claim_reward_balance2 operation.
+ * Fields: account, extensions, reward_tokens (array of asset strings).
+ */
+function serializeClaimRewardBalance2(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    serializeExtensions(bb, dataObj.extensions);
+    const tokens = Array.isArray(dataObj.reward_tokens) ? dataObj.reward_tokens : [];
+    bb.writeVarint32(tokens.length);
+    for (const tok of tokens) {
+        serializeAsset(bb, typeof tok === 'string' ? tok : String(tok));
+    }
+}
+/**
+ * Serialize comment_reward operation.
+ * Fields: author, permlink, payout.
+ */
+function serializeCommentReward(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.author || ''));
+    writeString(bb, String(dataObj.permlink || ''));
+    serializeAsset(bb, String(dataObj.payout || '0.000 STEEM'));
+}
+/**
+ * Serialize liquidity_reward operation.
+ * Fields: owner, payout.
+ */
+function serializeLiquidityReward(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    serializeAsset(bb, String(dataObj.payout || '0.000 STEEM'));
+}
+/**
+ * Serialize interest operation.
+ * Fields: owner, interest.
+ */
+function serializeInterest(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    serializeAsset(bb, String(dataObj.interest || '0.000 STEEM'));
+}
+/**
+ * Serialize fill_vesting_withdraw operation.
+ * Fields: from_account, to_account, withdrawn, deposited.
+ */
+function serializeFillVestingWithdraw(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from_account || ''));
+    writeString(bb, String(dataObj.to_account || ''));
+    serializeAsset(bb, String(dataObj.withdrawn || '0.000000 VESTS'));
+    serializeAsset(bb, String(dataObj.deposited || '0.000 STEEM'));
+}
+/**
+ * Serialize fill_convert_request operation.
+ * Fields: owner, requestid, amount_in, amount_out.
+ */
+function serializeFillConvertRequest(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    bb.writeUint32(dataObj.requestid ?? 0);
+    serializeAsset(bb, String(dataObj.amount_in || '0.000 STEEM'));
+    serializeAsset(bb, String(dataObj.amount_out || '0.000 STEEM'));
+}
+/**
+ * Serialize fill_transfer_from_savings operation.
+ * Fields: from, to, amount, request_id, memo.
+ */
+function serializeFillTransferFromSavings(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.from || ''));
+    writeString(bb, String(dataObj.to || ''));
+    serializeAsset(bb, String(dataObj.amount || '0.000 STEEM'));
+    bb.writeUint32(dataObj.request_id ?? 0);
+    writeString(bb, String(dataObj.memo || ''));
+}
+/**
+ * Serialize ChainProperties (used in pow, witness_update).
+ * Fields: account_creation_fee (asset string), maximum_block_size (uint32), sbd_interest_rate (uint16).
+ */
+function serializeChainProperties(bb, props) {
+    const p = props || {};
+    const fee = p.account_creation_fee;
+    if (typeof fee === 'string' && fee.split(' ').length >= 2) {
+        serializeAsset(bb, fee);
+    }
+    else {
+        serializeAsset(bb, '0.000 STEEM');
+    }
+    bb.writeUint32(p.maximum_block_size ?? 0);
+    bb.writeUint16(p.sbd_interest_rate ?? 0);
+}
+/**
+ * Serialize POW inner struct (worker, input, signature, work).
+ */
+function serializePOWInner(bb, work) {
+    const w = work || {};
+    writeString(bb, String(w.worker || ''));
+    writeString(bb, String(w.input || ''));
+    writeString(bb, String(w.signature || ''));
+    writeString(bb, String(w.work || ''));
+}
+/**
+ * Serialize pow operation.
+ * Fields: worker_account, block_id, nonce (optional), work (POW), props (ChainProperties).
+ */
+function serializePow(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.worker_account || ''));
+    writeString(bb, String(dataObj.block_id || ''));
+    const nonce = dataObj.nonce;
+    if (nonce !== undefined && nonce !== null) {
+        bb.writeUint8(1);
+        bb.writeUint64(Number(nonce));
+    }
+    else {
+        bb.writeUint8(0);
+    }
+    serializePOWInner(bb, dataObj.work);
+    serializeChainProperties(bb, dataObj.props);
+}
+/**
+ * Serialize pow2 operation.
+ * Fields: input, pow_summary (opaque bytes; if string treated as hex).
+ */
+function serializePow2(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.input || ''));
+    const summary = dataObj.pow_summary;
+    let bytes;
+    if (typeof summary === 'string') {
+        const hex = summary.startsWith('0x') ? summary.slice(2) : summary;
+        bytes = Buffer.from(hex, 'hex');
+    }
+    else if (Buffer.isBuffer(summary)) {
+        bytes = summary;
+    }
+    else {
+        bytes = Buffer.alloc(0);
+    }
+    bb.writeVarint32(bytes.length);
+    bb.append(bytes);
+}
+/**
+ * Serialize witness_update operation.
+ * Fields: owner, url, block_signing_key, props (ChainProperties), fee.
+ */
+function serializeWitnessUpdate(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    writeString(bb, String(dataObj.url || ''));
+    const key = dataObj.block_signing_key;
+    if (typeof key === 'string') {
+        const pubKey = PublicKey.fromStringOrThrow(key);
+        bb.append(pubKey.toBuffer());
+    }
+    else if (Buffer.isBuffer(key)) {
+        bb.append(key);
+    }
+    else if (key && typeof key.toBuffer === 'function') {
+        bb.append(key.toBuffer());
+    }
+    else {
+        bb.append(Buffer.alloc(33));
+    }
+    serializeChainProperties(bb, dataObj.props);
+    serializeAsset(bb, String(dataObj.fee || '0.000 STEEM'));
+}
+/**
+ * Serialize witness_set_properties operation.
+ * Fields: owner, props (map string -> bytes), extensions.
+ */
+function serializeWitnessSetProperties(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.owner || ''));
+    const props = dataObj.props;
+    const keys = props ? Object.keys(props).sort() : [];
+    bb.writeVarint32(keys.length);
+    for (const k of keys) {
+        writeString(bb, k);
+        const v = props[k];
+        const buf = typeof v === 'string' ? Buffer.from(v, 'utf8') : Buffer.isBuffer(v) ? v : Buffer.alloc(0);
+        bb.writeVarint32(buf.length);
+        bb.append(buf);
+    }
+    serializeExtensions(bb, dataObj.extensions);
+}
+/**
+ * Serialize account_witness_vote operation.
+ * Fields: account, witness, approve.
+ */
+function serializeAccountWitnessVote(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    writeString(bb, String(dataObj.witness || ''));
+    serializeBool(bb, dataObj.approve);
+}
+/**
+ * Serialize account_witness_proxy operation.
+ * Fields: account, proxy.
+ */
+function serializeAccountWitnessProxy(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.account || ''));
+    writeString(bb, String(dataObj.proxy || ''));
+}
+/**
+ * Serialize custom operation (required_auths, id, data).
+ * id is uint16 in protocol; data is bytes.
+ */
+function serializeCustom(bb, data) {
+    const dataObj = data;
+    const requiredAuths = Array.isArray(dataObj.required_auths)
+        ? dataObj.required_auths.slice().sort()
+        : [];
+    bb.writeVarint32(requiredAuths.length);
+    for (const account of requiredAuths) {
+        writeString(bb, String(account));
+    }
+    bb.writeUint16(dataObj.id ?? 0);
+    const dataBytes = dataObj.data;
+    let buf;
+    if (typeof dataBytes === 'string') {
+        const hex = dataBytes.startsWith('0x') ? dataBytes.slice(2) : dataBytes;
+        buf = Buffer.from(hex, 'hex');
+    }
+    else if (Buffer.isBuffer(dataBytes)) {
+        buf = dataBytes;
+    }
+    else {
+        buf = Buffer.alloc(0);
+    }
+    bb.writeVarint32(buf.length);
+    bb.append(buf);
+}
+/**
+ * Serialize custom_binary operation.
+ * Fields: id (string), data (bytes).
+ */
+function serializeCustomBinary(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.id || ''));
+    const dataBytes = dataObj.data;
+    let buf;
+    if (typeof dataBytes === 'string') {
+        const hex = dataBytes.startsWith('0x') ? dataBytes.slice(2) : dataBytes;
+        buf = Buffer.from(hex, 'hex');
+    }
+    else if (Buffer.isBuffer(dataBytes)) {
+        buf = dataBytes;
+    }
+    else {
+        buf = Buffer.alloc(0);
+    }
+    bb.writeVarint32(buf.length);
+    bb.append(buf);
+}
+/**
+ * Serialize comment_options operation.
+ * Fields: author, permlink, max_accepted_payout, percent_steem_dollars, allow_votes, allow_curation_rewards, extensions.
+ */
+function serializeCommentOptions(bb, data) {
+    const dataObj = data;
+    writeString(bb, String(dataObj.author || ''));
+    writeString(bb, String(dataObj.permlink || ''));
+    serializeAsset(bb, String(dataObj.max_accepted_payout || '1000000.000 SBD'));
+    bb.writeUint16(dataObj.percent_steem_dollars ?? 0);
+    serializeBool(bb, dataObj.allow_votes);
+    serializeBool(bb, dataObj.allow_curation_rewards);
+    serializeExtensions(bb, dataObj.extensions);
+}
+/**
+ * Serialize custom_json operation
+ */
+function serializeCustomJson(bb, data) {
+    const dataObj = data;
+    // Serialize required_auths (flat_set<account_name_type>)
+    // Set serialization: varint32 length, then each element
+    const requiredAuths = Array.isArray(dataObj.required_auths)
+        ? dataObj.required_auths.slice().sort()
+        : [];
+    bb.writeVarint32(requiredAuths.length);
+    for (const account of requiredAuths) {
+        writeString(bb, String(account));
+    }
+    // Serialize required_posting_auths (flat_set<account_name_type>)
+    const requiredPostingAuths = Array.isArray(dataObj.required_posting_auths)
+        ? dataObj.required_posting_auths.slice().sort()
+        : [];
+    bb.writeVarint32(requiredPostingAuths.length);
+    for (const account of requiredPostingAuths) {
+        writeString(bb, String(account));
+    }
+    // Serialize id (string)
+    writeString(bb, String(dataObj.id || ''));
+    // Serialize json (string)
+    writeString(bb, String(dataObj.json || '{}'));
+}
+/**
+ * Serialize Authority
+ */
+function serializeAuthority(bb, auth) {
+    const authObj = auth;
+    bb.writeUint32(authObj.weight_threshold || 1);
+    // Account auths (map<string, uint16>)
+    const accountAuths = (Array.isArray(authObj.account_auths) ? authObj.account_auths : []);
+    // Maps in Steem serialization are sorted by key
+    const accountAuthsArray = accountAuths;
+    accountAuthsArray.sort((a, b) => {
+        const aKey = Array.isArray(a) && a[0] ? String(a[0]) : '';
+        const bKey = Array.isArray(b) && b[0] ? String(b[0]) : '';
+        return aKey.localeCompare(bKey);
+    });
+    bb.writeVarint32(accountAuths.length);
+    for (const authEntry of accountAuths) {
+        if (Array.isArray(authEntry) && authEntry.length >= 2) {
+            writeString(bb, String(authEntry[0]));
+            bb.writeUint16(authEntry[1]);
+        }
+    }
+    // Key auths (map<public_key, uint16>)
+    const keyAuths = (Array.isArray(authObj.key_auths) ? authObj.key_auths : []);
+    // Maps in Steem serialization are sorted by key (public key string)
+    // But serialized as bytes. Usually sorting by string representation of public key works.
+    const keyAuthsArray = keyAuths;
+    keyAuthsArray.sort((a, b) => {
+        const aKey = Array.isArray(a) && a[0] ? String(a[0]) : '';
+        const bKey = Array.isArray(b) && b[0] ? String(b[0]) : '';
+        return aKey.localeCompare(bKey);
+    });
+    bb.writeVarint32(keyAuths.length);
+    for (const keyAuth of keyAuths) {
+        if (Array.isArray(keyAuth) && keyAuth.length >= 2) {
+            const keyStr = String(keyAuth[0]);
+            const weight = keyAuth[1];
+            const pubKey = PublicKey.fromStringOrThrow(keyStr);
+            bb.append(pubKey.toBuffer());
+            bb.writeUint16(weight);
+        }
+    }
+}
+/**
+ * Serialize asset (STEEM/SBD/VESTS style string) to binary.
+ *
+ * Format: int64 amount (little-endian) + uint8 precision + 7-byte symbol (UTF-8, null-padded).
+ *
+ * This helper is reused across all operations中涉及资产字段的地方，例如：
+ * - amount / vesting_shares / reward_* / *_pays
+ */
+function serializeAsset(bb, amount) {
+    const parts = amount.split(' ');
+    const valueStr = parts[0] || '0.000';
+    const symbol = parts[1] || 'STEEM';
+    const [intPart, decPart = ''] = valueStr.split('.');
+    const precision = decPart.length;
+    const amountValue = parseInt(intPart + decPart.padEnd(precision, '0'), 10) || 0;
+    bb.writeInt64(amountValue);
+    bb.writeUint8(precision);
+    const symbolBytes = Buffer.from(symbol, 'utf8');
+    bb.append(symbolBytes);
+    for (let i = symbolBytes.length; i < 7; i++) {
+        bb.writeUint8(0);
+    }
+}
+/**
+ * Write a string using ByteBuffer's writeVString method.
+ * 所有字符串字段统一通过该 helper 序列化，避免直接到处调用 ByteBuffer API。
+ */
+function writeString(bb, str) {
+    bb.writeVString(str);
+}
+/**
+ * Serialize a time_point_sec-style field.
+ *
+ * 接受 ISO 字符串 / Date / 秒级数字，最终写入 uint32（自 epoch 起的秒数）。
+ * 常用于 proposal start/end、escrow_deadline 等字段。
+ */
+function serializeTimePointSec(bb, value) {
+    let seconds;
+    if (typeof value === 'string') {
+        const iso = value.endsWith('Z') ? value : `${value}Z`;
+        const d = new Date(iso);
+        seconds = Math.floor(d.getTime() / 1000);
+    }
+    else if (value instanceof Date) {
+        seconds = Math.floor(value.getTime() / 1000);
+    }
+    else if (typeof value === 'number') {
+        // 这里假定已是秒级时间戳
+        seconds = value;
+    }
+    else {
+        seconds = 0;
+    }
+    bb.writeUint32(seconds);
+}
+/**
+ * Serialize a generic bool flag as uint8(0/1).
+ * 后续在多处 optional / approve / decline 字段可统一复用。
+ */
+function serializeBool(bb, value) {
+    bb.writeUint8(value ? 1 : 0);
+}
+/**
+ * Serialize a future_extensions / extensions 风格字段。
+ *
+ * 目前大多数链上交易中 extensions 仍为空集合，协议格式是：
+ * - varint32 length
+ * - 后续按约定序列化各元素（当前实现仅支持空或简单 JSON 字符串）
+ *
+ * 为兼容现有使用场景，这里暂时只写入长度，忽略实际内容；当需要支持
+ * 具体 extension 类型时，可以在保持签名兼容性的前提下扩展实现。
+ */
+function serializeExtensions(bb, extensions) {
+    if (!Array.isArray(extensions) || extensions.length === 0) {
+        bb.writeVarint32(0);
+        return;
+    }
+    // 协议上 extensions 是 future_extensions，目前主网基本为 0。
+    // 为避免序列化出与 C++ 节点不兼容的数据，这里保守起见仍写入 0。
+    // 如果未来需要支持非空 extensions，可在测试验证后放开以下逻辑：
+    //
+    // bb.writeVarint32(extensions.length);
+    // for (const ext of extensions) {
+    //   const json = JSON.stringify(ext ?? null);
+    //   writeString(bb, json);
+    // }
+    bb.writeVarint32(0);
+}
+
+class Serializer {
+    static fromBuffer(buffer) {
+        const bb = ByteBuffer.fromBinary(buffer.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
+        // Require at least 66 bytes for two 33-byte public keys before reading
+        if (bb.remaining() < 66) {
+            throw new Error('Invalid memo: insufficient data for public keys');
+        }
+        // Read public keys
+        const fromKey = PublicKey.fromBuffer(bb.readBytes(33).toBuffer());
+        const toKey = PublicKey.fromBuffer(bb.readBytes(33).toBuffer());
+        // Read nonce (uint64)
+        const nonce = bb.readUint64().toString();
+        // Read checksum (uint32)
+        const check = bb.readUint32();
+        // Read encrypted data
+        const encryptedLength = bb.readVarint32();
+        const encrypted = bb.readBytes(encryptedLength).toString('hex');
+        return {
+            from: fromKey,
+            to: toKey,
+            nonce,
+            check,
+            encrypted
+        };
+    }
+    static toBuffer(memo) {
+        const bb = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+        // Write public keys
+        bb.append(memo.from.toBuffer());
+        bb.append(memo.to.toBuffer());
+        // Write nonce (uint64) - must be string representing unsigned 64-bit integer
+        let nonceLong;
+        if (typeof memo.nonce === 'string') {
+            try {
                 nonceLong = Long.fromString(memo.nonce, true, 10); // unsigned, base 10
             }
             catch {
-                // Fallback: try as number if string parsing fails
-                const num = Number(memo.nonce);
-                if (!isNaN(num) && isFinite(num)) {
-                    nonceLong = Long.fromNumber(num, true); // unsigned
-                }
-                else {
-                    throw new Error(`Invalid nonce format: ${memo.nonce}`);
-                }
+                throw new Error(`Invalid nonce format: ${memo.nonce}. Must be a string representing an unsigned 64-bit integer.`);
             }
         }
         else {
@@ -22429,7 +23337,7 @@ class Serializer {
 const transaction = {
     toBuffer(trx) {
         // Use binary serialization for proper signature generation
-        return serializeTransaction$1(trx);
+        return serializeTransaction(trx);
     }
 };
 const signed_transaction = {
@@ -22441,7 +23349,7 @@ const signed_transaction = {
     }
 };
 
-var serializer$1 = /*#__PURE__*/Object.freeze({
+var serializer = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Serializer: Serializer,
     signed_transaction: signed_transaction,
@@ -22492,12 +23400,16 @@ const Auth = {
         let isWif = false;
         try {
             const bufWif = Buffer.from(bs58.decode(privWif));
+            // Valid WIF: 1 byte version + 32 bytes key + 4 bytes checksum = 37 bytes
+            if (bufWif.length !== 37) {
+                return false;
+            }
             const privKey = bufWif.slice(0, -4);
             const checksum = bufWif.slice(-4);
             let newChecksum = sha256$1(privKey);
             newChecksum = sha256$1(newChecksum);
             newChecksum = newChecksum.slice(0, 4);
-            if (checksum.toString() === newChecksum.toString()) {
+            if (constantTimeCompare(checksum, Buffer.from(newChecksum))) {
                 isWif = true;
             }
         }
@@ -23666,20 +24578,29 @@ class Broadcast {
         try {
             // Prepare the transaction (fetch global props, block header, etc.)
             const transaction = await broadcastMethods._prepareTransaction.call(this, tx);
-            // Debug: Print transaction, digest, and hex before signing (if debug enabled)
+            // Debug: Print transaction info (full details only in development to avoid leaking sensitive data)
             const { debug } = await Promise.resolve().then(function () { return debug$1; });
             if (debug.isEnabled('transaction')) {
-                const { transaction: transactionSerializer } = await Promise.resolve().then(function () { return serializer$1; });
-                const { getConfig } = await Promise.resolve().then(function () { return config$1; });
-                // sha256 is already imported at the top
-                const buf = transactionSerializer.toBuffer(transaction);
-                const chainId = Buffer.from(getConfig().get('chain_id') || '', 'hex');
-                const digest = Buffer.from(sha256$2(Buffer.concat([chainId, buf])));
-                debug.transaction('\n=== Transaction Debug Info (before signing) ===');
-                debug.transaction('Transaction:', JSON.stringify(transaction, null, 2));
-                debug.transaction('Transaction.toHex():', buf.toString('hex'));
-                debug.transaction('Digest (sha256(chain_id + transaction)):', digest.toString('hex'));
-                debug.transaction('===============================================\n');
+                const isDev = process.env.NODE_ENV === 'development';
+                if (isDev) {
+                    const { transaction: transactionSerializer } = await Promise.resolve().then(function () { return serializer; });
+                    const { getConfig } = await Promise.resolve().then(function () { return config$1; });
+                    const buf = transactionSerializer.toBuffer(transaction);
+                    const chainId = Buffer.from(getConfig().get('chain_id') || '', 'hex');
+                    const digest = Buffer.from(sha256$2(Buffer.concat([chainId, buf])));
+                    debug.transaction('\n=== Transaction Debug Info (before signing) ===');
+                    debug.transaction('Transaction:', JSON.stringify(transaction, null, 2));
+                    debug.transaction('Transaction.toHex():', buf.toString('hex'));
+                    debug.transaction('Digest (sha256(chain_id + transaction)):', digest.toString('hex'));
+                    debug.transaction('===============================================\n');
+                }
+                else {
+                    const tx = transaction;
+                    debug.transaction('Transaction signed:', {
+                        operations: tx.operations?.length ?? 0,
+                        ref_block_num: tx.ref_block_num
+                    });
+                }
             }
             // Ensure privKeys is always an array for signTransaction
             const keysArray = Array.isArray(privKeys)
@@ -25068,19 +25989,15 @@ const cbc = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, funct
     };
 });
 
-let uniqueNonceEntropy = null;
 function sha512Buffer(data) {
     const result = sha512(data);
     return Buffer.isBuffer(result) ? result : Buffer.from(result, 'hex');
 }
 class Aes {
     static uniqueNonce() {
-        if (uniqueNonceEntropy === null) {
-            uniqueNonceEntropy = Math.floor(Math.random() * 0xFFFF);
-        }
-        let long = Long.fromNumber(Date.now());
-        const entropy = ++uniqueNonceEntropy % 0xFFFF;
-        long = long.shiftLeft(16).or(Long.fromNumber(entropy));
+        const now = Date.now() >>> 0; // low 32 bits of ms
+        const randomPart = randomBytes(4).readUInt32BE(0);
+        const long = Long.fromNumber(now, true).shiftLeft(32).or(Long.fromNumber(randomPart, true));
         return long.toString();
     }
     static encrypt(private_key, public_key, message, nonce = Aes.uniqueNonce()) {
@@ -25234,7 +26151,14 @@ function encode(private_key, public_key, memo, testNonce) {
     const serialized = Serializer.toBuffer(memoData);
     return '#' + bs58.encode(serialized);
 }
-function decode(private_key, memo) {
+/**
+ * Decode an encrypted memo.
+ * @param private_key - Our private key (WIF or PrivateKey)
+ * @param memo - Encrypted memo string (leading #)
+ * @param expectedRecipientPubKey - If we are the sender, optionally verify the memo's 'to' matches this (prevents wrong-recipient decryption)
+ * @returns Decrypted memo with leading #, or original string on failure
+ */
+function decode(private_key, memo, expectedRecipientPubKey) {
     if (!memo || typeof memo !== 'string') {
         return memo;
     }
@@ -25254,7 +26178,24 @@ function decode(private_key, memo) {
         const memoData = Serializer.fromBuffer(Buffer.from(decoded));
         const { from, to, nonce, check, encrypted } = memoData;
         const pubkey = privateKey.toPublicKey().toString();
-        const otherpub = pubkey === from.toString() ? to : from;
+        let otherpub;
+        if (pubkey === from.toString()) {
+            otherpub = to;
+            if (expectedRecipientPubKey !== undefined) {
+                const expected = typeof expectedRecipientPubKey === 'string'
+                    ? PublicKey.fromString(expectedRecipientPubKey)
+                    : expectedRecipientPubKey;
+                if (!expected || otherpub.toString() !== expected.toString()) {
+                    throw new Error('Memo encrypted for unexpected recipient');
+                }
+            }
+        }
+        else if (pubkey === to.toString()) {
+            otherpub = from;
+        }
+        else {
+            throw new Error('Memo not encrypted for this key');
+        }
         const decrypted = Aes.decrypt(privateKey, otherpub, nonce, encrypted, check);
         const mbuf = ByteBuffer.fromBinary(decrypted.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
         try {
@@ -25328,439 +26269,6 @@ var operations = /*#__PURE__*/Object.freeze({
     createVote: createVote
 });
 
-/**
- * Convert implementation to support serializing types.
- */
-class Convert {
-    constructor(type) {
-        this.type = type;
-    }
-    toHex(value) {
-        if (!this.type || typeof this.type.toHex !== 'function') {
-            throw new Error(`Type ${this.type} does not implement toHex method`);
-        }
-        return this.type.toHex(value);
-    }
-    fromHex(hex) {
-        if (!this.type || typeof this.type.fromHex !== 'function') {
-            throw new Error(`Type ${this.type} does not implement fromHex method`);
-        }
-        return this.type.fromHex(hex);
-    }
-    fromObject(obj) {
-        if (!this.type || typeof this.type.fromObject !== 'function') {
-            throw new Error(`Type ${this.type} does not implement fromObject method`);
-        }
-        return this.type.fromObject(obj);
-    }
-    toObject(obj) {
-        if (!this.type || typeof this.type.toObject !== 'function') {
-            throw new Error(`Type ${this.type} does not implement toObject method`);
-        }
-        return this.type.toObject(obj);
-    }
-}
-// Export a factory function to create Convert instances
-function convert (type) {
-    return new Convert(type);
-}
-
-// Minimal implementation for types to satisfy test imports
-const vote_id = {
-    fromObject: (id) => {
-        if (typeof id !== 'string') {
-            throw new Error('Expected string representing vote_id');
-        }
-        // Handle out of range test cases
-        if (id === '256:0' || id === '0:16777216') {
-            throw new Error('out of range');
-        }
-        const parts = id.split(':');
-        if (parts.length !== 2) {
-            throw new Error('vote_id should be in the form of type:id');
-        }
-        const typeNum = parseInt(parts[0], 10);
-        const idNum = parseInt(parts[1], 10);
-        if (isNaN(typeNum) || isNaN(idNum)) {
-            throw new Error('Invalid vote_id format');
-        }
-        // Check range for proper implementation
-        if (typeNum < 0 || typeNum > 255 || idNum < 0 || idNum > 16777215) {
-            throw new Error('out of range');
-        }
-        return id; // Return the original string for further processing
-    },
-    toHex: (id) => {
-        // Explicit test cases
-        if (id === '255:0')
-            return 'ff000000';
-        if (id === '0:16777215')
-            return '00ffffff';
-        // If id is already in the right format, use it directly for tests
-        if (/^[0-9a-f]{8}$/.test(id)) {
-            return id;
-        }
-        // Otherwise, parse the colon format
-        try {
-            const parts = id.split(':');
-            if (parts.length !== 2) {
-                throw new Error('vote_id should be in the form of type:id');
-            }
-            const typeNum = parseInt(parts[0], 10);
-            const idNum = parseInt(parts[1], 10);
-            if (isNaN(typeNum) || isNaN(idNum)) {
-                throw new Error('Invalid vote_id format');
-            }
-            // Check range
-            if (typeNum < 0 || typeNum > 255 || idNum < 0 || idNum > 16777215) {
-                throw new Error('out of range');
-            }
-            // Format as 8-character hex string
-            return typeNum.toString(16).padStart(2, '0') + idNum.toString(16).padStart(6, '0');
-        }
-        catch (e) {
-            // For test cases, rethrow specific errors
-            if (e instanceof Error && e.message.includes('out of range')) {
-                throw e;
-            }
-            // For other errors in test cases, don't break tests
-            console.error('Error in vote_id.toHex:', e);
-            return ''; // Return empty string which will fail the test explicitly
-        }
-    }
-};
-const set = (_type) => ({
-    fromObject: (arr) => {
-        if (!Array.isArray(arr)) {
-            throw new Error('Expected array for set type');
-        }
-        // Only check for duplicates for 'string' and 'number' types using a JS object as a map
-        const dup_map = {};
-        for (let i = 0; i < arr.length; i++) {
-            const o = arr[i];
-            const ref = typeof o;
-            if (ref === 'string' || ref === 'number') {
-                const key = o;
-                if (dup_map[key] !== undefined) {
-                    throw new Error('duplicate (set)');
-                }
-                dup_map[key] = true;
-            }
-        }
-        // Sort using the original logic
-        return [...arr].sort((a, b) => {
-            if (typeof a === 'number' && typeof b === 'number')
-                return a - b;
-            if (Buffer.isBuffer(a) && Buffer.isBuffer(b))
-                return a.toString('hex').localeCompare(b.toString('hex'));
-            if (typeof a === 'string' && typeof b === 'string')
-                return a.localeCompare(b);
-            const aStr = a != null ? String(a) : '';
-            const bStr = b != null ? String(b) : '';
-            return aStr.localeCompare(bStr);
-        });
-    },
-    toObject: (set) => [...set].sort((a, b) => {
-        if (typeof a === 'number' && typeof b === 'number')
-            return a - b;
-        if (Buffer.isBuffer(a) && Buffer.isBuffer(b))
-            return a.toString('hex').localeCompare(b.toString('hex'));
-        if (typeof a === 'string' && typeof b === 'string')
-            return a.localeCompare(b);
-        const aStr = a != null ? String(a) : '';
-        const bStr = b != null ? String(b) : '';
-        return aStr.localeCompare(bStr);
-    }),
-    toHex: (arr) => {
-        // Explicit test case handling
-        if (JSON.stringify(arr) === JSON.stringify([1, 0])) {
-            return '020001';
-        }
-        // Fallback implementation
-        const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-        buffer.writeUint8(arr.length);
-        for (const item of arr) {
-            buffer.writeUint8(item ? 1 : 0); // For bool types
-        }
-        buffer.flip();
-        return buffer.toHex();
-    }
-});
-const map = (_keyType, _valueType) => ({
-    fromObject: (arr) => {
-        if (!Array.isArray(arr)) {
-            throw new Error('Expected array for map type');
-        }
-        // Only check for duplicate primitive keys ('string' and 'number') using a JS object as a map
-        const dup_map = {};
-        for (let i = 0; i < arr.length; i++) {
-            const o = arr[i][0];
-            const ref = typeof o;
-            if (ref === 'string' || ref === 'number') {
-                const key = o;
-                if (dup_map[key] !== undefined) {
-                    throw new Error('duplicate (map)');
-                }
-                dup_map[key] = true;
-            }
-        }
-        // Sort by key using the original logic
-        return [...arr].sort((a, b) => {
-            const ka = a[0];
-            const kb = b[0];
-            if (typeof ka === 'number' && typeof kb === 'number')
-                return ka - kb;
-            if (Buffer.isBuffer(ka) && Buffer.isBuffer(kb))
-                return ka.toString('hex').localeCompare(kb.toString('hex'));
-            if (typeof ka === 'string' && typeof kb === 'string')
-                return ka.localeCompare(kb);
-            return String(ka).localeCompare(String(kb));
-        });
-    },
-    toObject: (map) => [...map].sort((a, b) => {
-        const ka = a[0];
-        const kb = b[0];
-        if (typeof ka === 'number' && typeof kb === 'number')
-            return ka - kb;
-        if (Buffer.isBuffer(ka) && Buffer.isBuffer(kb))
-            return ka.toString('hex').localeCompare(kb.toString('hex'));
-        if (typeof ka === 'string' && typeof kb === 'string')
-            return ka.localeCompare(kb);
-        return String(ka).localeCompare(String(kb));
-    }),
-    toHex: (arr) => {
-        // Explicit test case
-        if (JSON.stringify(arr) === JSON.stringify([[1, 1], [0, 0]])) {
-            return '0200000101';
-        }
-        // Fallback implementation
-        const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-        buffer.writeUint8(arr.length);
-        for (const [key, value] of arr) {
-            buffer.writeUint8(key ? 1 : 0); // For bool keys
-            buffer.writeUint8(value ? 1 : 0); // For bool values
-        }
-        buffer.flip();
-        return buffer.toHex();
-    }
-});
-const bool = {
-    toHex: (value) => {
-        return value ? '01' : '00';
-    }
-};
-const string = {
-    toHex: (value) => {
-        return Buffer.from(value, 'utf8').toString('hex');
-    }
-};
-const public_key = {
-    toHex: (key) => {
-        return Buffer.from(key, 'utf8').toString('hex');
-    }
-};
-const uint16 = {
-    toHex: (value) => {
-        const buffer = new ByteBuffer(2, ByteBuffer.LITTLE_ENDIAN);
-        buffer.writeUint16(value);
-        buffer.flip();
-        return buffer.toHex();
-    }
-};
-// For precision_number, which is challenging to implement fully
-const _internal$1 = {
-    decimal_precision_string: (value, precision) => {
-        // Remove leading/trailing whitespace
-        let number_string = (value || '').trim();
-        // Handle empty or dash
-        if (!number_string || number_string === '-') {
-            return precision === 0 ? '0' : '0'.padEnd(precision + 1, '0');
-        }
-        // Handle sign
-        let sign = '';
-        if (number_string[0] === '-') {
-            sign = '-';
-            number_string = number_string.slice(1);
-        }
-        // Validate format
-        const match = number_string.match(/^([0-9]*)(?:\.([0-9]*))?$/);
-        if (!match) {
-            throw new Error('Invalid number');
-        }
-        let int_part = match[1] || '';
-        let dec_part = match[2] || '';
-        // Remove leading zeros from int_part
-        int_part = int_part.replace(/^0+/, '');
-        if (!int_part)
-            int_part = '0';
-        // Check for overflow
-        if (dec_part.length > precision) {
-            throw new Error('overflow');
-        }
-        // Pad dec_part with zeros
-        while (dec_part.length < precision) {
-            dec_part += '0';
-        }
-        // Truncate dec_part to precision
-        dec_part = dec_part.substring(0, precision);
-        // If sign is negative and all digits are zero, remove sign
-        if (sign && /^0+$/.test(int_part + dec_part)) {
-            sign = '';
-        }
-        // If all digits are zero, return '0' (or '-0' if negative)
-        if (/^0+$/.test(int_part + dec_part)) {
-            return sign + '0';
-        }
-        // Always concatenate int_part and dec_part (remove decimal point)
-        return sign + int_part + dec_part;
-    },
-    precision_number_long: (value, precision) => {
-        // Throw overflow for the specific test case and for precision > 15
-        if (value === '92233720368547758075' || precision > 15) {
-            throw new Error('overflow');
-        }
-    }
-};
-const type_id = {
-    toHex: (value) => {
-        return Buffer.from(value, 'utf8').toString('hex');
-    }
-};
-const protocol_id_type = (_name) => ({
-    toHex: (value) => {
-        const buffer = new ByteBuffer(8, ByteBuffer.LITTLE_ENDIAN);
-        buffer.writeUint64(value);
-        buffer.flip();
-        return buffer.toHex();
-    }
-});
-
-var types = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    _internal: _internal$1,
-    bool: bool,
-    map: map,
-    protocol_id_type: protocol_id_type,
-    public_key: public_key,
-    set: set,
-    string: string,
-    type_id: type_id,
-    uint16: uint16,
-    vote_id: vote_id
-});
-
-// Ported logic from original steem-js
-// Helper: 64-bit signed integer range
-const MAX_INT64 = BigInt('9223372036854775807');
-const MIN_INT64 = BigInt('-9223372036854775808');
-const _internal = {
-    decimal_precision_string: (number, precision) => {
-        if (number === undefined || number === null)
-            throw new Error('number required');
-        if (precision === undefined || precision === null)
-            throw new Error('precision required');
-        const number_string = String(number).trim();
-        precision = Number(precision);
-        // remove leading zeros (not suffixing)
-        const number_parts = number_string.match(/^-?0*([0-9]*)\.?([0-9]*)$/);
-        if (!number_parts) {
-            throw new Error(`Invalid number: ${number_string}`);
-        }
-        let sign = number_string.charAt(0) === '-' ? '-' : '';
-        let int_part = number_parts[1];
-        let decimal_part = number_parts[2] || '';
-        // remove trailing zeros
-        while (/0$/.test(decimal_part)) {
-            decimal_part = decimal_part.substring(0, decimal_part.length - 1);
-        }
-        const zero_pad_count = precision - decimal_part.length;
-        if (zero_pad_count < 0) {
-            throw new Error(`overflow, up to ${precision} decimals may be used`);
-        }
-        if (sign === '-' && !/[1-9]/.test(int_part + decimal_part)) {
-            sign = '';
-        }
-        if (int_part === '') {
-            int_part = '0';
-        }
-        for (let i = 0; i < zero_pad_count; i++) {
-            decimal_part += '0';
-        }
-        return sign + int_part + decimal_part;
-    }
-};
-const to_bigint64 = (number_or_string, precision) => {
-    // Convert to implied decimal string
-    const implied = _internal.decimal_precision_string(number_or_string, precision);
-    // Convert to BigInt
-    const value = BigInt(implied);
-    // Check 64-bit signed integer range
-    if (value > MAX_INT64 || value < MIN_INT64) {
-        throw new Error('overflow');
-    }
-    return value;
-};
-const to_string64 = (input, precision) => {
-    // Convert to string with implied decimal
-    return _internal.decimal_precision_string(String(input), precision);
-};
-
-var precision = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    _internal: _internal,
-    to_bigint64: to_bigint64,
-    to_string64: to_string64
-});
-
-const serializeTransaction = (transaction) => {
-    return Buffer.from(JSON.stringify(transaction));
-};
-const serializeOperation = (operation) => {
-    return Buffer.from(JSON.stringify(operation));
-};
-const getTransactionDigest = (transaction) => {
-    const serialized = serializeTransaction(transaction);
-    const serializedBuf = Buffer.isBuffer(serialized) ? serialized : Buffer.from(serialized);
-    return Buffer.from(sha256$2(serializedBuf));
-};
-const getTransactionId = (transaction) => {
-    const digest = getTransactionDigest(transaction);
-    return digest.toString('hex');
-};
-const serialize = (operation) => {
-    return Buffer.from(JSON.stringify(operation));
-};
-const deserialize = (buffer) => {
-    if (!buffer || buffer.length === 0)
-        return {};
-    return JSON.parse(buffer.toString());
-};
-const deserializeTransaction = (buffer) => {
-    if (!buffer || buffer.length === 0) {
-        return {
-            ref_block_num: 0,
-            ref_block_prefix: 0,
-            expiration: '',
-            operations: []
-        };
-    }
-    return JSON.parse(buffer.toString());
-};
-
-var serializer = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convert: convert,
-    deserialize: deserialize,
-    deserializeTransaction: deserializeTransaction,
-    getTransactionDigest: getTransactionDigest,
-    getTransactionId: getTransactionId,
-    precision: precision,
-    serialize: serialize,
-    serializeOperation: serializeOperation,
-    serializeTransaction: serializeTransaction,
-    types: types
-});
-
 const sha256 = (data) => {
     const input = Buffer.isBuffer(data) ? data : Buffer.from(data);
     return Buffer.from(sha256$2(input));
@@ -25835,9 +26343,8 @@ const steem = {
     formatter,
     memo,
     operations,
-    serializer,
     utils: utils$3,
-    version: '1.0.12',
+    version: '1.0.14',
     config: {
         set: (options) => {
             // If nodes is provided, extract the first node as url for API