@steemit/steem-js 1.0.9 → 1.0.11

package/dist/index.cjs

@@ -292,7 +292,7 @@ function requireBn$1 () {
 	if (hasRequiredBn$1) return bn$1.exports;
 	hasRequiredBn$1 = 1;
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -335,7 +335,7 @@ function requireBn$1 () {
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -3767,9 +3767,9 @@ var hasRequiredUtils$2;
 function requireUtils$2 () {
 	if (hasRequiredUtils$2) return utils$1;
 	hasRequiredUtils$2 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 
 		function toArray(msg, enc) {
 		  if (Array.isArray(msg))
@@ -3834,9 +3834,9 @@ var hasRequiredUtils$1;
 function requireUtils$1 () {
 	if (hasRequiredUtils$1) return utils$2;
 	hasRequiredUtils$1 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var utils = exports$1;
+		var utils = exports;
 		var BN = requireBn$1();
 		var minAssert = requireMinimalisticAssert();
 		var minUtils = requireUtils$2();
@@ -6060,9 +6060,9 @@ var hasRequiredCurve;
 function requireCurve () {
 	if (hasRequiredCurve) return curve;
 	hasRequiredCurve = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var curve = exports$1;
+		var curve = exports;
 
 		curve.base = requireBase();
 		curve.short = requireShort();
@@ -7366,8 +7366,8 @@ var hasRequiredHash;
 function requireHash () {
 	if (hasRequiredHash) return hash;
 	hasRequiredHash = 1;
-	(function (exports$1) {
-		var hash = exports$1;
+	(function (exports) {
+		var hash = exports;
 
 		hash.utils = requireUtils();
 		hash.common = requireCommon$1();
@@ -8180,9 +8180,9 @@ var hasRequiredCurves;
 function requireCurves () {
 	if (hasRequiredCurves) return curves;
 	hasRequiredCurves = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var curves = exports$1;
+		var curves = exports;
 
 		var hash = requireHash();
 		var curve = requireCurve();
@@ -9421,9 +9421,9 @@ var hasRequiredElliptic;
 function requireElliptic () {
 	if (hasRequiredElliptic) return elliptic;
 	hasRequiredElliptic = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		var elliptic = exports$1;
+		var elliptic = exports;
 
 		elliptic.version = require$$0$1.version;
 		elliptic.utils = requireUtils$1();
@@ -9450,7 +9450,7 @@ function requireBn () {
 	if (hasRequiredBn) return bn.exports;
 	hasRequiredBn = 1;
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -9493,7 +9493,7 @@ function requireBn () {
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -14193,6 +14193,77 @@ function sign$3(curve, hash, d, nonce) {
     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, '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, '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.
  *
@@ -14207,11 +14278,15 @@ function sign$3(curve, hash, d, nonce) {
 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;
             }
         }
@@ -14245,7 +14320,13 @@ class Signature {
             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));
@@ -14294,7 +14375,9 @@ class Signature {
             }
         }
         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
@@ -14425,24 +14508,24 @@ class Address {
  * @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.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') {
@@ -14453,7 +14536,7 @@ function randomBytes(size) {
         // 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.');
 }
 
 /**
@@ -15406,11 +15489,11 @@ var hasRequiredRetry$1;
 function requireRetry$1 () {
 	if (hasRequiredRetry$1) return retry$2;
 	hasRequiredRetry$1 = 1;
-	(function (exports$1) {
+	(function (exports) {
 		var RetryOperation = requireRetry_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,
@@ -15418,7 +15501,7 @@ function requireRetry$1 () {
 		  });
 		};
 
-		exports$1.timeouts = function(options) {
+		exports.timeouts = function(options) {
 		  if (options instanceof Array) {
 		    return [].concat(options);
 		  }
@@ -15455,7 +15538,7 @@ function requireRetry$1 () {
 		  return timeouts;
 		};
 
-		exports$1.createTimeout = function(attempt, opts) {
+		exports.createTimeout = function(attempt, opts) {
 		  var random = (opts.randomize)
 		    ? (Math.random() + 1)
 		    : 1;
@@ -15466,7 +15549,7 @@ function requireRetry$1 () {
 		  return timeout;
 		};
 
-		exports$1.wrap = function(obj, options, methods) {
+		exports.wrap = function(obj, options, methods) {
 		  if (options instanceof Array) {
 		    methods = options;
 		    options = null;
@@ -15486,7 +15569,7 @@ function requireRetry$1 () {
 		    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();
 
@@ -15579,7 +15662,7 @@ class JsonRpcError extends Error {
 }
 /**
  * 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
@@ -15926,7 +16009,7 @@ function requireLong () {
 		            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;
@@ -20671,7 +20754,7 @@ function fromNumber(value, unsigned) {
     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();
@@ -22750,6 +22833,25 @@ class Api extends events.EventEmitter {
         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'));
@@ -22768,6 +22870,27 @@ class Api extends events.EventEmitter {
         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
@@ -22830,6 +22953,24 @@ class Api extends events.EventEmitter {
                 .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);
@@ -23004,6 +23145,24 @@ class Api extends events.EventEmitter {
         }
         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
@@ -23023,6 +23182,24 @@ class Api extends events.EventEmitter {
             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
@@ -23071,6 +23248,25 @@ class Api extends events.EventEmitter {
             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
@@ -23086,6 +23282,24 @@ class Api extends events.EventEmitter {
             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
@@ -23101,6 +23315,24 @@ class Api extends events.EventEmitter {
             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
@@ -25605,7 +25837,7 @@ const steem = {
     operations,
     serializer,
     utils: utils$3,
-    version: '1.0.9',
+    version: '1.0.11',
     config: {
         set: (options) => {
             // If nodes is provided, extract the first node as url for API
@@ -25652,6 +25884,8 @@ exports.hmacSha256 = hmacSha256;
 exports.ripemd160 = ripemd160;
 exports.sha256 = sha256;
 exports.sign = sign;
+exports.signRequest = sign$2;
 exports.steem = steem;
+exports.validateRequest = validate;
 exports.verify = verify;
 //# sourceMappingURL=index.cjs.map