@steemit/steem-js 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -6085,6 +6085,98 @@ const setConfig = (newConfig) => {
 // Alias for setConfig to match the API's setOptions
 const setOptions$1 = setConfig;
 
+var config$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	Config: Config,
+	getConfig: getConfig,
+	setConfig: setConfig,
+	setOptions: setOptions$1
+});
+
+/**
+ * Debug utility for controlled debug output
+ * Can be enabled via:
+ * 1. Config: steem.config.set({ debug: true })
+ * 2. Environment variable: DEBUG=steem-js or DEBUG=steem-js:*
+ * 3. Specific debug flags: DEBUG=steem-js:transaction,steem-js:signature
+ */
+// Check if debug is enabled via environment variable
+const DEBUG_ENV = process.env.DEBUG || '';
+const DEBUG_ENABLED = DEBUG_ENV.includes('steem-js');
+// Parse debug flags from environment
+const DEBUG_FLAGS = DEBUG_ENV.split(',').map(f => f.trim());
+function isDebugEnabled(flag) {
+    // Check config first
+    const configDebug = getConfig().get('debug');
+    if (configDebug === true) {
+        return true;
+    }
+    if (configDebug === false) {
+        return false;
+    }
+    // Check environment variable
+    if (!DEBUG_ENABLED) {
+        return false;
+    }
+    // If no flag specified, check for general steem-js debug
+    if (!flag) {
+        return DEBUG_ENV.includes('steem-js') && !DEBUG_ENV.includes('steem-js:');
+    }
+    // Check for specific flag
+    const flagPattern = `steem-js:${flag}`;
+    return DEBUG_FLAGS.some(f => f === flagPattern || f === 'steem-js:*');
+}
+const debug = {
+    /**
+     * Log debug information
+     * @param flag - Optional debug flag (e.g., 'transaction', 'signature')
+     * @param args - Arguments to log
+     */
+    log(flag, ...args) {
+        if (isDebugEnabled(flag)) {
+            const prefix = flag ? `[steem-js:${flag}]` : '[steem-js]';
+            console.log(prefix, ...args);
+        }
+    },
+    /**
+     * Log transaction debug info
+     */
+    transaction(...args) {
+        this.log('transaction', ...args);
+    },
+    /**
+     * Log signature debug info
+     */
+    signature(...args) {
+        this.log('signature', ...args);
+    },
+    /**
+     * Log warning (always shown, but can be controlled)
+     */
+    warn(...args) {
+        if (isDebugEnabled() || getConfig().get('debug_warnings') !== false) {
+            console.warn('[steem-js]', ...args);
+        }
+    },
+    /**
+     * Log error (always shown)
+     */
+    error(...args) {
+        console.error('[steem-js]', ...args);
+    },
+    /**
+     * Check if debug is enabled for a specific flag
+     */
+    isEnabled(flag) {
+        return isDebugEnabled(flag);
+    }
+};
+
+var debug$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	debug: debug
+});
+
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
@@ -6130,6 +6222,7 @@ var utils = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	camelCase: camelCase,
 	chunk: chunk,
+	debug: debug,
 	flatten: flatten,
 	isValidAddress: isValidAddress,
 	isValidAmount: isValidAmount,
