@steemit/steem-js 1.0.9 → 1.0.11

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

package/dist/api/index.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'events';
 import type { Transport } from './transports/types';
 import type { TransportOptions } from './transports/types';
+import type { ApiMethodSignatures } from './types';
 interface ApiOptions {
     url?: string;
     transport?: string | (new (options: TransportOptions) => Transport);
@@ -20,6 +21,11 @@ export declare class Api extends EventEmitter {
     private transport;
     private options;
     private __logger;
+    [key: string]: unknown;
+    getAccounts: ApiMethodSignatures['getAccounts'];
+    getAccountsAsync: ApiMethodSignatures['getAccountsAsync'];
+    getAccountsWith: ApiMethodSignatures['getAccountsWith'];
+    getAccountsWithAsync: ApiMethodSignatures['getAccountsWithAsync'];
     private static _wrapWithPromise;
     constructor(options?: ApiOptions);
     private _setTransport;
@@ -29,13 +35,41 @@ 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;
     setUrl(url: string): void;
     streamBlockNumber(mode?: string | ((err: Error | null, blockNumber?: unknown) => void), callback?: (err: Error | null, blockNumber?: unknown) => void, ts?: number): () => void;
@@ -45,12 +79,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
@@ -75,18 +125,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,7 +2,7 @@ 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 url - The URL to the JSON-RPC endpoint
  * @param request - The JSON-RPC request object

package/dist/api/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Type definitions for dynamically generated API methods
+ * These types provide TypeScript support for all API methods
+ */
+export type ApiCallback<T = unknown> = (err: Error | null, result?: T) => void;
+type ApiMethodWithParams<TResult = unknown> = (...args: unknown[]) => Promise<TResult> | void;
+type ApiMethodNoParams<TResult = unknown> = (callback?: ApiCallback<TResult>) => Promise<TResult> | void;
+type ApiMethodWith<TResult = unknown> = (options: Record<string, unknown>, callback?: ApiCallback<TResult>) => Promise<TResult> | void;
+type ApiMethodAsync<TParams extends unknown[] = unknown[], TResult = unknown> = (...args: TParams) => Promise<TResult>;
+type ApiMethodWithAsync<TResult = unknown> = (options: Record<string, unknown>) => Promise<TResult>;
+/**
+ * Type definitions for all API methods
+ * This interface provides type safety for dynamically generated methods
+ */
+export interface ApiMethodSignatures {
+    getAccounts(accounts: string[], callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getAccountsAsync(accounts: string[]): Promise<any[]>;
+    getAccountsWith(options: {
+        names: string[];
+    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getAccountsWithAsync(options: {
+        names: string[];
+    }): Promise<any[]>;
+    getAccountHistory(account: string, from: number, limit: number, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getAccountHistoryAsync(account: string, from: number, limit: number): Promise<any[]>;
+    getAccountHistoryWith(options: {
+        account: string;
+        from: number;
+        limit: number;
+    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getAccountHistoryWithAsync(options: {
+        account: string;
+        from: number;
+        limit: number;
+    }): Promise<any[]>;
+    getDynamicGlobalProperties(callback?: ApiCallback<any>): Promise<any> | void;
+    getDynamicGlobalPropertiesAsync(): Promise<any>;
+    getDynamicGlobalPropertiesWith(options: Record<string, unknown>, callback?: ApiCallback<any>): Promise<any> | void;
+    getDynamicGlobalPropertiesWithAsync(options: Record<string, unknown>): Promise<any>;
+    getContent(author: string, permlink: string, callback?: ApiCallback<any>): Promise<any> | void;
+    getContentAsync(author: string, permlink: string): Promise<any>;
+    getContentWith(options: {
+        author: string;
+        permlink: string;
+    }, callback?: ApiCallback<any>): Promise<any> | void;
+    getContentWithAsync(options: {
+        author: string;
+        permlink: string;
+    }): Promise<any>;
+    getFollowers(following: string, startFollower: string, followType: string, limit: number, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getFollowersAsync(following: string, startFollower: string, followType: string, limit: number): Promise<any[]>;
+    getFollowersWith(options: {
+        following: string;
+        startFollower: string;
+        followType: string;
+        limit: number;
+    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    getFollowersWithAsync(options: {
+        following: string;
+        startFollower: string;
+        followType: string;
+        limit: number;
+    }): Promise<any[]>;
+    getBlock(blockNum: number, callback?: ApiCallback<any>): Promise<any> | void;
+    getBlockAsync(blockNum: number): Promise<any>;
+    getBlockWith(options: {
+        blockNum: number;
+    }, callback?: ApiCallback<any>): Promise<any> | void;
+    getBlockWithAsync(options: {
+        blockNum: number;
+    }): Promise<any>;
+    getConfig(callback?: ApiCallback<any>): Promise<any> | void;
+    getConfigAsync(): Promise<any>;
+    getConfigWith(options: Record<string, unknown>, callback?: ApiCallback<any>): Promise<any> | void;
+    getConfigWithAsync(options: Record<string, unknown>): Promise<any>;
+    [methodName: string]: ApiMethodWithParams | ApiMethodNoParams | ApiMethodWith | ApiMethodAsync<unknown[]> | ApiMethodWithAsync | unknown;
+}
+export {};