@steemit/steem-js 0.7.11 → 1.0.0

package/README.md

@@ -1,116 +1,232 @@
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/steemit/steem-js/blob/master/LICENSE)
-[![Steem.js channel on steemit.chat](https://img.shields.io/badge/chat-steemit.chat-1c56a4.svg)](https://steemit.chat/channel/steemjs)
-
 # Steem.js
-Steem.js the JavaScript API for Steem blockchain
-
-# Documentation
-
-- [Install](https://github.com/steemit/steem-js/tree/master/doc#install)
-- [Browser](https://github.com/steemit/steem-js/tree/master/doc#browser)
-- [Config](https://github.com/steemit/steem-js/tree/master/doc#config)
-- [Database API](https://github.com/steemit/steem-js/tree/master/doc#api)
-    - [Subscriptions](https://github.com/steemit/steem-js/tree/master/doc#subscriptions)
-    - [Tags](https://github.com/steemit/steem-js/tree/master/doc#tags)
-    - [Blocks and transactions](https://github.com/steemit/steem-js/tree/master/doc#blocks-and-transactions)
-    - [Globals](https://github.com/steemit/steem-js/tree/master/doc#globals)
-    - [Keys](https://github.com/steemit/steem-js/tree/master/doc#keys)
-    - [Accounts](https://github.com/steemit/steem-js/tree/master/doc#accounts)
-    - [Market](https://github.com/steemit/steem-js/tree/master/doc#market)
-    - [Authority / validation](https://github.com/steemit/steem-js/tree/master/doc#authority--validation)
-    - [Votes](https://github.com/steemit/steem-js/tree/master/doc#votes)
-    - [Content](https://github.com/steemit/steem-js/tree/master/doc#content)
-    - [Witnesses](https://github.com/steemit/steem-js/tree/master/doc#witnesses)
-- [Login API](https://github.com/steemit/steem-js/tree/master/doc#login)
-- [Follow API](https://github.com/steemit/steem-js/tree/master/doc#follow-api)
-- [Broadcast API](https://github.com/steemit/steem-js/tree/master/doc#broadcast-api)
-- [Broadcast](https://github.com/steemit/steem-js/tree/master/doc#broadcast)
-- [Auth](https://github.com/steemit/steem-js/tree/master/doc#auth)
-
-
-Here is full documentation:
-https://github.com/steemit/steem-js/tree/master/doc
-
-## Browser
+
+Steem.js is a JavaScript/TypeScript library for interacting with the Steem blockchain.
+
+## Status
+
+This is a complete refactoring of the original steem-js library, migrating from JavaScript to TypeScript with modern tooling and improved code quality. Published as `@steemit/steem-js`.
+
+### Refactoring Progress
+
+- ✅ **TypeScript Migration**: Complete migration from JavaScript to TypeScript
+- ✅ **Build System**: Migrated from Webpack to Rollup
+- ✅ **Testing**: Migrated from Mocha to Vitest
+- ✅ **Core Modules**: All core functionality implemented
+  - API module with HTTP and WebSocket transports
+  - Authentication and encryption (ECC secp256k1)
+  - Broadcast operations
+  - Memo encryption/decryption
+  - Transaction serialization
+- ✅ **Security**: Fixed insecure random number generation, implemented proper cryptographic functions
+- ✅ **Tests**: 174 tests passing, 12 skipped (network-dependent integration tests)
+
+## Installation
+
+```bash
+pnpm install
+# or
+npm install
+```
+
+## Installation
+
+### npm / pnpm / yarn
+
+```bash
+npm install @steemit/steem-js
+# or
+pnpm install @steemit/steem-js
+# or
+yarn add @steemit/steem-js
+```
+
+### Browser (CDN)
+
 ```html
-<script src="./steem.min.js"></script>
-<script>
-steem.api.getAccounts(['ned', 'dan'], function(err, response){
-    console.log(err, response);
+<!-- Include @steemit/steem-js (all dependencies are bundled) -->
+<script src="https://cdn.jsdelivr.net/npm/@steemit/steem-js/dist/index.umd.js"></script>
+```
+
+**Note**: The UMD build includes all necessary polyfills (axios, events, buffer, util, stream, assert, crypto). No additional dependencies are required.
+
+## Usage
+
+### Node.js / TypeScript / ES Modules
+
+```typescript
+import { steem } from '@steemit/steem-js';
+
+// Configure the API endpoint
+steem.config.set({
+  node: 'https://api.steemit.com',
+  address_prefix: 'STM',
+  chain_id: '0000000000000000000000000000000000000000000000000000000000000000'
 });
-</script>
+
+// Get account information
+const account = await steem.api.getAccountAsync('ned');
+console.log(account);
+
+// Generate keys
+const keys = steem.auth.generateKeys('username', 'password', ['owner', 'active', 'posting', 'memo']);
+console.log(keys);
+
+// Sign and verify messages
+import { generateKeyPair, sign, verify } from '@steemit/steem-js/crypto';
+const keyPair = generateKeyPair();
+const message = 'Hello, Steem!';
+const signature = sign(message, keyPair.privateKey);
+const isValid = verify(message, signature, keyPair.publicKey);
+console.log('Signature valid:', isValid);
 ```
 
-## CDN
-https://cdn.jsdelivr.net/npm/steem/dist/steem.min.js<br/>
-```html
-<script src="https://cdn.jsdelivr.net/npm/steem/dist/steem.min.js"></script>
+### Node.js / CommonJS
+
+```javascript
+const { steem } = require('@steemit/steem-js');
+
+steem.config.set({
+  node: 'https://api.steemit.com',
+  address_prefix: 'STM'
+});
+
+const account = await steem.api.getAccountAsync('ned');
+console.log(account);
 ```
 
-## Webpack
-[Please have a look at the webpack usage example.](https://github.com/steemit/steem-js/blob/master/examples/webpack-example)
+### Browser (Script Tag)
+
+The UMD build includes all necessary dependencies and polyfills, so you can use it directly without any additional setup.
 
-## Server
-## Install
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Steem.js Example</title>
+  <!-- Include @steemit/steem-js (all dependencies bundled) -->
+  <script src="https://cdn.jsdelivr.net/npm/@steemit/steem-js/dist/index.umd.js"></script>
+</head>
+<body>
+  <script>
+    // Use the global 'steem' object
+    steem.config.set({
+      node: 'https://api.steemit.com',
+      address_prefix: 'STM'
+    });
+
+    // Get account information
+    steem.api.getAccountAsync('ned')
+      .then(account => {
+        console.log('Account:', account);
+      })
+      .catch(error => {
+        console.error('Error:', error);
+      });
+  </script>
+</body>
+</html>
 ```
-$ npm install steem --save
+
+**Note**: The UMD build (1.7MB) includes all polyfills, making it ready to use in browsers without additional dependencies. For production use with bundlers (Webpack, Vite, Rollup), use the ES Module or CommonJS builds instead.
+
+### Broadcast Operations
+
+```typescript
+import { steem } from '@steemit/steem-js';
+
+// Vote on a post
+const postingWif = steem.auth.toWif('username', 'password', 'posting');
+await steem.broadcast.voteAsync(
+  postingWif,
+  'voter',
+  'author',
+  'permlink',
+  10000 // weight
+);
+
+// Transfer STEEM
+await steem.broadcast.transferAsync(
+  activeWif,
+  'from',
+  'to',
+  '1.000 STEEM',
+  'memo'
+);
 ```
 
-## RPC Servers
-https://api.steemit.com By Default<br/>
-https://node.steem.ws<br/>
-https://this.piston.rocks<br/>
+## Development
 
-## Examples
-### Broadcast Vote
-```js
-var steem = require('steem');
+### Build
 
-var wif = steem.auth.toWif(username, password, 'posting');
-steem.broadcast.vote(wif, voter, author, permlink, weight, function(err, result) {
-	console.log(err, result);
-});
+```bash
+pnpm build
 ```
 
-### Get Accounts
-```js
-steem.api.getAccounts(['ned', 'dan'], function(err, result) {
-	console.log(err, result);
-});
+### Test
+
+```bash
+# Run all tests
+pnpm test
+
+# Run tests in watch mode
+pnpm test:watch
+
+# Run tests with coverage
+pnpm test:coverage
 ```
 
-### Get State
-```js
-steem.api.getState('/trends/funny', function(err, result) {
-	console.log(err, result);
-});
+### Type Check
+
+```bash
+pnpm typecheck
 ```
 
-### Reputation Formatter
-```js
-var reputation = steem.formatter.reputation(user.reputation);
-console.log(reputation);
+### Lint
+
+```bash
+pnpm lint
 ```
 
-### Steem Testnet
-Steem-js requires some configuration to work on the public Steem testnet.
+## Project Structure
 
-You need to set two Steem API options, `address_prefix` and `chain_id`.
-```js
-steem.api.setOptions({
-  address_prefix: 'TST',
-  chain_id: '46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32',
-  useTestNet: true,
-});
 ```
+src/
+  api/          # API client with HTTP and WebSocket transports
+  auth/         # Authentication and key management
+  broadcast/    # Transaction broadcasting
+  crypto/       # Cryptographic utilities
+  formatter/    # Data formatting
+  memo/         # Encrypted memo handling
+  operations/   # Operation type definitions
+  serializer/   # Transaction serialization
+  utils/        # Utility functions
+```
+
+## Key Features
 
-The Chain ID could change. If it does, it may not be reflected here, but will be documented on any testnet launch announcements.
+- **Type Safety**: Full TypeScript support with type definitions
+- **Modern ES Modules**: Uses ES modules with CommonJS fallback
+- **Secure Cryptography**: Proper implementation using Node.js crypto module
+- **Multiple Transports**: Supports both HTTP and WebSocket connections
+- **Promise and Callback Support**: Compatible with both async/await and callback patterns
 
-## Contributions
-Patches are welcome! Contributors are listed in the package.json file. Please run the tests before opening a pull request and make sure that you are passing all of them. If you would like to contribute, but don't know what to work on, check the issues list or on Steemit Chat channel #steemjs https://steemit.chat/channel/steemjs.
+## Breaking Changes from Original
 
-## Issues
-When you find issues, please report them!
+This is a complete refactor with the following changes:
+
+1. **TypeScript**: All code is now TypeScript
+2. **ES Modules**: Uses ES modules by default (CommonJS available)
+3. **Build System**: Uses Rollup instead of Webpack
+4. **Testing**: Uses Vitest instead of Mocha
+5. **API**: Some method signatures may have changed for better type safety
+
+## Security Notes
+
+- Private keys are never logged or exposed
+- Uses cryptographically secure random number generation
+- All cryptographic operations use proper implementations
 
 ## License
+
 MIT
+

package/dist/api/index.d.ts

@@ -0,0 +1,128 @@
+import { EventEmitter } from 'events';
+import Bluebird from 'bluebird';
+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;
+    useTestNet?: boolean;
+    useAppbaseApi?: boolean;
+}
+export declare class Api extends EventEmitter {
+    private seqNo;
+    private _transportType;
+    private transport;
+    private options;
+    private __logger;
+    private static _wrapWithPromise;
+    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;
+    /**
+     * 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.
+     */
+    setWebSocket(url: string): 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;
+    /**
+     * Broadcast a transaction to the blockchain.
+     * @param trx The transaction object
+     * @param callback Callback function
+     */
+    broadcastTransaction(trx: any, callback: any): 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;
+    /**
+     * Get followers for an account (backward compatibility).
+     * @param account The account name
+     * @param startFollower The follower to start from
+     * @param type The type of follow
+     * @param limit The number of followers to return
+     * @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;
+    /**
+     * 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;
+    /**
+     * Broadcast a block to the network.
+     * @param block Block object to broadcast
+     * @param callback Callback function
+     */
+    broadcastBlock(block: any, callback: any): 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;
+    /**
+     * 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;
+    /**
+     * Verify account authority.
+     * @param nameOrId Account name or ID
+     * @param signers Array of signer public keys
+     * @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;
+}
+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 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;

package/dist/api/methods.d.ts

@@ -0,0 +1,9 @@
+interface ApiMethod {
+    api: string;
+    method: string;
+    method_name?: string;
+    params?: string[];
+    is_object?: boolean;
+}
+declare const methods: ApiMethod[];
+export default methods;

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

@@ -0,0 +1,43 @@
+interface RpcRequest {
+    method: string;
+    params: any[];
+    id: number;
+}
+interface SignedRequest {
+    jsonrpc: string;
+    method: string;
+    id: number;
+    params: {
+        __signed: {
+            account: string;
+            nonce: string;
+            params: string;
+            signatures: string[];
+            timestamp: string;
+        };
+    };
+}
+/**
+ * Signing constant used to reserve opcode space and prevent cross-protocol attacks.
+ * Output of `sha256('steem_jsonrpc_auth')`.
+ */
+export declare const K: Buffer<ArrayBuffer>;
+/**
+ * Sign a JSON RPC Request.
+ */
+export declare function sign(request: RpcRequest, account: string, keys: string[]): SignedRequest;
+/**
+ * Validate a signed JSON RPC request.
+ * Throws a ValidationError if the request fails validation.
+ *
+ * @param request The signed JSON RPC request to validate
+ * @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>;
+declare const _default: {
+    sign: typeof sign;
+    validate: typeof validate;
+    K: Buffer<ArrayBuffer>;
+};
+export default _default;

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

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+import { Transport, TransportOptions } from './types';
+export declare class BaseTransport extends EventEmitter implements Transport {
+    options: TransportOptions;
+    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;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export default BaseTransport;

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

@@ -0,0 +1,9 @@
+import { TransportOptions, JsonRpcRequest } from './types';
+import { BaseTransport } from './base';
+export declare const jsonRpc: (uri: string, request: Partial<JsonRpcRequest>) => Promise<any>;
+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;
+}

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,35 @@
+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.
+     */
+    websocket?: string;
+    transport?: string | any;
+    [key: string]: any;
+}
+export interface JsonRpcRequest {
+    id: number;
+    method: string;
+    params: any[];
+    jsonrpc?: string;
+}
+export interface JsonRpcResponse {
+    id: number;
+    result: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export interface Transport {
+    options: TransportOptions;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    setOptions(options: TransportOptions): void;
+    send(api: string, data: any, callback: (error: any, result?: any) => void): void | Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { TransportOptions } from './types';
+import { BaseTransport } from './base';
+/**
+ * WebSocket transport implementation
+ *
+ * NOTE: WebSocket functionality is currently not supported.
+ * This implementation is kept for backward compatibility only.
+ * Please use HTTP transport (via https://api.steemit.com) for API calls.
+ */
+export declare class WsTransport extends BaseTransport {
+    private ws;
+    private _requests;
+    private seqNo;
+    constructor(options: TransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(api: string, data: any, callback: (error: any, result?: any) => void): void;
+}

package/dist/auth/ecc/index.d.ts

@@ -0,0 +1,9 @@
+export { Address } from './src/address';
+export { Aes } from './src/aes';
+export { PrivateKey } from './src/key_private';
+export { PublicKey } from './src/key_public';
+export { Signature } from './src/signature';
+export { normalize as brainKey } from './src/brain_key';
+export * as key_utils from './src/key_utils';
+export * as hash from './src/hash';
+export { Config as ecc_config } from '../../config';

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

@@ -0,0 +1,13 @@
+import { PublicKey } from './key_public';
+export declare class Address {
+    private addy;
+    constructor(addy: Buffer);
+    static fromBuffer(buffer: Buffer): string;
+    static fromString(address: string): Buffer;
+    static fromPublicKey(public_key: PublicKey, compressed?: boolean): string;
+    static fromPublic(public_key: PublicKey, compressed?: boolean, version?: number): Address;
+    static toBuffer(address: string): Buffer;
+    toBuffer(): Buffer;
+    getVersion(): number;
+    toString(address_prefix?: string): string;
+}

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

@@ -0,0 +1,16 @@
+import { PrivateKey } from './key_private';
+import { PublicKey } from './key_public';
+export declare class Aes {
+    static uniqueNonce(): string;
+    static encrypt(private_key: PrivateKey, public_key: PublicKey, message: Buffer | string, nonce?: string): {
+        nonce: string;
+        message: string;
+        checksum: number;
+    };
+    static decrypt(private_key: PrivateKey, public_key: PublicKey, nonce: string, message: string, checksum: number): Buffer;
+    static fromSeed(seed: string): Buffer;
+    static fromBuffer(buffer: Buffer): Buffer;
+    static fromString(string: string): Buffer;
+    static toBuffer(aes: Buffer): Buffer;
+    static toString(aes: Buffer): string;
+}

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

@@ -0,0 +1 @@
+export declare function normalize(brain_key: string): string;

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

@@ -0,0 +1,28 @@
+import BigInteger from 'bigi';
+import ECSignature from './ecsignature';
+type Curve = any;
+type Point = any;
+export declare function sign(curve: Curve, hash: Buffer, d: BigInteger, nonce?: number): ECSignature;
+export declare function verify(curve: Curve, hash: Buffer, signature: ECSignature, Q: Point): boolean;
+/**
+ * Recover a public key from a signature.
+ *
+ * See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
+ * Key Recovery Operation".
+ *
+ * http://www.secg.org/download/aid-780/sec1-v2.pdf
+ */
+export declare function recoverPubKey(curve: Curve, e: BigInteger, signature: ECSignature, i: number): Point;
+/**
+ * Calculate pubkey extraction parameter.
+ *
+ * When extracting a pubkey from a signature, we have to
+ * distinguish four different cases. Rather than putting this
+ * burden on the verifier, Bitcoin includes a 2-bit value with the
+ * signature.
+ *
+ * This function simply tries all four cases and returns the value
+ * that resulted in a successful pubkey recovery.
+ */
+export declare function calcPubKeyRecoveryParam(curve: Curve, e: BigInteger, signature: ECSignature, Q: Point): number;
+export {};