@steemit/steem-js 1.0.8 → 1.0.10

package/dist/index.umd.js

@@ -2,18 +2,18 @@
   // Provide minimal polyfills for browser
   var g = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
   
-  // Process polyfill
+    // Process polyfill
   if (typeof g.process === 'undefined') {
     g.process = {
-      browser: true,
-      env: {},
-      version: '',
-      versions: {},
-      nextTick: function(fn) { setTimeout(fn, 0); },
-      exit: function() {},
-      cwd: function() { return '/'; },
-      platform: 'browser'
-    };
+        browser: true,
+        env: {},
+        version: '',
+        versions: {},
+        nextTick: function(fn) { setTimeout(fn, 0); },
+        exit: function() {},
+        cwd: function() { return '/'; },
+        platform: 'browser'
+      };
     if (typeof globalThis !== 'undefined') {
       globalThis.process = g.process;
     }
@@ -564,12 +564,10 @@
 	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();
@@ -1190,7 +1188,7 @@
 	 * @license  MIT
 	 */
 
-	(function (exports$1) {
+	(function (exports) {
 
 		const base64 = base64Js;
 		const ieee754$1 = ieee754;
@@ -1199,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`:
@@ -1800,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 + '>'
@@ -3310,7 +3308,7 @@
 	bn$1.exports;
 
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -3353,7 +3351,7 @@
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -6772,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))
@@ -6832,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;
@@ -8986,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;
@@ -10191,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;
@@ -10998,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;
@@ -12169,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;
@@ -12189,7 +12187,7 @@
 	bn.exports;
 
 	(function (module) {
-		(function (module, exports$1) {
+		(function (module, exports) {
 
 		  // Utils
 		  function assert (val, msg) {
@@ -12232,7 +12230,7 @@
 		  if (typeof module === 'object') {
 		    module.exports = BN;
 		  } else {
-		    exports$1.BN = BN;
+		    exports.BN = BN;
 		  }
 
 		  BN.BN = BN;
@@ -17162,24 +17160,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') {
@@ -17190,7 +17188,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.');
 	}
 
 	/**
@@ -18130,11 +18128,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,
@@ -18142,7 +18140,7 @@
 		  });
 		};
 
-		exports$1.timeouts = function(options) {
+		exports.timeouts = function(options) {
 		  if (options instanceof Array) {
 		    return [].concat(options);
 		  }
@@ -18179,7 +18177,7 @@
 		  return timeouts;
 		};
 
-		exports$1.createTimeout = function(attempt, opts) {
+		exports.createTimeout = function(attempt, opts) {
 		  var random = (opts.randomize)
 		    ? (Math.random() + 1)
 		    : 1;
@@ -18190,7 +18188,7 @@
 		  return timeout;
 		};
 
-		exports$1.wrap = function(obj, options, methods) {
+		exports.wrap = function(obj, options, methods) {
 		  if (options instanceof Array) {
 		    methods = options;
 		    options = null;
@@ -18210,7 +18208,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();
 
@@ -18292,15 +18290,15 @@
 	}
 	/**
 	 * 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
@@ -18313,7 +18311,7 @@
 	        }, timeoutMs);
 	    });
 	    // Create the fetch promise
-	    const fetchPromise = fetchMethod(uri, {
+	    const fetchPromise = fetchMethod(url, {
 	        method: 'POST',
 	        headers: {
 	            'Content-Type': 'application/json',
@@ -18362,9 +18360,9 @@
 	        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;
@@ -18375,7 +18373,7 @@
 	        if (!isBroadcast && retryOptions) {
 	            const operation = typeof retryOptions === 'object' ? retry$1.operation(retryOptions) : retry$1.operation();
 	            operation.attempt((currentAttempt) => {
-	                fetchMethod(uri, {
+	                fetchMethod(url, {
 	                    method: 'POST',
 	                    body: JSON.stringify({
 	                        jsonrpc: '2.0',
@@ -18409,7 +18407,7 @@
 	            });
 	        }
 	        else {
-	            fetchMethod(uri, {
+	            fetchMethod(url, {
 	                method: 'POST',
 	                body: JSON.stringify({
 	                    jsonrpc: '2.0',
@@ -18639,7 +18637,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;
@@ -23668,7 +23666,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();
@@ -25633,7 +25631,6 @@
 	    _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;
@@ -25659,9 +25656,10 @@
 	            }
 	        }
 	        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;
@@ -25744,9 +25742,28 @@
 	        }
 	        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'));
@@ -25762,9 +25779,30 @@
 	            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
@@ -25827,6 +25865,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);
@@ -25839,9 +25895,9 @@
 	            getConfig().set('address_prefix', options.useTestNet ? 'TST' : 'STM');
 	        }
 	    }
-	    setUri(url) {
+	    setUrl(url) {
 	        this.setOptions({
-	            uri: url
+	            url: url
 	        });
 	    }
 	    streamBlockNumber(mode = 'head', callback, ts = 200) {
@@ -26001,6 +26057,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
@@ -26020,6 +26094,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
@@ -26068,6 +26160,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
@@ -26083,6 +26194,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
@@ -26098,6 +26227,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
@@ -26171,15 +26318,17 @@
 	    }
 	}
 	// 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 = [
 	    {
@@ -28598,11 +28747,12 @@
 		verify: verify
 	});
 
-	// 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 - this will be the default export for UMD
 	const steem = {
 	    api,
+	    Api, // Export Api class for creating multiple instances
 	    auth,
 	    broadcast: broadcast$1,
 	    formatter,
@@ -28611,10 +28761,15 @@
 	    serializer,
 	    utils: utils$n,
 	    ...crypto$1,
-	    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),