@steemit/steem-js 1.0.8 → 1.0.10

package/dist/config.d.ts

@@ -1,7 +1,5 @@
 interface SteemConfig {
-    node?: string;
     nodes?: string[];
-    uri?: string;
     address_prefix?: string;
     chain_id?: string;
     debug?: boolean;

package/dist/index.cjs

@@ -51,12 +51,10 @@ class Config {
 const DEFAULT_CONFIG = {
     address_prefix: 'STM',
     chain_id: '0000000000000000000000000000000000000000000000000000000000000000',
-    // Default API endpoint: api.steemit.com
-    node: 'https://api.steemit.com',
+    // Default API endpoints: api.steemit.com
     nodes: [
         'https://api.steemit.com'
-    ],
-    uri: 'https://api.steemit.com'
+    ]
 };
 // Singleton config instance
 const config = new Config();
@@ -294,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) {
@@ -337,7 +335,7 @@ function requireBn$1 () {
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -3769,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))
@@ -3836,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();
@@ -6062,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();
@@ -7368,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();
@@ -8182,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();
@@ -9423,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();
@@ -9452,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) {
@@ -9495,7 +9493,7 @@ function requireBn () {
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -14427,24 +14425,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') {
@@ -14455,7 +14453,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.');
 }
 
 /**
@@ -15408,11 +15406,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,
@@ -15420,7 +15418,7 @@ function requireRetry$1 () {
 		  });
 		};
 
-		exports$1.timeouts = function(options) {
+		exports.timeouts = function(options) {
 		  if (options instanceof Array) {
 		    return [].concat(options);
 		  }
@@ -15457,7 +15455,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;
@@ -15468,7 +15466,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;
@@ -15488,7 +15486,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();
 
@@ -15581,15 +15579,15 @@ 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 uri - The URI to the JSON-RPC endpoint
+ * @param url - The URL to the JSON-RPC endpoint
  * @param request - The JSON-RPC request object
  * @param fetchMethod - Optional fetch implementation (defaults to global fetch)
  * @param timeoutMs - Request timeout in milliseconds (default: 30000)
  * @returns Promise resolving to the JSON-RPC result
  */
-const jsonRpc = async (uri, request, fetchMethod = fetch, timeoutMs = 30000) => {
+const jsonRpc = async (url, request, fetchMethod = fetch, timeoutMs = 30000) => {
     const payload = {
         jsonrpc: '2.0',
         ...request
@@ -15602,7 +15600,7 @@ const jsonRpc = async (uri, request, fetchMethod = fetch, timeoutMs = 30000) =>
         }, timeoutMs);
     });
     // Create the fetch promise
