@steemit/steem-js 1.0.16 → 1.0.18

package/dist/index.cjs

@@ -17017,7 +17017,7 @@ function requireBytebufferNode () {
 	         * @type {!Buffer}
 	         * @expose
 	         */
-	        this.buffer = capacity === 0 ? EMPTY_BUFFER : new Buffer(capacity);
+	        this.buffer = capacity === 0 ? EMPTY_BUFFER : Buffer.alloc(capacity);
 
 	        /**
 	         * Absolute read/write offset.
@@ -17142,7 +17142,7 @@ function requireBytebufferNode () {
 	     * @type {!Buffer}
 	     * @inner
 	     */
-	    var EMPTY_BUFFER = new Buffer(0);
+	    var EMPTY_BUFFER = Buffer.alloc(0);
 
 	    /**
 	     * String.fromCharCode reference for compile-time renaming.
@@ -17311,7 +17311,7 @@ function requireBytebufferNode () {
 	            k = 0,
 	            b;
 	        if (buffer instanceof Uint8Array) { // Extract bytes from Uint8Array
-	            b = new Buffer(buffer.length);
+	            b = Buffer.alloc(buffer.length);
 	            if (memcpy) { // Fast
 	                memcpy(b, 0, buffer.buffer, buffer.byteOffset, buffer.byteOffset + buffer.length);
 	            } else { // Slow
@@ -17320,7 +17320,7 @@ function requireBytebufferNode () {
 	            }
 	            buffer = b;
 	        } else if (buffer instanceof ArrayBuffer) { // Convert ArrayBuffer to Buffer
-	            b = new Buffer(buffer.byteLength);
+	            b = Buffer.alloc(buffer.byteLength);
 	            if (memcpy) { // Fast
 	                memcpy(b, 0, buffer, 0, buffer.byteLength);
 	            } else { // Slow
@@ -17333,7 +17333,7 @@ function requireBytebufferNode () {
 	        } else if (!(buffer instanceof Buffer)) { // Create from octets if it is an error, otherwise fail
 	            if (Object.prototype.toString.call(buffer) !== "[object Array]")
 	                throw TypeError("Illegal buffer");
-	            buffer = new Buffer(buffer);
+	            buffer = Buffer.from(buffer);
 	        }
 	        bb = new ByteBuffer(0, littleEndian, noAssert);
 	        if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER
@@ -19277,7 +19277,7 @@ function requireBytebufferNode () {
 	    ByteBufferPrototype.clone = function(copy) {
 	        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);
 	        if (copy) {
-	            var buffer = new Buffer(this.buffer.length);
+	            var buffer = Buffer.alloc(this.buffer.length);
 	            this.buffer.copy(buffer);
 	            bb.buffer = buffer;
 	        } else {
@@ -19321,7 +19321,7 @@ function requireBytebufferNode () {
 	            this.limit = 0;
 	            return this;
 	        }
-	        var buffer = new Buffer(len);
+	        var buffer = Buffer.alloc(len);
 	        this.buffer.copy(buffer, 0, begin, end);
 	        this.buffer = buffer;
 	        if (this.markedOffset >= 0) this.markedOffset -= begin;
@@ -19560,7 +19560,7 @@ function requireBytebufferNode () {
 	        if (len <= 0) return this; // Nothing to prepend
 	        var diff = len - offset;
 	        if (diff > 0) { // Not enough space before offset, so resize + move
-	            var buffer = new Buffer(this.buffer.length + diff);
+	            var buffer = Buffer.alloc(this.buffer.length + diff);
 	            this.buffer.copy(buffer, len, offset, this.buffer.length);
 	            this.buffer = buffer;
 	            this.offset += diff;
@@ -19648,7 +19648,7 @@ function requireBytebufferNode () {
 	                throw RangeError("Illegal capacity: 0 <= "+capacity);
 	        }
 	        if (this.buffer.length < capacity) {
-	            var buffer = new Buffer(capacity);
+	            var buffer = Buffer.alloc(capacity);
 	            this.buffer.copy(buffer);
 	            this.buffer = buffer;
 	        }
@@ -19747,7 +19747,7 @@ function requireBytebufferNode () {
 	                throw RangeError("Illegal range: 0 <= "+offset+" <= "+limit+" <= "+this.buffer.length);
 	        }
 	        if (forceCopy) {
-	            var buffer = new Buffer(limit - offset);
+	            var buffer = Buffer.alloc(limit - offset);
 	            this.buffer.copy(buffer, 0, offset, limit);
 	            return buffer;
 	        } else {
@@ -19853,7 +19853,7 @@ function requireBytebufferNode () {
 	     * @expose
 	     */
 	    ByteBuffer.fromBase64 = function(str, littleEndian) {
-	        return ByteBuffer.wrap(new Buffer(str, "base64"), littleEndian);
+	        return ByteBuffer.wrap(Buffer.from(str, "base64"), littleEndian);
 	    };
 
 	    /**
@@ -19908,7 +19908,7 @@ function requireBytebufferNode () {
 	     * @expose
 	     */
 	    ByteBuffer.fromBinary = function(str, littleEndian) {
-	        return ByteBuffer.wrap(new Buffer(str, "binary"), littleEndian);
+	        return ByteBuffer.wrap(Buffer.from(str, "binary"), littleEndian);
 	    };
 
 	    // encodings/debug
@@ -20140,7 +20140,7 @@ function requireBytebufferNode () {
 	                throw TypeError("Illegal str: Length not a multiple of 2");
 	        }
 	        var bb = new ByteBuffer(0, littleEndian, true);
-	        bb.buffer = new Buffer(str, "hex");
+	        bb.buffer = Buffer.from(str, "hex");
 	        bb.limit = bb.buffer.length;
 	        return bb;
 	    };
