@steemit/steem-js 1.0.12 → 1.0.14

package/dist/index.umd.js

@@ -16593,6 +16593,20 @@
 	const secp256k1$1 = new elliptic.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
@@ -16605,11 +16619,8 @@
 	        if (!buffer.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));
 	    }
@@ -16634,21 +16645,33 @@
 	     * @return {string} Wallet Import Format (still a secret, Not encrypted)
 	     */
 	    static fromWif(private_wif) {
-	        const private_wif_buffer = 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.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.Buffer.concat([buffer.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.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();
@@ -17027,18 +17050,21 @@
 	        }
 	        catch (error) {
 	            // try next value
-	            console.debug(`Recovery attempt ${i} failed:`, error.message);
+	            if (process$1.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$1.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');
 	}
 
@@ -17090,9 +17116,10 @@
 	        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.Buffer, 'be', 32);
 	            const sBa = ecsignature.s.toArrayLike(buffer.Buffer, 'be', 32);
@@ -17109,6 +17136,9 @@
 	                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
@@ -17409,7 +17439,11 @@
 	    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);
@@ -18359,7 +18393,37 @@
 	    }
 	}
 
-	// @ts-expect-error: No types for 'retry'
+	/** Detect Node.js for optional undici Agent (custom TLS). */
+	const isNode = typeof process$1 !== 'undefined' &&
+	    typeof process$1.versions === 'object' &&
+	    typeof process$1.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
 	 */
@@ -18379,29 +18443,22 @@
 	 * @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}`);
@@ -18452,71 +18509,56 @@
 	        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$1.operation(retryOptions) : retry$1.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$1.operation(retryOptions) : retry$1.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));
 	    }
 	}
 
@@ -25078,7 +25120,7 @@
 	 * 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)
@@ -25108,7 +25150,7 @@
 	    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
@@ -25137,7 +25179,7 @@
 	/**
 	 * 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]');
 	    }
@@ -25169,9 +25211,45 @@
 	        '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) {
@@ -25196,6 +25274,135 @@
 	        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;
@@ -25266,143 +25473,843 @@
 	    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.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.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.Buffer.from(hex, 'hex');
+	    }
+	    else if (buffer.Buffer.isBuffer(summary)) {
+	        bytes = summary;
+	    }
+	    else {
+	        bytes = buffer.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.Buffer.isBuffer(key)) {
+	        bb.append(key);
+	    }
+	    else if (key && typeof key.toBuffer === 'function') {
+	        bb.append(key.toBuffer());
+	    }
+	    else {
+	        bb.append(buffer.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.Buffer.from(v, 'utf8') : buffer.Buffer.isBuffer(v) ? v : buffer.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.Buffer.from(hex, 'hex');
+	    }
+	    else if (buffer.Buffer.isBuffer(dataBytes)) {
+	        buf = dataBytes;
+	    }
+	    else {
+	        buf = buffer.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.Buffer.from(hex, 'hex');
+	    }
+	    else if (buffer.Buffer.isBuffer(dataBytes)) {
+	        buf = dataBytes;
+	    }
+	    else {
+	        buf = buffer.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.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 {
@@ -25424,7 +26331,7 @@
 	const transaction = {
 	    toBuffer(trx) {
 	        // Use binary serialization for proper signature generation
-	        return serializeTransaction$1(trx);
+	        return serializeTransaction(trx);
 	    }
 	};
 	const signed_transaction = {
@@ -25436,7 +26343,7 @@
 	    }
 	};
 
-	var serializer$1 = /*#__PURE__*/Object.freeze({
+	var serializer = /*#__PURE__*/Object.freeze({
 		__proto__: null,
 		Serializer: Serializer,
 		signed_transaction: signed_transaction,
@@ -25487,12 +26394,16 @@
 	        let isWif = false;
 	        try {
 	            const bufWif = buffer.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.Buffer.from(newChecksum))) {
 	                isWif = true;
 	            }
 	        }
@@ -26661,20 +27572,29 @@
 	        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.Buffer.from(getConfig().get('chain_id') || '', 'hex');
-	                const digest = buffer.Buffer.from(sha256$2(buffer.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$1.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.Buffer.from(getConfig().get('chain_id') || '', 'hex');
+	                    const digest = buffer.Buffer.from(sha256$2(buffer.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)
@@ -28063,19 +28983,15 @@
 	    };
 	});
 
-	let uniqueNonceEntropy = null;
 	function sha512Buffer(data) {
 	    const result = sha512(data);
 	    return buffer.Buffer.isBuffer(result) ? result : buffer.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()) {
@@ -28229,7 +29145,14 @@
 	    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;
 	    }
@@ -28249,7 +29172,24 @@
 	        const memoData = Serializer.fromBuffer(buffer.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 {
@@ -28323,438 +29263,6 @@
 		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);
-	}
-
-	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.Buffer.isBuffer(a) && buffer.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.Buffer.isBuffer(a) && buffer.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.Buffer.isBuffer(ka) && buffer.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.Buffer.isBuffer(ka) && buffer.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.Buffer.from(value, 'utf8').toString('hex');
-	    }
-	};
-	const public_key = {
-	    toHex: (key) => {
-	        return buffer.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.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.Buffer.from(JSON.stringify(transaction));
-	};
-	const serializeOperation = (operation) => {
-	    return buffer.Buffer.from(JSON.stringify(operation));
-	};
-	const getTransactionDigest = (transaction) => {
-	    const serialized = serializeTransaction(transaction);
-	    const serializedBuf = buffer.Buffer.isBuffer(serialized) ? serialized : buffer.Buffer.from(serialized);
-	    return buffer.Buffer.from(sha256$2(serializedBuf));
-	};
-	const getTransactionId = (transaction) => {
-	    const digest = getTransactionDigest(transaction);
-	    return digest.toString('hex');
-	};
-	const serialize = (operation) => {
-	    return buffer.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.Buffer.isBuffer(data) ? data : buffer.Buffer.from(data);
 	    return buffer.Buffer.from(sha256$2(input));
@@ -28841,10 +29349,9 @@
 	    formatter,
 	    memo,
 	    operations,
-	    serializer,
 	    utils: utils$n,
 	    ...crypto$1,
-	    version: '1.0.12',
+	    version: '1.0.14',
 	    config: {
 	        set: (options) => {
 	            // If nodes is provided, extract the first node as url for API