@steemit/steem-js 1.0.17 → 1.0.19

package/dist/index.umd.js

@@ -24986,6 +24986,153 @@
 	  };
 	}
 
+	/**
+	 * Chain-safe JSON normalization for `account_update` operations.
+	 *
+	 * Protocol types (steem/libraries/protocol):
+	 * - `authority` — weight_threshold (uint32), account_auths / key_auths (fc::flat_map)
+	 * - `account_update_operation` — account, optional owner/active/posting, memo_key, json_metadata (string)
+	 *
+	 * JSON-RPC (`condenser_api.broadcast_transaction` → fc::from_variant):
+	 * - `authority` is a variant_object, not a bare key_auths array.
+	 * - `fc::flat_map` serializes as an array of [key, weight] pairs (see fc/container/flat.hpp),
+	 *   not a JSON object `{ "key": weight }` — object maps cause bad_cast_exception.
+	 * - `json_metadata` must be a string (protocol `string`), not a parsed JSON object.
+	 *
+	 * Binary signing (transaction digest) uses the same logical fields; the serializer packs
+	 * flat_maps as sorted on-wire maps (see serializeAuthority in serializer/transaction.ts).
+	 */
+	/**
+	 * Coerce `json_metadata` to protocol `string` (FC string field).
+	 * Node rejects object/array variants with bad_cast when broadcasting.
+	 */
+	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);
+	}
+	/**
+	 * Parse fc::flat_map JSON (pair array) or mistaken object-map input into pair arrays.
+	 * Broadcast output always uses pair arrays per fc::from_variant(flat_map).
+	 */
+	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 (get_accounts-style input; accepts pair arrays or object maps). */
+	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 protocol JSON shape for signing and broadcast.
+	 * Emits fc::flat_map fields as pair arrays, not object maps.
+	 */
+	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
@@ -25343,8 +25490,9 @@
 	    writeString(bb, String(dataObj.json_metadata || ''));
 	}
 	/**
-	 * Serialize account_update operation.
-	 * Format: account, optional owner (1 byte + authority?), optional active, optional posting, memo_key, json_metadata.
+	 * Serialize account_update_operation (steem_operations.hpp).
+	 * JSON fields: account, owner/active/posting (authority objects), memo_key, json_metadata (string).
+	 * Optional authorities use a presence byte before serializeAuthority.
 	 */
 	function serializeAccountUpdate(bb, data) {
 	    const dataObj = data;
@@ -25352,21 +25500,21 @@
 	    // 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);
@@ -26011,46 +26159,50 @@
 	    writeString(bb, String(dataObj.json || '{}'));
 	}
 	/**
-	 * Serialize Authority
+	 * Read authority map fields for binary packing (on-wire sorted flat_map).
+	 * JSON-RPC uses fc::flat_map → array of [key, weight] pairs; object maps are accepted
+	 * here only so callers that forgot to normalize still sign the intended keys.
+	 */
+	function authorityMapEntries(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 [];
+	}
+	/**
+	 * Serialize steem::protocol::authority (weight_threshold + sorted account/key flat_maps).
 	 */
 	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>)
-	    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);
-	    });
+	    const accountAuths = authorityMapEntries(authObj.account_auths).sort((a, b) => a[0].localeCompare(b[0]));
 	    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]);
-	        }
+	    for (const [account, weight] of accountAuths) {
+	        writeString(bb, account);
+	        bb.writeUint16(weight);
 	    }
 	    // 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);
-	    });
+	    const keyAuths = authorityMapEntries(authObj.key_auths).sort((a, b) => a[0].localeCompare(b[0]));
 	    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);
-	        }
+	    for (const [keyStr, weight] of keyAuths) {
+	        const pubKey = PublicKey.fromStringOrThrow(keyStr);
+	        bb.append(pubKey.toBuffer());
+	        bb.writeUint16(weight);
 	    }
 	}
 	/**
@@ -26349,17 +26501,18 @@
 	        if (Array.isArray(trxObjWithSigs.signatures)) {
 	            signatures.push(...trxObjWithSigs.signatures.map((sig) => buffer.Buffer.isBuffer(sig) ? sig.toString('hex') : String(sig)));
 	        }
+	        const trxObj = trx;
+	        const normalizedTrx = normalizeTransactionForBroadcast(trxObj);
 	        const chainId = getConfig().get('chain_id') || '';
 	        const cid = buffer.Buffer.from(chainId, 'hex');
-	        const buf = transaction.toBuffer(trx);
+	        const buf = transaction.toBuffer(normalizedTrx);
 	        for (const key of keys) {
 	            const sig = Signature.signBuffer(buffer.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
@@ -26439,6 +26592,12 @@
 		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,
@@ -29260,7 +29419,7 @@
 	    operations,
 	    utils: utils$n,
 	    ...crypto$1,
-	    version: '1.0.17',
+	    version: '1.0.19',
 	    config: {
 	        set: (options) => {
 	            // If nodes is provided, extract the first node as url for API