@@ -20383,7 +20383,7 @@ function requireBytebufferNode () {
 	            if (typeof str !== 'string')
 	                throw TypeError("Illegal str: Not a string");
 	        var bb = new ByteBuffer(0, littleEndian, noAssert);
-	        bb.buffer = new Buffer(str, "utf8");
+	        bb.buffer = Buffer.from(str, "utf8");
 	        bb.limit = bb.buffer.length;
 	        return bb;
 	    };
@@ -21992,6 +21992,132 @@ if (typeof BigInt === "function") {
   };
 }
 
+/**
+ * Chain-safe JSON normalization for account_update operations.
+ * Matches steem::protocol::account_update_operation and authority (FC_REFLECT).
+ * Broadcast via JSON-RPC uses fc::from_variant; malformed shapes cause bad_cast_exception.
+ */
+/** Steem broadcast JSON requires json_metadata to be a string (not object/array). */
+function normalizeChainJsonMetadata(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    if (Array.isArray(value))
+        return value.length === 0 ? '' : JSON.stringify(value);
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
+function toAuthPairs(raw) {
+    if (Array.isArray(raw)) {
+        return raw
+            .filter((entry) => Array.isArray(entry) && entry.length >= 2)
+            .map(([key, weight]) => [String(key), Number(weight)])
+            .filter(([, weight]) => Number.isFinite(weight));
+    }
+    if (raw && typeof raw === 'object') {
+        return Object.entries(raw)
+            .map(([key, weight]) => [String(key), Number(weight)])
+            .filter(([, weight]) => Number.isFinite(weight));
+    }
+    return [];
+}
+function toKeyAuthPairs(raw) {
+    if (Array.isArray(raw)) {
+        return raw
+            .filter((entry) => Array.isArray(entry) && entry.length >= 2)
+            .map(([key, weight]) => [String(key), Number(weight)])
+            .filter(([key, weight]) => key.startsWith('STM') && Number.isFinite(weight));
+    }
+    if (raw && typeof raw === 'object') {
+        return Object.entries(raw)
+            .map(([key, weight]) => [String(key), Number(weight)])
+            .filter(([key, weight]) => key.startsWith('STM') && Number.isFinite(weight));
+    }
+    return [];
+}
+/** Normalize API authority data (handles object-maps and malformed arrays). */
+function normalizeAuthoritySource(source) {
+    if (Array.isArray(source) || !source || typeof source !== 'object') {
+        return { weight_threshold: 1, account_auths: [], key_auths: [] };
+    }
+    const obj = source;
+    const weight_threshold = Math.max(1, Number(obj.weight_threshold) || 1);
+    return {
+        weight_threshold,
+        account_auths: toAuthPairs(obj.account_auths),
+        key_auths: toKeyAuthPairs(obj.key_auths),
+    };
+}
+function sanitizeAuthority(value, field) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Invalid ${field} authority: expected object with weight_threshold, account_auths, key_auths`);
+    }
+    const obj = value;
+    const weight_threshold = Math.max(1, Number(obj.weight_threshold) || 1);
+    const account_auths = toAuthPairs(obj.account_auths);
+    const key_auths = toKeyAuthPairs(obj.key_auths);
+    if (key_auths.length === 0) {
+        throw new Error(`Invalid ${field} authority: key_auths is empty or malformed`);
+    }
+    return { weight_threshold, account_auths, key_auths };
+}
+/** Coerce account_update operation payload to chain-safe JSON (for signing and broadcast). */
+function sanitizeAccountUpdatePayload(payload) {
+    return {
+        account: String(payload.account || ''),
+        owner: sanitizeAuthority(payload.owner, 'owner'),
+        active: sanitizeAuthority(payload.active, 'active'),
+        posting: sanitizeAuthority(payload.posting, 'posting'),
+        memo_key: String(payload.memo_key || ''),
+        json_metadata: normalizeChainJsonMetadata(payload.json_metadata),
+    };
+}
+/**
+ * Normalize an operation tuple before signing or JSON broadcast.
+ * Only account_update is rewritten; other operations pass through unchanged.
+ */
+function normalizeOperationForBroadcast(operation) {
+    if (!Array.isArray(operation) || operation.length !== 2) {
+        return operation;
+    }
+    const [opType, opData] = operation;
+    if (opType !== 'account_update') {
+        return operation;
+    }
+    if (!opData || typeof opData !== 'object' || Array.isArray(opData)) {
+        throw new Error('account_update payload must be an object');
+    }
+    return ['account_update', sanitizeAccountUpdatePayload(opData)];
+}
+/** Normalize transaction operations/extensions for JSON broadcast after signing. */
+function normalizeTransactionForBroadcast(trx) {
+    const operations = Array.isArray(trx.operations) ? trx.operations : [];
+    const extensions = Array.isArray(trx.extensions) ? trx.extensions : [];
+    return {
+        ...trx,
+        operations: operations.map((op) => normalizeOperationForBroadcast(op)),
+        extensions,
+    };
+}
+/**
+ * Authority value for binary serialization (fail-fast on array mistaken for object).
+ * Mirrors steem wallet_api::update_account which assigns authority structs, not key_auths arrays.
+ */
+function resolveAuthorityForSerialize(auth, field) {
+    if (auth == null || auth === '') {
+        throw new Error(`Invalid ${field} authority: value is required`);
+    }
+    if (Array.isArray(auth)) {
+        throw new Error(`Invalid ${field} authority: expected object, got array (wrap key_auths inside an authority object)`);
+    }
+    if (typeof auth !== 'object') {
+        throw new Error(`Invalid ${field} authority: expected object`);
+    }
+    return auth;
+}
+
 /**
  * Serialize a transaction to binary format for Steem blockchain
  * This is a simplified implementation that handles the basic structure
@@ -22358,21 +22484,21 @@ function serializeAccountUpdate(bb, data) {
     // 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: [] });
+        serializeAuthority(bb, resolveAuthorityForSerialize(dataObj.owner, 'owner'));
     }
     else {
         bb.writeUint8(0);
     }
     if (dataObj.active != null && dataObj.active !== '') {
         bb.writeUint8(1);
-        serializeAuthority(bb, typeof dataObj.active === 'object' ? dataObj.active : { weight_threshold: 1, account_auths: [], key_auths: [] });
+        serializeAuthority(bb, resolveAuthorityForSerialize(dataObj.active, 'active'));
     }
     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: [] });
+        serializeAuthority(bb, resolveAuthorityForSerialize(dataObj.posting, 'posting'));
     }
     else {
         bb.writeUint8(0);
@@ -23020,6 +23146,12 @@ function serializeCustomJson(bb, data) {
  * Serialize Authority
  */
 function serializeAuthority(bb, auth) {
+    if (Array.isArray(auth)) {
+        throw new Error('Invalid authority: expected object, got array');
+    }
+    if (auth == null || typeof auth !== 'object') {
+        throw new Error('Invalid authority: expected object');
+    }
     const authObj = auth;
     bb.writeUint32(authObj.weight_threshold || 1);
     // Account auths (map<string, uint16>)
@@ -23355,17 +23487,18 @@ const Auth = {
         if (Array.isArray(trxObjWithSigs.signatures)) {
             signatures.push(...trxObjWithSigs.signatures.map((sig) => Buffer.isBuffer(sig) ? sig.toString('hex') : String(sig)));
         }
+        const trxObj = trx;
+        const normalizedTrx = normalizeTransactionForBroadcast(trxObj);
         const chainId = getConfig().get('chain_id') || '';
         const cid = Buffer.from(chainId, 'hex');
-        const buf = transaction.toBuffer(trx);
+        const buf = transaction.toBuffer(normalizedTrx);
         for (const key of keys) {
             const sig = Signature.signBuffer(Buffer.concat([cid, buf]), key);
             // Use toBuffer() to match old-steem-js behavior
             // The serializer will convert Buffer to hex string when needed
             signatures.push(sig.toBuffer().toString('hex'));
         }
-        const trxObj = trx;
-        return signed_transaction.toObject(Object.assign(trxObj, { signatures }));
+        return signed_transaction.toObject(Object.assign({}, normalizedTrx, { signatures }));
     }
 };
 // Export individual functions
@@ -23445,6 +23578,12 @@ var auth = /*#__PURE__*/Object.freeze({
     getPublicKey: getPublicKey,
     isPubkey: isPubkey,
     isWif: isWif,
+    normalizeAuthoritySource: normalizeAuthoritySource,
+    normalizeChainJsonMetadata: normalizeChainJsonMetadata,
+    normalizeOperationForBroadcast: normalizeOperationForBroadcast,
+    normalizeTransactionForBroadcast: normalizeTransactionForBroadcast,
+    resolveAuthorityForSerialize: resolveAuthorityForSerialize,
+    sanitizeAccountUpdatePayload: sanitizeAccountUpdatePayload,
     sign: sign$1,
     signTransaction: signTransaction,
     toWif: toWif,
@@ -26253,7 +26392,7 @@ const steem = {
     memo,
     operations,
     utils: utils$3,
-    version: '1.0.16',
+    version: '1.0.18',
     config: {
         set: (options) => {
             // If nodes is provided, extract the first node as url for API