@steemit/steem-js 1.0.8 → 1.0.10

package/README.md

@@ -17,7 +17,7 @@ A modern JavaScript/TypeScript library for interacting with the Steem blockchain
 
 ### Requirements
 
-- **Node.js**: >= 18.0.0 (LTS recommended)
+- **Node.js**: >= 20.19.0 (LTS recommended)
 - **Browser**: Modern browsers with Web Crypto API support
 
 ### Installation
@@ -40,7 +40,7 @@ import { steem } from '@steemit/steem-js';
 
 // Configure API endpoint
 steem.config.set({
-  node: 'https://api.steemit.com',
+  nodes: ['https://api.steemit.com'],
   address_prefix: 'STM'
 });
 
@@ -58,7 +58,7 @@ await steem.broadcast.voteAsync(postingWif, 'voter', 'author', 'permlink', 10000
 ```html
 <script src="https://cdn.jsdelivr.net/npm/@steemit/steem-js/dist/index.umd.min.js"></script>
 <script>
-  steem.config.set({ node: 'https://api.steemit.com' });
+  steem.config.set({ nodes: ['https://api.steemit.com'] });
   steem.api.getAccountsAsync(['username']).then(console.log);
 </script>
 ```

package/dist/api/index.d.ts

@@ -3,7 +3,6 @@ import type { Transport } from './transports/types';
 import type { TransportOptions } from './transports/types';
 interface ApiOptions {
     url?: string;
-    uri?: string;
     transport?: string | (new (options: TransportOptions) => Transport);
     logger?: Logger;
     useTestNet?: boolean;
@@ -30,15 +29,43 @@ export declare class Api extends EventEmitter {
     stop(): Promise<void>;
     send(api: string, data: unknown, callback: unknown): void | Promise<void>;
     call(method: string, params: unknown[], callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: string, params: unknown[]): Promise<unknown>;
     signedCall(method: string, params: unknown[], account: string, key: string, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: string, params: unknown[], account: string, key: string): Promise<unknown>;
     /**
      * Verify a signed RPC request
      * @param signedRequest The signed request to verify
      * @param callback Callback function
      */
     verifySignedRequest(signedRequest: unknown, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: unknown): Promise<{
+        valid: boolean;
+        params: unknown;
+    }>;
     setOptions(options: ApiOptions): void;
-    setUri(url: string): void;
+    setUrl(url: string): void;
     streamBlockNumber(mode?: string | ((err: Error | null, blockNumber?: unknown) => void), callback?: (err: Error | null, blockNumber?: unknown) => void, ts?: number): () => void;
     streamBlock(mode: string | undefined, callback: (err: Error | null, block?: unknown) => void): () => void;
     streamTransactions(mode?: string | ((err: Error | null, tx?: unknown) => void), callback?: (err: Error | null, tx?: unknown) => void): () => void;
@@ -46,12 +73,28 @@ export declare class Api extends EventEmitter {
     broadcastTransactionSynchronousWith(options: {
         transaction: unknown;
     }, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: {
+        transaction: unknown;
+    }): Promise<unknown>;
     /**
      * Broadcast a transaction to the blockchain.
      * @param trx The transaction object
      * @param callback Callback function
      */
     broadcastTransaction(trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: unknown): Promise<unknown>;
     /**
      * Sign a transaction with the provided private key(s).
      * @param trx The transaction object
@@ -76,18 +119,40 @@ export declare class Api extends EventEmitter {
      * @param callback Callback function
      */
     broadcastTransactionWithCallback(confirmationCallback: (result: unknown) => void, trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: (result: unknown) => void, trx: unknown): Promise<unknown>;
     /**
      * Broadcast a block to the network.
      * @param block Block object to broadcast
      * @param callback Callback function
      */
     broadcastBlock(block: unknown, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: unknown): Promise<unknown>;
     /**
      * Set the maximum block age for transaction acceptance.
      * @param maxBlockAge Maximum block age in seconds
      * @param callback Callback function
      */
     setMaxBlockAge(maxBlockAge: number, callback: (err: Error | null, result?: unknown) => void): void;
+    /**
+     * 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: number): Promise<unknown>;
     /**
      * Verify transaction authority.
      * @param trx Transaction object to verify

package/dist/api/transports/http.d.ts

@@ -2,15 +2,15 @@ import { TransportOptions, JsonRpcRequest } from './types';
 import { BaseTransport } from './base';
 /**
  * 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
  */
-export declare const jsonRpc: (uri: string, request: Partial<JsonRpcRequest>, fetchMethod?: typeof fetch, timeoutMs?: number) => Promise<unknown>;
+export declare const jsonRpc: (url: string, request: Partial<JsonRpcRequest>, fetchMethod?: typeof fetch, timeoutMs?: number) => Promise<unknown>;
 export declare class HttpTransport extends BaseTransport {
     constructor(options: TransportOptions);
     get nonRetriableOperations(): string[];

package/dist/api/transports/types.d.ts

@@ -1,11 +1,10 @@
 export interface TransportOptions {
     url?: string;
-    uri?: string;
     /**
      * WebSocket URL
      * NOTE: WebSocket functionality is currently not supported.
      * This field is kept for backward compatibility only.
-     * Please use HTTP transport (via url or uri field) for API calls.
+     * Please use HTTP transport (via url field) for API calls.
      */
     websocket?: string;
     transport?: string | unknown;