@steemit/steem-js 1.0.4 → 1.0.6

package/README.md

@@ -1,5 +1,7 @@
 # Steem.js
 
+> ⚠️ Under Construction: This SDK is currently under active development.  Do not use it in the production environment.
+
 A modern JavaScript/TypeScript library for interacting with the Steem blockchain. Complete refactoring with TypeScript, modern tooling, and improved security.
 
 [![npm version](https://img.shields.io/npm/v/@steemit/steem-js.svg)](https://www.npmjs.com/package/@steemit/steem-js)
@@ -13,6 +15,11 @@ A modern JavaScript/TypeScript library for interacting with the Steem blockchain
 
 ## 🚀 Quick Start
 
+### Requirements
+
+- **Node.js**: >= 18.0.0 (LTS recommended)
+- **Browser**: Modern browsers with Web Crypto API support
+
 ### Installation
 
 ```bash
@@ -86,6 +93,7 @@ This is a complete modernization of the original steem-js library:
 
 - ✅ **TypeScript Migration** - Full type safety and better developer experience
 - ✅ **Modern Dependencies** - Replaced outdated crypto libraries (`bigi` → `bn.js`, `ecurve` → `elliptic`)
+- ✅ **Modern Crypto** - Using @noble/hashes and @noble/ciphers for universal browser/Node.js compatibility
 - ✅ **Build System** - Migrated from Webpack to Rollup for better output
 - ✅ **Testing** - Migrated from Mocha to Vitest with 95.8% test coverage
 - ✅ **Security** - Fixed insecure random number generation and crypto implementations
@@ -94,7 +102,7 @@ This is a complete modernization of the original steem-js library:
 
 ```
 src/
-├── api/          # Blockchain API client (HTTP/WebSocket)
+├── api/          # Blockchain API client (HTTP)
 ├── auth/         # Authentication and key management
 ├── broadcast/    # Transaction broadcasting
 ├── crypto/       # Cryptographic utilities

package/dist/api/index.d.ts

@@ -1,19 +1,19 @@
 import { EventEmitter } from 'events';
-import Bluebird from 'bluebird';
+import type { Transport } from './transports/types';
+import type { TransportOptions } from './transports/types';
 interface ApiOptions {
     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.
-     */
-    websocket?: string;
-    transport?: string | any;
-    logger?: any;
+    transport?: string | (new (options: TransportOptions) => Transport);
+    logger?: Logger;
     useTestNet?: boolean;
     useAppbaseApi?: boolean;
+    fetchMethod?: typeof fetch;
+    [key: string]: unknown;
+}
+interface Logger {
+    log: (...args: unknown[]) => void;
+    [key: string]: (...args: unknown[]) => void;
 }
 export declare class Api extends EventEmitter {
     private seqNo;
@@ -25,47 +25,40 @@ export declare class Api extends EventEmitter {
     constructor(options?: ApiOptions);
     private _setTransport;
     private _setLogger;
-    log(logLevel: string, ...args: any[]): void;
-    start(): any;
-    stop(): any;
-    send(api: string, data: any, callback: any): any;
-    call(method: string, params: any[], callback: any): void;
-    signedCall(method: string, params: any[], account: string, key: string, callback: any): void;
-    setOptions(options: ApiOptions): void;
+    log(logLevel: string, ...args: unknown[]): void;
+    start(): Promise<void>;
+    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;
+    signedCall(method: string, params: unknown[], account: string, key: string, callback: (err: Error | null, result?: unknown) => void): void;
     /**
-     * Set WebSocket URL
-     *
-     * NOTE: WebSocket functionality is currently not supported.
-     * This method is kept for backward compatibility only.
-     * Please use HTTP transport (via setOptions({ url: 'https://api.steemit.com' })) for API calls.
+     * Verify a signed RPC request
+     * @param signedRequest The signed request to verify
+     * @param callback Callback function
      */
-    setWebSocket(url: string): void;
+    verifySignedRequest(signedRequest: unknown, callback: (err: Error | null, result?: unknown) => void): void;
+    setOptions(options: ApiOptions): void;
     setUri(url: string): void;
-    streamBlockNumber(mode: string | undefined, callback: any, ts?: number): () => void;
-    streamBlock(mode: string | undefined, callback: any): () => void;
-    streamTransactions(mode: string | undefined, callback: any): () => void;
-    streamOperations(mode: string | undefined, callback: any): () => void;
-    broadcastTransactionSynchronousWith(options: any, callback: any): 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;
+    streamOperations(mode?: string | ((err: Error | null, op?: unknown) => void), callback?: (err: Error | null, op?: unknown) => void): () => void;
+    broadcastTransactionSynchronousWith(options: {
+        transaction: unknown;
+    }, callback: (err: Error | null, result?: unknown) => void): void;
     /**
      * Broadcast a transaction to the blockchain.
      * @param trx The transaction object
      * @param callback Callback function
      */
-    broadcastTransaction(trx: any, callback: any): void;
+    broadcastTransaction(trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
     /**
      * Sign a transaction with the provided private key(s).
      * @param trx The transaction object
      * @param keys Array of WIF private keys
      * @returns Signed transaction object
      */
-    signTransaction(trx: any, keys: string[]): any;
-    /**
-     * Get a single account by name (backward compatibility).
-     * @param name The account name
-     * @param callback Optional callback
-     * @returns Account object or Promise
-     */
-    getAccount(name: string, callback?: (err: any, result?: any) => void): Bluebird<any> | void;
+    signTransaction(trx: unknown, keys: string[]): unknown;
     /**
      * Get followers for an account (backward compatibility).
      * @param account The account name
@@ -75,33 +68,33 @@ export declare class Api extends EventEmitter {
      * @param callback Optional callback
      * @returns Array of followers or Promise
      */
-    getFollowers(account: string, startFollower: string, type: string, limit: number, callback?: (err: any, result?: any) => void): Bluebird<any[]> | void;
+    getFollowers(account: string, startFollower: string, type: string, limit: number, callback?: (err: Error | null, result?: unknown[]) => void): Promise<unknown[]> | void;
     /**
      * Broadcast a transaction with a confirmation callback.
      * @param confirmationCallback Callback function for transaction confirmation
      * @param trx Transaction object to broadcast
      * @param callback Callback function
      */
-    broadcastTransactionWithCallback(confirmationCallback: any, trx: any, callback: any): void;
+    broadcastTransactionWithCallback(confirmationCallback: (result: unknown) => void, trx: unknown, callback: (err: Error | null, result?: unknown) => void): void;
     /**
      * Broadcast a block to the network.
      * @param block Block object to broadcast
      * @param callback Callback function
      */
-    broadcastBlock(block: any, callback: any): void;
+    broadcastBlock(block: unknown, callback: (err: Error | null, result?: unknown) => void): void;
     /**
      * Set the maximum block age for transaction acceptance.
      * @param maxBlockAge Maximum block age in seconds
      * @param callback Callback function
      */
-    setMaxBlockAge(maxBlockAge: number, callback: any): void;
+    setMaxBlockAge(maxBlockAge: number, callback: (err: Error | null, result?: unknown) => void): void;
     /**
      * Verify transaction authority.
      * @param trx Transaction object to verify
      * @param callback Optional callback function
      * @returns Promise with verification result if no callback provided
      */
-    verifyAuthority(trx: any, callback?: (err: any, result?: boolean) => void): Bluebird<boolean> | void;
+    verifyAuthority(trx: unknown, callback?: (err: Error | null, result?: boolean) => void): Promise<boolean> | void;
     /**
      * Verify account authority.
      * @param nameOrId Account name or ID
@@ -109,20 +102,22 @@ export declare class Api extends EventEmitter {
      * @param callback Optional callback function
      * @returns Promise with verification result if no callback provided
      */
-    verifyAccountAuthority(nameOrId: string, signers: string[], callback?: (err: any, result?: boolean) => void): Bluebird<boolean> | void;
+    verifyAccountAuthority(nameOrId: string, signers: string[], callback?: (err: Error | null, result?: boolean) => void): Promise<boolean> | void;
 }
 declare const api: Api;
 export declare function setOptions(options: ApiOptions): void;
-export declare function call(method: string, params: any[], callback: any): void;
-export declare function signTransaction(trx: any, keys: string[]): any;
-export declare function verifyAuthority(..._args: any[]): boolean;
+export declare function call(method: string, params: unknown[], callback: (err: Error | null, result?: unknown) => void): void;
+export declare function signTransaction(trx: unknown, keys: string[]): unknown;
+export declare function verifyAuthority(..._args: unknown[]): boolean;
 export default api;
-export declare const getDynamicGlobalPropertiesAsync: any;
-export declare const getBlockAsync: any;
-export declare const getFollowersAsync: any;
-export declare const getContentAsync: any;
-export declare const listeners: (...args: any[]) => any;
-export declare const streamBlockNumber: (...args: any[]) => any;
-export declare const streamBlock: (...args: any[]) => any;
-export declare const streamTransactions: (...args: any[]) => any;
-export declare const streamOperations: (...args: any[]) => any;
+export declare const getDynamicGlobalPropertiesAsync: () => Promise<unknown>;
+export declare const getBlockAsync: (...args: unknown[]) => Promise<unknown>;
+export declare const getFollowersAsync: (...args: unknown[]) => Promise<unknown>;
+export declare const getContentAsync: (...args: unknown[]) => Promise<unknown>;
+export declare const listeners: (...args: unknown[]) => unknown;
+export declare const streamBlockNumber: (...args: unknown[]) => unknown;
+export declare const streamBlock: (...args: unknown[]) => unknown;
+export declare const streamTransactions: (...args: unknown[]) => unknown;
+export declare const streamOperations: (...args: unknown[]) => unknown;
+export { sign as signRequest, validate as validateRequest } from './rpc-auth';
+export * as signatureVerification from './signature-verification';

package/dist/api/rpc-auth.d.ts

@@ -1,6 +1,6 @@
 interface RpcRequest {
     method: string;
-    params: any[];
+    params: unknown[];
     id: number;
 }
 interface SignedRequest {
@@ -34,7 +34,7 @@ export declare function sign(request: RpcRequest, account: string, keys: string[
  * @param verify Function to verify signatures against public keys
  * @returns Resolved request params
  */
-export declare function validate(request: SignedRequest, verify: (message: Buffer, signatures: string[], account: string) => Promise<void>): Promise<any>;
+export declare function validate(request: SignedRequest, verify: (message: Buffer, signatures: string[], account: string) => Promise<void>): Promise<unknown>;
 declare const _default: {
     sign: typeof sign;
     validate: typeof validate;

package/dist/api/signature-verification.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Signature Verification Utilities for Steem.js
+ *
+ * This module provides comprehensive signature verification functionality
+ * for signed RPC requests and general message signatures.
+ */
+export interface SignedRequest {
+    jsonrpc: string;
+    method: string;
+    id: number;
+    params: {
+        __signed: {
+            account: string;
+            nonce: string;
+            params: string;
+            signatures: string[];
+            timestamp: string;
+        };
+    };
+}
+export interface VerificationResult {
+    valid: boolean;
+    account?: string;
+    params?: unknown;
+    error?: string;
+    timestamp?: string;
+    signatures?: string[];
+}
+export interface AccountKeys {
+    owner: string[];
+    active: string[];
+    posting: string[];
+    memo: string;
+}
+/**
+ * Verify a signed RPC request against account's public keys
+ */
+export declare function verifySignedRequest(signedRequest: SignedRequest, getAccountKeys: (account: string) => Promise<AccountKeys>): Promise<VerificationResult>;
+/**
+ * Verify a simple message signature
+ */
+export declare function verifyMessageSignature(message: string | Buffer, signature: string, publicKey: string): boolean;
+/**
+ * Verify multiple signatures against multiple public keys
+ */
+export declare function verifyMultipleSignatures(message: string | Buffer, signatures: string[], publicKeys: string[]): {
+    verified: boolean;
+    validSignatures: number;
+    details: Array<{
+        signature: string;
+        publicKey: string;
+        valid: boolean;
+    }>;
+};
+/**
+ * Extract account keys from Steem account data
+ */
+export declare function extractAccountKeys(accountData: unknown): AccountKeys;
+/**
+ * Create a verification function for use with API calls
+ */
+export declare function createApiVerificationFunction(api: {
+    call: (method: string, params: unknown[], callback: (err: Error | null, result?: unknown) => void) => void;
+}): (account: string) => Promise<AccountKeys>;
+/**
+ * Batch verify multiple signed requests
+ */
+export declare function batchVerifySignedRequests(signedRequests: SignedRequest[], getAccountKeys: (account: string) => Promise<AccountKeys>): Promise<VerificationResult[]>;
+/**
+ * Check if a signature is expired
+ */
+export declare function isSignatureExpired(timestamp: string, maxAgeMs?: number): boolean;
+/**
+ * Validate signature format
+ */
+export declare function isValidSignatureFormat(signature: string): boolean;
+/**
+ * Validate public key format
+ */
+export declare function isValidPublicKeyFormat(publicKey: string): boolean;
+declare const _default: {
+    verifySignedRequest: typeof verifySignedRequest;
+    verifyMessageSignature: typeof verifyMessageSignature;
+    verifyMultipleSignatures: typeof verifyMultipleSignatures;
+    extractAccountKeys: typeof extractAccountKeys;
+    createApiVerificationFunction: typeof createApiVerificationFunction;
+    batchVerifySignedRequests: typeof batchVerifySignedRequests;
+    isSignatureExpired: typeof isSignatureExpired;
+    isValidSignatureFormat: typeof isValidSignatureFormat;
+    isValidPublicKeyFormat: typeof isValidPublicKeyFormat;
+};
+export default _default;

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

@@ -5,8 +5,8 @@ export declare class BaseTransport extends EventEmitter implements Transport {
     id: number;
     constructor(options?: TransportOptions);
     setOptions(options: TransportOptions): void;
-    listenTo(target: EventEmitter, eventName: string, callback: (...args: any[]) => void): () => void;
-    send(_api: string, _data: any, _callback: (error: any, result?: any) => void): void;
+    listenTo(target: EventEmitter, eventName: string, callback: (...args: unknown[]) => void): () => void;
+    send(_api: string, _data: unknown, _callback: (error: Error | null, result?: unknown) => void): void;
     start(): Promise<void>;
     stop(): Promise<void>;
 }

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

@@ -1,9 +1,23 @@
 import { TransportOptions, JsonRpcRequest } from './types';
 import { BaseTransport } from './base';
-export declare const jsonRpc: (uri: string, request: Partial<JsonRpcRequest>) => Promise<any>;
+/**
+ * Makes a JSON-RPC request using native fetch API
+ * Universal implementation that works in both Node.js (18+) and browser
+ *
+ * @param uri - The URI 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 class HttpTransport extends BaseTransport {
     constructor(options: TransportOptions);
     get nonRetriableOperations(): string[];
     isBroadcastOperation(method: string): boolean;
-    send(api: string, data: any, callback?: (err: any, result?: any, attempt?: number) => void): void;
+    send(api: string, data: {
+        id?: number;
+        method: string;
+        params: unknown[];
+    }, callback?: (err: Error | null, result?: unknown, attempt?: number) => void): void;
 }

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

@@ -1,9 +1,7 @@
 import { HttpTransport } from './http';
-import { WsTransport } from './ws';
 import { BaseTransport } from './base';
 export * from './types';
 export declare const transports: {
     http: typeof HttpTransport;
-    ws: typeof WsTransport;
 };
 export { BaseTransport };

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

@@ -8,22 +8,22 @@ export interface TransportOptions {
      * Please use HTTP transport (via url or uri field) for API calls.
      */
     websocket?: string;
-    transport?: string | any;
-    [key: string]: any;
+    transport?: string | unknown;
+    [key: string]: unknown;
 }
 export interface JsonRpcRequest {
     id: number;
     method: string;
-    params: any[];
+    params: unknown[];
     jsonrpc?: string;
 }
 export interface JsonRpcResponse {
     id: number;
-    result: any;
+    result: unknown;
     error?: {
         code: number;
         message: string;
-        data?: any;
+        data?: unknown;
     };
 }
 export interface Transport {
@@ -31,5 +31,5 @@ export interface Transport {
     start(): Promise<void>;
     stop(): Promise<void>;
     setOptions(options: TransportOptions): void;
-    send(api: string, data: any, callback: (error: any, result?: any) => void): void | Promise<void>;
+    send(api: string, data: unknown, callback: (error: Error | null, result?: unknown) => void): void | Promise<void>;
 }

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

@@ -11,6 +11,7 @@ export declare class WsTransport extends BaseTransport {
     private ws;
     private _requests;
     private seqNo;
+    private isBrowser;
     constructor(options: TransportOptions);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/auth/ecc/src/ecdsa.d.ts

@@ -2,7 +2,7 @@ import BN from 'bn.js';
 import ECSignature from './ecsignature';
 import { ec as EC } from 'elliptic';
 type ECInstance = EC;
-type ECPoint = any;
+type ECPoint = ReturnType<ECInstance['g']['mul']>;
 export declare function sign(curve: ECInstance, hash: Buffer, d: BN, nonce?: number): ECSignature;
 export declare function verify(curve: ECInstance, hash: Buffer, signature: ECSignature, Q: ECPoint): boolean;
 /**

package/dist/auth/ecc/src/enforce_types.d.ts

@@ -1,5 +1,5 @@
 type TypeName = 'Array' | 'Boolean' | 'Buffer' | 'Number' | 'String' | {
-    new (...args: any[]): any;
+    new (...args: unknown[]): unknown;
 };
-export default function enforce(type: TypeName, value: any): void;
+export default function enforce(type: TypeName, value: unknown): void;
 export {};

package/dist/auth/ecc/src/hash.d.ts

@@ -7,12 +7,14 @@ export declare function sha1(data: string | Buffer, encoding?: BufferEncoding):
     @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
     @return {string|Buffer} - Buffer when digest is null, or string
 */
-export declare function sha256(data: string | Buffer, encoding?: BufferEncoding): Buffer;
+export declare function sha256(data: string | Buffer): Buffer;
+export declare function sha256(data: string | Buffer, encoding: BufferEncoding): string;
 /** @arg {string|Buffer} data
     @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
     @return {string|Buffer} - Buffer when digest is null, or string
 */
-export declare function sha512(data: string | Buffer, encoding?: BufferEncoding): Buffer;
+export declare function sha512(data: string | Buffer): Buffer;
+export declare function sha512(data: string | Buffer, encoding: BufferEncoding): string;
 export declare function HmacSHA256(buffer: Buffer, secret: Buffer): Buffer;
 export declare function ripemd160(data: string | Buffer): Buffer;
 declare const _default: {

package/dist/auth/ecc/src/key_private.d.ts

@@ -1,6 +1,8 @@
+import { ec as EC } from 'elliptic';
+declare const secp256k1: EC;
 import BN from 'bn.js';
 import { PublicKey } from './key_public';
-type ECPoint = any;
+type ECPoint = ReturnType<typeof secp256k1.g.mul>;
 export declare class PrivateKey {
     d: BN;
     public_key?: PublicKey;

package/dist/auth/ecc/src/key_public.d.ts

@@ -1,4 +1,6 @@
-type ECPoint = any;
+import { ec as EC } from 'elliptic';
+declare const secp256k1: EC;
+type ECPoint = ReturnType<typeof secp256k1.g.mul>;
 export declare class PublicKey {
     Q: ECPoint | null;
     pubdata?: string;
@@ -11,27 +13,27 @@ export declare class PublicKey {
     toUncompressed(): PublicKey;
     /** bts::blockchain::address (unique but not a full public key) */
     toBlockchainAddress(): Buffer;
-    toString(address_prefix?: any): string;
+    toString(address_prefix?: string | undefined): string;
     /**
      * Full public key
      * {return} string
      */
-    toPublicKeyString(address_prefix?: any): string;
+    toPublicKeyString(address_prefix?: string | undefined): string;
     /**
      * @arg {string} public_key - like STMXyz...
      * @arg {string} address_prefix - like STM
      * @return PublicKey or `null` (if the public_key string is invalid)
      * @deprecated fromPublicKeyString (use fromString instead)
      */
-    static fromString(public_key: string, address_prefix?: any): PublicKey | null;
+    static fromString(public_key: string, address_prefix?: string | undefined): PublicKey | null;
     /**
      * @arg {string} public_key - like STMXyz...
      * @arg {string} address_prefix - like STM
      * @throws {Error} if public key is invalid
      * @return PublicKey
      */
-    static fromStringOrThrow(public_key: string, address_prefix?: any): PublicKey;
-    toAddressString(address_prefix?: any): string;
+    static fromStringOrThrow(public_key: string, address_prefix?: string | undefined): PublicKey;
+    toAddressString(address_prefix?: unknown): string;
     toPtsAddy(): string;
     child(offset: Buffer): PublicKey;
     static fromHex(hex: string): PublicKey;

package/dist/auth/index.d.ts

@@ -9,7 +9,7 @@ export interface Authority {
     key_auths: [string, number][];
 }
 export interface Auth {
-    verify(name: string, password: string, auths: any): boolean;
+    verify(name: string, password: string, auths: unknown): boolean;
     generateKeys(name: string, password: string, roles: string[]): {
         [key: string]: string;
     };
@@ -21,11 +21,11 @@ export interface Auth {
     wifIsValid(privWif: string, pubWif: string): boolean;
     wifToPublic(privWif: string): string;
     isPubkey(pubkey: string, address_prefix?: string): boolean;
-    signTransaction(trx: any, keys: string[]): any;
+    signTransaction(trx: unknown, keys: string[]): unknown;
 }
 export declare const Auth: Auth;
 export default Auth;
-export declare const verify: (name: string, password: string, auths: any) => boolean;
+export declare const verify: (name: string, password: string, auths: unknown) => boolean;
 export declare const generateKeys: (name: string, password: string, roles: string[]) => {
     [key: string]: string;
 };
@@ -39,10 +39,11 @@ export declare const wifToPublic: (privWif: string) => string;
 export declare const isPubkey: (pubkey: string, address_prefix?: string) => boolean;
 export { PrivateKey } from './ecc/src/key_private';
 export { PublicKey } from './ecc/src/key_public';
+export { Signature } from './ecc/src/signature';
 export { Address } from './ecc/src/address';
 export declare const sign: (message: string, privateKey: string) => string;
 export declare const verifySignature: (message: string, signature: string, publicKey: string) => boolean;
-export declare const verifyTransaction: (transaction: any, publicKey: string) => boolean;
+export declare const verifyTransaction: (transaction: unknown, publicKey: string) => boolean;
 export declare const getPublicKey: (privateKey: string) => string;
 export declare const getPrivateKey: (seed: string) => string;
-export declare const signTransaction: (trx: any, keys: string[]) => any;
+export declare const signTransaction: (trx: unknown, keys: string[]) => unknown;

package/dist/auth/serializer/transaction.d.ts

@@ -2,4 +2,4 @@
  * Serialize a transaction to binary format for Steem blockchain
  * This is a simplified implementation that handles the basic structure
  */
-export declare function serializeTransaction(trx: any): Buffer;
+export declare function serializeTransaction(trx: unknown): Buffer;

package/dist/auth/serializer.d.ts

@@ -11,9 +11,9 @@ export declare class Serializer {
     static toBuffer(memo: EncryptedMemo): Buffer;
 }
 export declare const transaction: {
-    toBuffer(trx: any): Buffer;
+    toBuffer(trx: unknown): Buffer;
 };
 export declare const signed_transaction: {
-    toObject(trx: any): any;
-    toBuffer(trx: any): Buffer;
+    toObject(trx: unknown): unknown;
+    toBuffer(trx: unknown): Buffer;
 };

package/dist/broadcast/helpers.d.ts

@@ -2,10 +2,29 @@ import { Operation } from './operations';
 export interface BroadcastOptions {
     roles: string[];
     operation: string;
-    params: any[];
+    params: unknown[];
 }
 export declare function getOperation(operation: string): Operation | undefined;
 export declare function validateOperation(options: BroadcastOptions): void;
-export declare function createOperation(options: BroadcastOptions): [string, any[]];
-export declare function createTransaction(operations: [string, any[]][]): any;
-export declare function createSignedTransaction(transaction: any, signatures: string[]): any;
+export declare function createOperation(options: BroadcastOptions): [string, unknown[]];
+export declare function createTransaction(operations: [string, unknown[]][]): {
+    ref_block_num: number;
+    ref_block_prefix: number;
+    expiration: string;
+    operations: [string, unknown[]][];
+    extensions: unknown[];
+};
+export declare function createSignedTransaction(transaction: {
+    ref_block_num: number;
+    ref_block_prefix: number;
+    expiration: string;
+    operations: [string, unknown[]][];
+    extensions: unknown[];
+}, signatures: string[]): {
+    ref_block_num: number;
+    ref_block_prefix: number;
+    expiration: string;
+    operations: [string, unknown[]][];
+    extensions: unknown[];
+    signatures: string[];
+};