@@ -8310,17 +8403,18 @@ function requireCreateHash () {
 var createHashExports = requireCreateHash();
 var createHash = /*@__PURE__*/getDefaultExportFromCjs(createHashExports);
 
-var createHmac;
+var createHmac$1;
 var hasRequiredCreateHmac;
 
 function requireCreateHmac () {
-	if (hasRequiredCreateHmac) return createHmac;
+	if (hasRequiredCreateHmac) return createHmac$1;
 	hasRequiredCreateHmac = 1;
-	createHmac = require$$3$1.createHmac;
-	return createHmac;
+	createHmac$1 = require$$3$1.createHmac;
+	return createHmac$1;
 }
 
-requireCreateHmac();
+var createHmacExports = requireCreateHmac();
+var createHmac = /*@__PURE__*/getDefaultExportFromCjs(createHmacExports);
 
 /** @arg {string|Buffer} data
     @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
@@ -8342,6 +8436,9 @@ function sha512(data, encoding) {
     }
     return createHash('sha512').update(data).digest();
 }
+function HmacSHA256(buffer, secret) {
+    return createHmac('sha256', secret).update(buffer).digest();
+}
 function ripemd160$1(data) {
     return createHash('rmd160').update(data).digest();
 }
@@ -8627,7 +8724,7 @@ class PrivateKey {
             throw new Error("Expecting parameter to be a Buffer type");
         }
         if (32 !== buf.length) {
-            console.log(`WARN: Expecting 32 bytes, instead got ${buf.length}, stack trace:`, new Error().stack);
+            debug.warn(`WARN: Expecting 32 bytes, instead got ${buf.length}, stack trace:`, new Error().stack);
         }
         if (buf.length === 0) {
             throw new Error("Empty buffer");
@@ -8746,6 +8843,278 @@ const toPublic = (data) => {
     return data;
 };
 
+function enforce(type, value) {
+    switch (type) {
+        case 'Array': {
+            if (Array.isArray(value))
+                return;
+            break;
+        }
+        case 'Boolean': {
+            if (typeof value === 'boolean')
+                return;
+            break;
+        }
+        case 'Buffer': {
+            if (Buffer.isBuffer(value))
+                return;
+            break;
+        }
+        case 'Number': {
+            if (typeof value === 'number')
+                return;
+            break;
+        }
+        case 'String': {
+            if (typeof value === 'string')
+                return;
+            break;
+        }
+        default: {
+            if (typeof type === 'function' && getName(value.constructor) === getName(type))
+                return;
+        }
+    }
+    throw new TypeError('Expected ' + (typeof type === 'function' ? getName(type) : type) + ', got ' + value);
+}
+function getName(fn) {
+    const match = fn.toString().match(/function (.*?)\(/);
+    return match ? match[1] : null;
+}
+
+class ECSignature {
+    constructor(r, s) {
+        enforce(bigi, r);
+        enforce(bigi, s);
+        this.r = r;
+        this.s = s;
+    }
+    static parseCompact(buffer) {
+        if (buffer.length !== 65)
+            throw new Error('Invalid signature length');
+        let i = buffer.readUInt8(0) - 27;
+        if ((i & 7) !== i)
+            throw new Error('Invalid signature parameter');
+        const compressed = !!(i & 4);
+        i = i & 3;
+        const r = bigi.fromBuffer(buffer.slice(1, 33));
+        const s = bigi.fromBuffer(buffer.slice(33));
+        return {
+            compressed,
+            i,
+            signature: new ECSignature(r, s)
+        };
+    }
+    static fromDER(buffer) {
+        if (buffer.readUInt8(0) !== 0x30)
+            throw new Error('Not a DER sequence');
+        if (buffer.readUInt8(1) !== buffer.length - 2)
+            throw new Error('Invalid sequence length');
+        if (buffer.readUInt8(2) !== 0x02)
+            throw new Error('Expected a DER integer');
+        const rLen = buffer.readUInt8(3);
+        if (rLen === 0)
+            throw new Error('R length is zero');
+        let offset = 4 + rLen;
+        if (buffer.readUInt8(offset) !== 0x02)
+            throw new Error('Expected a DER integer (2)');
+        const sLen = buffer.readUInt8(offset + 1);
+        if (sLen === 0)
+            throw new Error('S length is zero');
+        const rB = buffer.slice(4, offset);
+        const sB = buffer.slice(offset + 2);
+        offset += 2 + sLen;
+        if (rLen > 1 && rB.readUInt8(0) === 0x00) {
+            if (!(rB.readUInt8(1) & 0x80))
+                throw new Error('R value excessively padded');
+        }
+        if (sLen > 1 && sB.readUInt8(0) === 0x00) {
+            if (!(sB.readUInt8(1) & 0x80))
+                throw new Error('S value excessively padded');
+        }
+        if (offset !== buffer.length)
+            throw new Error('Invalid DER encoding');
+        const r = bigi.fromBuffer(rB);
+        const s = bigi.fromBuffer(sB);
+        if (r.signum() < 0)
+            throw new Error('R value is negative');
+        if (s.signum() < 0)
+            throw new Error('S value is negative');
+        return new ECSignature(r, s);
+    }
+    static parseScriptSignature(buffer) {
+        const hashType = buffer.readUInt8(buffer.length - 1);
+        const hashTypeMod = hashType & -129;
+        if (hashTypeMod <= 0x00 || hashTypeMod >= 0x04)
+            throw new Error('Invalid hashType');
+        return {
+            signature: ECSignature.fromDER(buffer.slice(0, -1)),
+            hashType
+        };
+    }
+    toCompact(i, compressed) {
+        if (compressed)
+            i += 4;
+        i += 27;
+        const buffer = Buffer.alloc(65);
+        buffer.writeUInt8(i, 0);
+        this.r.toBuffer(32).copy(buffer, 1);
+        this.s.toBuffer(32).copy(buffer, 33);
+        return buffer;
+    }
+    toDER() {
+        const rBa = this.r.toBuffer();
+        const sBa = this.s.toBuffer();
+        const sequence = [];
+        // INTEGER
+        sequence.push(0x02, rBa.length);
+        Array.from(rBa).forEach(b => sequence.push(b));
+        // INTEGER
+        sequence.push(0x02, sBa.length);
+        Array.from(sBa).forEach(b => sequence.push(b));
+        // SEQUENCE
+        sequence.unshift(0x30, sequence.length);
+        return Buffer.from(sequence);
+    }
+    toScriptSignature(hashType) {
+        const hashTypeBuffer = Buffer.alloc(1);
+        hashTypeBuffer.writeUInt8(hashType, 0);
+        return Buffer.concat([this.toDER(), hashTypeBuffer]);
+    }
+}
+
+// https://tools.ietf.org/html/rfc6979#section-3.2
+function deterministicGenerateK(curve, hash, d, checkSig, nonce) {
+    enforce('Buffer', hash);
+    enforce(bigi, d);
+    if (nonce) {
+        hash = sha256$1(Buffer.concat([hash, Buffer.alloc(nonce)]));
+    }
+    // sanity check
+    assert.equal(hash.length, 32, 'Hash must be 256 bit');
+    const x = d.toBuffer(32);
+    let k = Buffer.alloc(32);
+    let v = Buffer.alloc(32);
+    // Step B
+    v.fill(1);
+    // Step C
+    k.fill(0);
+    // Step D
+    k = HmacSHA256(Buffer.concat([v, Buffer.from([0]), x, hash]), k);
+    // Step E
+    v = HmacSHA256(v, k);
+    // Step F
+    k = HmacSHA256(Buffer.concat([v, Buffer.from([1]), x, hash]), k);
+    // Step G
+    v = HmacSHA256(v, k);
+    // Step H1/H2a, ignored as tlen === qlen (256 bit)
+    // Step H2b
+    v = HmacSHA256(v, k);
+    let T = bigi.fromBuffer(v);
+    // Step H3, repeat until T is within the interval [1, n - 1] and passes the supplied check
+    while ((T.signum() <= 0) || (T.compareTo(curve.n) >= 0) || !checkSig(T)) {
+        k = HmacSHA256(Buffer.concat([v, Buffer.from([0])]), k);
+        v = HmacSHA256(v, k);
+        // Step H1/H2a, again, ignored as tlen === qlen (256 bit)
+        // Step H2b again
+        v = HmacSHA256(v, k);
+        T = bigi.fromBuffer(v);
+    }
+    return T;
+}
+function sign$3(curve, hash, d, nonce) {
+    const e = bigi.fromBuffer(hash);
+    const n = curve.n;
+    const G = curve.G;
+    let r;
+    let s;
+    deterministicGenerateK(curve, hash, d, function (k) {
+        // find canonically valid signature
+        const Q = G.multiply(k);
+        if (curve.isInfinity(Q))
+            return false;
+        const tempR = Q.affineX.mod(n);
+        if (tempR.signum() === 0)
+            return false;
+        const tempS = k.modInverse(n).multiply(e.add(d.multiply(tempR))).mod(n);
+        if (tempS.signum() === 0)
+            return false;
+        r = tempR;
+        s = tempS;
+        return true;
+    }, nonce);
+    if (!r || !s)
+        throw new Error('Unable to find valid signature');
+    const N_OVER_TWO = n.shiftRight(1);
+    // enforce low S values, see bip62: 'low s values in signatures'
+    const finalS = s.compareTo(N_OVER_TWO) > 0 ? n.subtract(s) : s;
+    return new ECSignature(r, finalS);
+}
+/**
+ * Recover a public key from a signature.
+ *
+ * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
+ * Key Recovery Operation".
+ *
+ * http://www.secg.org/download/aid-780/sec1-v2.pdf
+ */
+function recoverPubKey(curve, e, signature, i) {
+    assert.strictEqual(i & 3, i, 'Recovery param is more than two bits');
+    const n = curve.n;
+    const G = curve.G;
+    const r = signature.r;
+    const s = signature.s;
+    assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value');
+    assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value');
+    // A set LSB signifies that the y-coordinate is odd
+    const isYOdd = !!(i & 1);
+    // The more significant bit specifies whether we should use the
+    // first or second candidate key.
+    const isSecondKey = i >> 1;
+    // 1.1 Let x = r + jn
+    const x = isSecondKey ? r.add(n) : r;
+    const R = curve.pointFromX(isYOdd, x);
+    // 1.4 Check that nR is at infinity
+    const nR = R.multiply(n);
+    assert(curve.isInfinity(nR), 'nR is not a valid curve point');
+    // Compute -e from e
+    const eNeg = e.negate().mod(n);
+    // 1.6.1 Compute Q = r^-1 (sR -  eG)
+    //               Q = r^-1 (sR + -eG)
+    const rInv = r.modInverse(n);
+    const sR = R.multiply(s);
+    const eGNeg = G.multiply(eNeg);
+    const Q = sR.add(eGNeg).multiply(rInv);
+    curve.validate(Q);
+    return Q;
+}
+/**
+ * Calculate pubkey extraction parameter.
+ *
+ * When extracting a pubkey from a signature, we have to
+ * distinguish four different cases. Rather than putting this
+ * burden on the verifier, Bitcoin includes a 2-bit value with the
+ * signature.
+ *
+ * This function simply tries all four cases and returns the value
+ * that resulted in a successful pubkey recovery.
+ */
+function calcPubKeyRecoveryParam(curve, e, signature, Q) {
+    for (let i = 0; i < 4; i++) {
+        try {
+            const Qprime = recoverPubKey(curve, e, signature, i);
+            // 1.6.2 Verify Q = Q'
+            if (Qprime.equals(Q)) {
+                return i;
+            }
+        }
+        catch (error) {
+            // try next value
+        }
+    }
+    throw new Error('Unable to find valid recovery factor');
+}
+
 const secp256k1 = libExports$1.getCurveByName('secp256k1');
 class Signature {
     constructor(r, s, i) {
@@ -8785,28 +9154,27 @@ class Signature {
             throw new Error('private_key required');
         }
         const e = bigi.fromBuffer(buf_sha256);
-        const n = secp256k1.n;
-        const G = secp256k1.G;
-        const d = privKey.d;
-        let r, s;
+        let ecsignature;
+        let i = null;
         let nonce = 0;
+        // Match old-steem-js behavior: find canonical signature (lenR === 32 && lenS === 32)
         while (true) {
-            const k = bigi.fromBuffer(sha256$1(Buffer.concat([buf_sha256, Buffer.from([nonce++])])));
-            const Q = G.multiply(k);
-            r = Q.affineX.mod(n);
-            if (r.signum() === 0)
-                continue;
-            s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);
-            if (s.signum() === 0)
-                continue;
-            break;
-        }
-        const N_OVER_TWO = n.shiftRight(1);
-        if (s.compareTo(N_OVER_TWO) > 0) {
-            s = n.subtract(s);
+            ecsignature = sign$3(secp256k1, buf_sha256, privKey.d, nonce++);
+            const der = ecsignature.toDER();
+            const lenR = der[3];
+            const lenS = der[5 + lenR];
+            if (lenR === 32 && lenS === 32) {
+                // Calculate recovery parameter to match old-steem-js
+                i = calcPubKeyRecoveryParam(secp256k1, e, ecsignature, privKey.toPublic().Q);
+                i += 4; // compressed
+                i += 27; // compact
+                break;
+            }
+            if (nonce % 10 === 0) {
+                debug.warn("WARN: " + nonce + " attempts to find canonical signature");
+            }
         }
-        const i = 27 + 4; // compressed + compact
-        return new Signature(r, s, i);
+        return new Signature(ecsignature.r, ecsignature.s, i);
     }
     static sign(string, private_key) {
         return Signature.signBuffer(Buffer.from(string), private_key);
@@ -9978,7 +10346,18 @@ class HttpTransport extends BaseTransport {
                     timeout: timeoutMs,
                 })
                     .then((res) => res.json())
-                    .then((result) => callback(null, result.result, currentAttempt), (error) => {
+                    .then((result) => {
+                    // Check for JSON-RPC errors
+                    if (result.error) {
+                        const error = new Error(result.error.message || 'JSON-RPC error');
+                        error.code = result.error.code;
+                        error.data = result.error.data;
+                        callback(error, undefined, currentAttempt);
+                    }
+                    else {
+                        callback(null, result.result, currentAttempt);
+                    }
+                }, (error) => {
                     if (operation.retry(error)) {
                         return;
                     }
@@ -9999,7 +10378,18 @@ class HttpTransport extends BaseTransport {
                 timeout: timeoutMs,
             })
                 .then((res) => res.json())
-                .then((result) => callback(null, result.result, 1), (error) => callback(error, undefined, 1));
+                .then((result) => {
+                // Check for JSON-RPC errors
+                if (result.error) {
+                    const error = new Error(result.error.message || 'JSON-RPC error');
+                    error.code = result.error.code;
+                    error.data = result.error.data;
+                    callback(error, undefined, 1);
+                }
+                else {
+                    callback(null, result.result, 1);
+                }
+            }, (error) => callback(error, undefined, 1));
         }
     }
 }
@@ -21900,6 +22290,179 @@ 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) {
+    const bb = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    // Write ref_block_num (uint16)
+    bb.writeUint16(trx.ref_block_num || 0);
+    // Write ref_block_prefix (uint32)
+    bb.writeUint32(trx.ref_block_prefix || 0);
+    // Write expiration (time_point_sec - uint32 seconds since epoch)
+    // Match old-steem-js behavior: ensure UTC time and precision to seconds
+    let expiration;
+    if (typeof trx.expiration === 'string') {
+        // If string doesn't end with 'Z', append it to ensure UTC time
+        let expirationStr = trx.expiration;
+        if (!expirationStr.endsWith('Z')) {
+            expirationStr = expirationStr + 'Z';
+        }
+        const date = new Date(expirationStr);
+        expiration = Math.floor(date.getTime() / 1000);
+    }
+    else if (typeof trx.expiration === 'number') {
+        expiration = trx.expiration;
+    }
+    else {
+        expiration = 0;
+    }
+    bb.writeUint32(expiration);
+    // Write operations array
+    const operations = trx.operations || [];
+    bb.writeVarint32(operations.length);
+    for (const op of operations) {
+        serializeOperation$1(bb, op);
+    }
+    // Write extensions (set of future_extensions, which is void/empty)
+    bb.writeVarint32(0); // Empty set
+    bb.flip();
+    return Buffer.from(bb.toBuffer());
+}
+/**
+ * Serialize an operation to binary format
+ */
+function serializeOperation$1(bb, op) {
+    if (!Array.isArray(op) || op.length !== 2) {
+        throw new Error('Operation must be an array of [operation_type, operation_data]');
+    }
+    const [opType, opData] = op;
+    // Write operation type index (varint32)
+    // For now, we'll use a simple mapping. In a full implementation,
+    // this would use the static_variant index
+    const opTypeIndex = getOperationTypeIndex(opType);
+    bb.writeVarint32(opTypeIndex);
+    // Serialize operation data based on type
+    serializeOperationData(bb, opType, opData);
+}
+/**
+ * Get operation type index based on Steem blockchain operation order
+ * This matches the operation.st_operations array from the blockchain
+ */
+function getOperationTypeIndex(opType) {
+    // Operation type indices based on Steem blockchain operation.st_operations
+    const opMap = {
+        'vote': 0,
+        'comment': 1,
+        'transfer': 2,
+        'transfer_to_vesting': 3,
+        'withdraw_vesting': 4,
+        'limit_order_create': 5,
+        'limit_order_cancel': 6,
+        'feed_publish': 7,
+        'convert': 8,
+        'account_create': 9,
+        'account_update': 10,
+        'witness_update': 11,
+        'account_witness_vote': 12,
+        'account_witness_proxy': 13,
+        'pow': 14,
+        'custom': 15,
+        'delete_comment': 17,
+        'custom_json': 18,
+        'comment_options': 19,
+    };
+    const index = opMap[opType];
+    if (index === undefined) {
+        throw new Error(`Unknown operation type: ${opType}. Please add it to the operation map.`);
+    }
+    return index;
+}
+/**
+ * Serialize operation data based on operation type
+ */
+function serializeOperationData(bb, opType, opData) {
+    switch (opType) {
+        case 'comment':
+            serializeComment(bb, opData);
+            break;
+        case 'vote':
+            serializeVote(bb, opData);
+            break;
+        case 'transfer':
+            serializeTransfer(bb, opData);
+            break;
+        default:
+            // For other operations, try to serialize common fields
+            // This is a fallback and may not work for all operations
+            throw new Error(`Operation type ${opType} serialization not fully implemented`);
+    }
+}
+/**
+ * Serialize comment operation
+ */
+function serializeComment(bb, data) {
+    writeString(bb, data.parent_author || '');
+    writeString(bb, data.parent_permlink || '');
+    writeString(bb, data.author || '');
+    writeString(bb, data.permlink || '');
+    writeString(bb, data.title || '');
+    writeString(bb, data.body || '');
+    writeString(bb, data.json_metadata || '{}');
+}
+/**
+ * Serialize vote operation
+ */
+function serializeVote(bb, data) {
+    writeString(bb, data.voter || '');
+    writeString(bb, data.author || '');
+    writeString(bb, data.permlink || '');
+    bb.writeInt16(data.weight || 0);
+}
+/**
+ * Serialize transfer operation (simplified - asset serialization is complex)
+ */
+function serializeTransfer(bb, data) {
+    writeString(bb, data.from || '');
+    writeString(bb, data.to || '');
+    // Asset serialization is complex and requires parsing amount string
+    // For now, this is a placeholder
+    serializeAsset(bb, data.amount || '0.000 STEEM');
+    writeString(bb, data.memo || '');
+}
+/**
+ * Serialize asset (simplified - full implementation is complex)
+ */
+function serializeAsset(bb, amount) {
+    // Parse amount string like "1.000 STEEM"
+    const parts = amount.split(' ');
+    const valueStr = parts[0] || '0.000';
+    const symbol = parts[1] || 'STEEM';
+    // Parse decimal value
+    const [intPart, decPart = ''] = valueStr.split('.');
+    const precision = decPart.length;
+    const amountValue = parseInt(intPart + decPart.padEnd(precision, '0'), 10);
+    // Write amount as int64
+    const amountLong = Long.fromNumber(amountValue, false);
+    bb.writeInt64(amountLong);
+    // Write precision and symbol (uint8 + 7 bytes)
+    bb.writeUint8(precision);
+    const symbolBytes = Buffer.from(symbol, 'utf8');
+    bb.append(symbolBytes);
+    // Pad to 7 bytes
+    for (let i = symbolBytes.length; i < 7; i++) {
+        bb.writeUint8(0);
+    }
+}
+/**
+ * Write a string using ByteBuffer's writeVString method
+ * This matches the old implementation exactly
+ */
+function writeString(bb, str) {
+    bb.writeVString(str);
+}
+
 class Serializer {
     static fromBuffer(buffer) {
         const bb = ByteBuffer.fromBinary(buffer.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
@@ -21962,7 +22525,8 @@ class Serializer {
 }
 const transaction = {
     toBuffer(trx) {
-        return Buffer.from(JSON.stringify(trx));
+        // Use binary serialization for proper signature generation
+        return serializeTransaction$1(trx);
     }
 };
 const signed_transaction = {
@@ -21974,6 +22538,13 @@ const signed_transaction = {
     }
 };
 
+var serializer$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	Serializer: Serializer,
+	signed_transaction: signed_transaction,
+	transaction: transaction
+});
+
 const Auth = {
     verify(name, password, auths) {
         let hasKey = false;
@@ -22055,13 +22626,15 @@ const Auth = {
         }
         const signatures = [];
         if (trx.signatures) {
-            signatures.push(...trx.signatures.map((sig) => Buffer.from(sig)));
+            signatures.push(...trx.signatures.map((sig) => Buffer.isBuffer(sig) ? sig.toString('hex') : sig));
         }
         const cid = Buffer.from(getConfig().get('chain_id') || '', 'hex');
         const buf = transaction.toBuffer(trx);
         for (const key of keys) {
             const sig = Signature.signBuffer(Buffer.concat([cid, buf]), key);
-            signatures.push(sig.toBuffer());
+            // Use toBuffer() to match old-steem-js behavior
+            // The serializer will convert Buffer to hex string when needed
+            signatures.push(sig.toBuffer().toString('hex'));
         }
         return signed_transaction.toObject(Object.assign(trx, { signatures }));
     }
@@ -22398,6 +22971,21 @@ 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)
+            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; });
+                const { createHash } = await import('crypto');
+                const buf = transactionSerializer.toBuffer(transaction);
+                const chainId = Buffer.from(getConfig().get('chain_id') || '', 'hex');
+                const digest = createHash('sha256').update(Buffer.concat([chainId, buf])).digest();
+                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');
+            }
             // Ensure privKeys is always an array for signTransaction
             const keysArray = Array.isArray(privKeys)
                 ? privKeys