@steemit/steem-js 1.0.9 → 1.0.11

package/dist/index.umd.js

@@ -1188,7 +1188,7 @@
 	 * @license  MIT
 	 */
 
-	(function (exports$1) {
+	(function (exports) {
 
 		const base64 = base64Js;
 		const ieee754$1 = ieee754;
@@ -1197,12 +1197,12 @@
 		    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
 		    : null;
 
-		exports$1.Buffer = Buffer;
-		exports$1.SlowBuffer = SlowBuffer;
-		exports$1.INSPECT_MAX_BYTES = 50;
+		exports.Buffer = Buffer;
+		exports.SlowBuffer = SlowBuffer;
+		exports.INSPECT_MAX_BYTES = 50;
 
 		const K_MAX_LENGTH = 0x7fffffff;
-		exports$1.kMaxLength = K_MAX_LENGTH;
+		exports.kMaxLength = K_MAX_LENGTH;
 
 		/**
 		 * If `Buffer.TYPED_ARRAY_SUPPORT`:
@@ -1798,7 +1798,7 @@
 
 		Buffer.prototype.inspect = function inspect () {
 		  let str = '';
-		  const max = exports$1.INSPECT_MAX_BYTES;
+		  const max = exports.INSPECT_MAX_BYTES;
 		  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim();
 		  if (this.length > max) str += ' ... ';
 		  return '<Buffer ' + str + '>'
@@ -3308,7 +3308,7 @@
 	bn$1.exports;
 
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -3351,7 +3351,7 @@
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -6770,9 +6770,9 @@
 
 	var utils$l = {};
 
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 
 		function toArray(msg, enc) {
 		  if (Array.isArray(msg))
@@ -6830,9 +6830,9 @@
 		}; 
 	} (utils$l));
 
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 		var BN = bnExports$1;
 		var minAssert = minimalisticAssert;
 		var minUtils = utils$l;
@@ -8984,9 +8984,9 @@
 	Point.prototype.toP = Point.prototype.normalize;
 	Point.prototype.mixedAdd = Point.prototype.add;
 
-	(function (exports$1) {
+	(function (exports) {
 
-		var curve = exports$1;
+		var curve = exports;
 
 		curve.base = base$1;
 		curve.short = short;
@@ -10189,8 +10189,8 @@
 	  return this.outer.digest(enc);
 	};
 
-	(function (exports$1) {
-		var hash = exports$1;
+	(function (exports) {
+		var hash = exports;
 
 		hash.utils = utils$g;
 		hash.common = common$5;
@@ -10996,9 +10996,9 @@
 		return secp256k1$3;
 	}
 
-	(function (exports$1) {
+	(function (exports) {
 
-		var curves = exports$1;
+		var curves = exports;
 
 		var hash = hash$2;
 		var curve$1 = curve;
@@ -12167,9 +12167,9 @@
 	  return val instanceof this.pointClass;
 	};
 
-	(function (exports$1) {
+	(function (exports) {
 
-		var elliptic = exports$1;
+		var elliptic = exports;
 
 		elliptic.version = require$$0$1.version;
 		elliptic.utils = utils$m;
@@ -12187,7 +12187,7 @@
 	bn.exports;
 
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -12230,7 +12230,7 @@
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -16928,6 +16928,77 @@
 	    const finalS = s.gt(N_OVER_TWO) ? n.sub(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) {
+	    if ((i & 3) !== i) {
+	        throw new Error('Recovery param is more than two bits');
+	    }
+	    const n = new BN(curve.n.toString());
+	    const r = signature.r;
+	    const s = signature.s;
+	    if (r.isNeg() || r.isZero() || !r.lt(n))
+	        throw new Error('Invalid r value');
+	    if (s.isNeg() || s.isZero() || !s.lt(n))
+	        throw new Error('Invalid s value');
+	    // Try using elliptic's built-in recoverPubKey method
+	    // It expects: msg (Buffer), signature ({r: BN, s: BN}), j (recovery param)
+	    try {
+	        // Convert e (BN) to Buffer
+	        const msgBuffer = e.toArrayLike(buffer.Buffer, 'be', 32);
+	        // Create signature object compatible with elliptic's recoverPubKey
+	        // elliptic expects {r: BN, s: BN} format
+	        const sigObj = { r: r, s: s };
+	        // Use elliptic's built-in method
+	        const Q = curve.recoverPubKey(msgBuffer, sigObj, i);
+	        return Q;
+	    }
+	    catch (error) {
+	        // Fallback to manual implementation if elliptic's method fails
+	        const G = curve.g;
+	        // 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;
+	        // pointFromX expects a hex string (not BN object)
+	        // Convert BN to hex string and ensure proper padding
+	        const xHex = x.toString(16);
+	        // Ensure hex string is properly padded to 64 characters (32 bytes)
+	        const xHexPadded = xHex.padStart(64, '0');
+	        // pointFromX may also accept a Buffer, but hex string is more reliable
+	        let R;
+	        try {
+	            R = curve.curve.pointFromX(xHexPadded, isYOdd);
+	        }
+	        catch (error) {
+	            // If hex string fails, try with Buffer
+	            const xBuffer = x.toArrayLike(buffer.Buffer, 'be', 32);
+	            R = curve.curve.pointFromX(xBuffer, isYOdd);
+	        }
+	        // 1.4 Check that nR is at infinity
+	        const nR = R.mul(n);
+	        if (!nR.isInfinity())
+	            throw new Error('nR is not a valid curve point');
+	        // Compute -e from e
+	        const eNeg = e.neg().mod(n);
+	        // 1.6.1 Compute Q = r^-1 (sR -  eG)
+	        //               Q = r^-1 (sR + -eG)
+	        const rInv = r.invm(n);
+	        const sR = R.mul(s);
+	        const eGNeg = G.mul(eNeg);
+	        const Q = sR.add(eGNeg).mul(rInv);
+	        return Q;
+	    }
+	}
 	/**
 	 * Calculate pubkey extraction parameter.
 	 *
@@ -16942,11 +17013,15 @@
 	function calcPubKeyRecoveryParam(curve, e, signature, Q) {
 	    for (let i = 0; i < 4; i++) {
 	        try {
-	            // Use elliptic's built-in recovery method
-	            const Qprime = curve.recoverPubKey(e, signature, i);
+	            // Use our own recoverPubKey function instead of curve.recoverPubKey
+	            const Qprime = recoverPubKey(curve, e, signature, i);
 	            // 1.6.2 Verify Q = Q'
-	            // Compare points by checking if they are the same point
-	            if (Qprime.eq(Q)) {
+	            // Compare points by checking coordinates (more reliable than eq method)
+	            const Qx = Q.getX().toString(16);
+	            const Qy = Q.getY().toString(16);
+	            const QprimeX = Qprime.getX().toString(16);
+	            const QprimeY = Qprime.getY().toString(16);
+	            if (Qx === QprimeX && Qy === QprimeY) {
 	                return i;
 	            }
 	        }
@@ -16980,7 +17055,13 @@
 	            throw new Error('Invalid signature length');
 	        }
 	        const i = buffer.readUInt8(0);
-	        if ((i - 27) !== ((i - 27) & 7)) {
+	        // Support both formats: 27-30 (old/legacy) and 31-34 (dsteem compatible)
+	        // Check if it's in the old format (27-30) or new format (31-34)
+	        const recoveryOld = i - 27;
+	        const recoveryNew = i - 31;
+	        const isValidOld = recoveryOld >= 0 && recoveryOld <= 3 && (recoveryOld === (recoveryOld & 7));
+	        const isValidNew = recoveryNew >= 0 && recoveryNew <= 3 && (recoveryNew === (recoveryNew & 7));
+	        if (!isValidOld && !isValidNew) {
 	            throw new Error('Invalid signature parameter');
 	        }
 	        const r = new BN(buffer.slice(1, 33));
@@ -17029,7 +17110,9 @@
 	            }
 	        }
 	        const i = calcPubKeyRecoveryParam(secp256k1, new BN(buf_sha256), ecsignature, privKey.toPublic().Q);
-	        return new Signature(ecsignature.r, ecsignature.s, i + 27);
+	        // Use recovery byte 31-34 (instead of 27-30) to be compatible with dsteem
+	        // dsteem expects: recovery = byte - 31, so byte = recovery + 31
+	        return new Signature(ecsignature.r, ecsignature.s, i + 31);
 	    }
 	    static isCanonical(r, s) {
 	        // See libraries/fc/src/crypto/elliptic_common.cpp is_fc_canonical
@@ -17160,24 +17243,24 @@
 	 * @returns Buffer with random bytes
 	 */
 	function randomBytes(size) {
-	    // Always try Web Crypto API first (works in both browser and Node.js 18+)
+	    // Always try Web Crypto API first (works in both browser and Node.js 20.19+)
 	    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
 	        const array = new Uint8Array(size);
 	        crypto.getRandomValues(array);
 	        return buffer.Buffer.from(array);
 	    }
 	    // Fallback to Node.js crypto only if Web Crypto API is not available
-	    // This code path should not be reached in Node.js 18+ (which has Web Crypto API)
+	    // This code path should not be reached in Node.js 20.19+ (which has Web Crypto API)
 	    // and is kept as a safety fallback for edge cases.
 	    // In browser builds, Rollup will tree-shake this code away because
 	    // the condition above will always be true in browsers.
 	    //
-	    // Note: This SDK requires Node.js >= 18.0.0 (see package.json engines field).
-	    // Node.js 18+ has Web Crypto API, so this fallback is rarely needed.
-	    // In ESM mode, require is undefined, but since Node.js 18+ has Web Crypto API,
+	    // Note: This SDK requires Node.js >= 20.19.0 (see package.json engines field).
+	    // Node.js 20.19+ has Web Crypto API, so this fallback is rarely needed.
+	    // In ESM mode, require is undefined, but since Node.js 20.19+ has Web Crypto API,
 	    // this code path won't be reached in ESM mode with the minimum required version.
 	    try {
-	        // Use dynamic require as a safety fallback (for Node.js < 18 edge cases)
+	        // Use dynamic require as a safety fallback (for Node.js < 20.19 edge cases)
 	        // eslint-disable-next-line @typescript-eslint/no-require-imports
 	        const nodeCrypto = typeof require !== 'undefined' ? require('crypto') : null;
 	        if (nodeCrypto && typeof nodeCrypto.randomBytes === 'function') {
@@ -17188,7 +17271,7 @@
 	        // Ignore require errors in browser environments or ESM mode
 	    }
 	    // If neither Web Crypto API nor Node.js crypto is available, throw error
-	    throw new Error('Random bytes generation is not available. This library requires either Web Crypto API (browser/Node.js 18+) or Node.js crypto module.');
+	    throw new Error('Random bytes generation is not available. This library requires either Web Crypto API (browser/Node.js 20.19+) or Node.js crypto module.');
 	}
 
 	/**
@@ -18128,11 +18211,11 @@
 	  return mainError;
 	};
 
-	(function (exports$1) {
+	(function (exports) {
 		var RetryOperation = retry_operation;
 
-		exports$1.operation = function(options) {
-		  var timeouts = exports$1.timeouts(options);
+		exports.operation = function(options) {
+		  var timeouts = exports.timeouts(options);
 		  return new RetryOperation(timeouts, {
 		      forever: options && (options.forever || options.retries === Infinity),
 		      unref: options && options.unref,
@@ -18140,7 +18223,7 @@
 		  });
 		};
 
-		exports$1.timeouts = function(options) {
+		exports.timeouts = function(options) {
 		  if (options instanceof Array) {
 		    return [].concat(options);
 		  }
@@ -18177,7 +18260,7 @@
 		  return timeouts;
 		};
 
-		exports$1.createTimeout = function(attempt, opts) {
+		exports.createTimeout = function(attempt, opts) {
 		  var random = (opts.randomize)
 		    ? (Math.random() + 1)
 		    : 1;
@@ -18188,7 +18271,7 @@
 		  return timeout;
 		};
 
-		exports$1.wrap = function(obj, options, methods) {
+		exports.wrap = function(obj, options, methods) {
 		  if (options instanceof Array) {
 		    methods = options;
 		    options = null;
@@ -18208,7 +18291,7 @@
 		    var original = obj[method];
 
 		    obj[method] = function retryWrapper(original) {
-		      var op       = exports$1.operation(options);
+		      var op       = exports.operation(options);
 		      var args     = Array.prototype.slice.call(arguments, 1);
 		      var callback = args.pop();
 
@@ -18290,7 +18373,7 @@
 	}
 	/**
 	 * Makes a JSON-RPC request using native fetch API
-	 * Universal implementation that works in both Node.js (18+) and browser
+	 * Universal implementation that works in both Node.js (20.19+) and browser
 	 *
 	 * @param url - The URL to the JSON-RPC endpoint
 	 * @param request - The JSON-RPC request object
@@ -18637,7 +18720,7 @@
 			            if (value >= TWO_PWR_64_DBL)
 			                return MAX_UNSIGNED_VALUE;
 			        } else {
-			            if (value <= -TWO_PWR_63_DBL)
+			            if (value <= -9223372036854776e3)
 			                return MIN_VALUE;
 			            if (value + 1 >= TWO_PWR_63_DBL)
 			                return MAX_VALUE;
@@ -23666,7 +23749,7 @@
 	    if (value < 0) return UZERO;
 	    if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;
 	  } else {
-	    if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;
+	    if (value <= -9223372036854776e3) return MIN_VALUE;
 	    if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;
 	  }
 	  if (value < 0) return fromNumber(-value, unsigned).neg();
@@ -25745,6 +25828,25 @@
 	        jsonRpc(this.options.url, { method, params, id }, fetchMethod)
 	            .then(res => { callback(null, res); }, err => { callback(err); });
 	    }
+	    /**
+	     * Promise-based version of call
+	     * Makes a JSON-RPC call to the Steem blockchain
+	     * @param method Method name (e.g., 'condenser_api.get_accounts')
+	     * @param params Parameters array for the method
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    callAsync(method, params) {
+	        return new Promise((resolve, reject) => {
+	            this.call(method, params, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    signedCall(method, params, account, key, callback) {
 	        if (this._transportType !== 'http') {
 	            callback(new Error('RPC methods can only be called when using http transport'));
@@ -25763,6 +25865,27 @@
 	        jsonRpc(this.options.url, request, fetchMethod)
 	            .then(res => { callback(null, res); }, err => { callback(err); });
 	    }
+	    /**
+	     * Promise-based version of signedCall
+	     * Makes an authenticated JSON-RPC call with cryptographic signature
+	     * @param method Method name (e.g., 'conveyor.is_email_registered')
+	     * @param params Parameters array for the method
+	     * @param account Account name to sign the request with
+	     * @param key Private key (WIF) to sign the request
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    signedCallAsync(method, params, account, key) {
+	        return new Promise((resolve, reject) => {
+	            this.signedCall(method, params, account, key, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Verify a signed RPC request
 	     * @param signedRequest The signed request to verify
@@ -25825,6 +25948,24 @@
 	                .catch(error => callback(error instanceof Error ? error : new Error(String(error))));
 	        }).catch(callback);
 	    }
+	    /**
+	     * Promise-based version of verifySignedRequest
+	     * Verifies a signed RPC request
+	     * @param signedRequest The signed request to verify
+	     * @returns Promise that resolves with verification result or rejects with an error
+	     */
+	    verifySignedRequestAsync(signedRequest) {
+	        return new Promise((resolve, reject) => {
+	            this.verifySignedRequest(signedRequest, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    setOptions(options) {
 	        Object.assign(this.options, options);
 	        this._setLogger(options);
@@ -25999,6 +26140,24 @@
 	        }
 	        this.broadcastTransactionSynchronous(trx, callback);
 	    }
+	    /**
+	     * Promise-based version of broadcastTransactionSynchronousWith
+	     * Broadcasts a transaction synchronously
+	     * @param options Options object containing the transaction
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    broadcastTransactionSynchronousWithAsync(options) {
+	        return new Promise((resolve, reject) => {
+	            this.broadcastTransactionSynchronousWith(options, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Broadcast a transaction to the blockchain.
 	     * @param trx The transaction object
@@ -26018,6 +26177,24 @@
 	            callback(new Error('broadcastTransaction is not implemented'));
 	        }
 	    }
+	    /**
+	     * Promise-based version of broadcastTransaction
+	     * Broadcasts a transaction to the blockchain
+	     * @param trx The transaction object
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    broadcastTransactionAsync(trx) {
+	        return new Promise((resolve, reject) => {
+	            this.broadcastTransaction(trx, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Sign a transaction with the provided private key(s).
 	     * @param trx The transaction object
@@ -26066,6 +26243,25 @@
 	            params: [confirmationCallback, trx]
 	        }, callback);
 	    }
+	    /**
+	     * Promise-based version of broadcastTransactionWithCallback
+	     * Note: The confirmationCallback will still be called when the transaction is confirmed
+	     * @param confirmationCallback Callback function for transaction confirmation
+	     * @param trx Transaction object to broadcast
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    broadcastTransactionWithCallbackAsync(confirmationCallback, trx) {
+	        return new Promise((resolve, reject) => {
+	            this.broadcastTransactionWithCallback(confirmationCallback, trx, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Broadcast a block to the network.
 	     * @param block Block object to broadcast
@@ -26081,6 +26277,24 @@
 	            params: [block]
 	        }, callback);
 	    }
+	    /**
+	     * Promise-based version of broadcastBlock
+	     * Broadcasts a block to the network
+	     * @param block Block object to broadcast
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    broadcastBlockAsync(block) {
+	        return new Promise((resolve, reject) => {
+	            this.broadcastBlock(block, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Set the maximum block age for transaction acceptance.
 	     * @param maxBlockAge Maximum block age in seconds
@@ -26096,6 +26310,24 @@
 	            params: [maxBlockAge]
 	        }, callback);
 	    }
+	    /**
+	     * Promise-based version of setMaxBlockAge
+	     * Sets the maximum block age for transaction acceptance
+	     * @param maxBlockAge Maximum block age in seconds
+	     * @returns Promise that resolves with the result or rejects with an error
+	     */
+	    setMaxBlockAgeAsync(maxBlockAge) {
+	        return new Promise((resolve, reject) => {
+	            this.setMaxBlockAge(maxBlockAge, (err, result) => {
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    resolve(result);
+	                }
+	            });
+	        });
+	    }
 	    /**
 	     * Verify transaction authority.
 	     * @param trx Transaction object to verify
@@ -28612,7 +28844,7 @@
 	    serializer,
 	    utils: utils$n,
 	    ...crypto$1,
-	    version: '1.0.9',
+	    version: '1.0.11',
 	    config: {
 	        set: (options) => {
 	            // If nodes is provided, extract the first node as url for API