-    const fetchPromise = fetchMethod(uri, {
+    const fetchPromise = fetchMethod(url, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -15651,9 +15649,9 @@ class HttpTransport extends BaseTransport {
         if (typeof callback !== 'function') {
             callback = () => { };
         }
-        const uri = this.options.uri;
-        if (!uri) {
-            throw new Error('HTTP transport requires a valid URI');
+        const url = this.options.url;
+        if (!url) {
+            throw new Error('HTTP transport requires a valid URL');
         }
         const fetchMethod = this.options.fetchMethod || fetch;
         const id = data.id;
@@ -15664,7 +15662,7 @@ class HttpTransport extends BaseTransport {
         if (!isBroadcast && retryOptions) {
             const operation = typeof retryOptions === 'object' ? retry.operation(retryOptions) : retry.operation();
             operation.attempt((currentAttempt) => {
-                fetchMethod(uri, {
+                fetchMethod(url, {
                     method: 'POST',
                     body: JSON.stringify({
                         jsonrpc: '2.0',
@@ -15698,7 +15696,7 @@ class HttpTransport extends BaseTransport {
             });
         }
         else {
-            fetchMethod(uri, {
+            fetchMethod(url, {
                 method: 'POST',
                 body: JSON.stringify({
                     jsonrpc: '2.0',
@@ -15928,7 +15926,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;
@@ -20673,7 +20671,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();
@@ -22638,7 +22636,6 @@ class Api extends events.EventEmitter {
     _setTransport(options) {
         // Use HTTP transport only
         if (options.url && options.url.match(/^((http|https)?:\/\/)/)) {
-            options.uri = options.url;
             options.transport = 'http';
             this._transportType = options.transport;
             this.options = options;
@@ -22664,9 +22661,10 @@ class Api extends events.EventEmitter {
             }
         }
         else {
-            // Default to HTTP for https://api.steemit.com
-            const defaultNode = getConfig().get('node') || 'https://api.steemit.com';
-            options.uri = defaultNode;
+            // Default to HTTP using first node from config.nodes
+            const nodes = getConfig().get('nodes') || ['https://api.steemit.com'];
+            const defaultNode = nodes[0] || 'https://api.steemit.com';
+            options.url = defaultNode;
             options.transport = 'http';
             this._transportType = options.transport;
             this.options = options;
@@ -22749,9 +22747,28 @@ class Api extends events.EventEmitter {
         }
         const id = ++this.seqNo;
         const fetchMethod = this.options.fetchMethod || fetch;
-        jsonRpc(this.options.uri, { method, params, id }, fetchMethod)
+        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'));
@@ -22767,9 +22784,30 @@ class Api extends events.EventEmitter {
             return;
         }
         const fetchMethod = this.options.fetchMethod || fetch;
-        jsonRpc(this.options.uri, request, fetchMethod)
+        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
@@ -22832,6 +22870,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);
@@ -22844,9 +22900,9 @@ class Api extends events.EventEmitter {
             getConfig().set('address_prefix', options.useTestNet ? 'TST' : 'STM');
         }
     }
-    setUri(url) {
+    setUrl(url) {
         this.setOptions({
-            uri: url
+            url: url
         });
     }
     streamBlockNumber(mode = 'head', callback, ts = 200) {
@@ -23006,6 +23062,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
@@ -23025,6 +23099,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
@@ -23073,6 +23165,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
@@ -23088,6 +23199,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
@@ -23103,6 +23232,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
@@ -23176,15 +23323,17 @@ class Api extends events.EventEmitter {
     }
 }
 // Export singleton instance for compatibility
-const api$1 = new Api({ uri: getConfig().get('uri') || 'https://api.steemit.com' });
+// Use first node from config.nodes array
+const nodes = getConfig().get('nodes') || ['https://api.steemit.com'];
+const api = new Api({ url: nodes[0] || 'https://api.steemit.com' });
 function setOptions(options) {
-    api$1.setOptions(options);
+    api.setOptions(options);
 }
 // Export async variants and listeners for compatibility with tests
-api$1.getDynamicGlobalPropertiesAsync;
-api$1.getBlockAsync;
-api$1.getFollowersAsync;
-api$1.getContentAsync;
+api.getDynamicGlobalPropertiesAsync;
+api.getBlockAsync;
+api.getFollowersAsync;
+api.getContentAsync;
 
 const operations$1 = [
     {
@@ -25593,8 +25742,8 @@ const verify = (message, signature, publicKey) => {
     }
 };
 
-// Create the API instance
-const api = new Api();
+// Use the singleton API instance exported from api module
+// This ensures steem.api and setOptions() operate on the same instance
 // Create the main steem object with all modules
 const steem = {
     api,
@@ -25605,10 +25754,15 @@ const steem = {
     operations,
     serializer,
     utils: utils$3,
-    version: '1.0.8',
+    version: '1.0.10',
     config: {
         set: (options) => {
-            setOptions(options);
+            // If nodes is provided, extract the first node as url for API
+            const apiOptions = { ...options };
+            if (options.nodes && Array.isArray(options.nodes) && options.nodes.length > 0) {
+                apiOptions.url = options.nodes[0];
+            }
+            setOptions(apiOptions);
             setOptions$1(options);
         },
         get: (key) => getConfig().get(key),
@@ -25640,6 +25794,7 @@ if (typeof window !== 'undefined' || typeof globalThis !== 'undefined') {
     }
 }
 
+exports.Api = Api;
 exports.doubleSha256 = doubleSha256;
 exports.generateKeyPair = generateKeyPair;
 exports.hmacSha256 = hmacSha256;