@steemit/steem-js 1.0.19 → 1.1.0

package/README.md

@@ -1,7 +1,5 @@
 # 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)

package/dist/api/types.d.ts

@@ -2,6 +2,7 @@
  * Type definitions for dynamically generated API methods.
  * Runtime routing (condenser_api vs database_api) is defined in methods.ts; see docs/README.md#api-routing.
  */
+import type { ExtendedAccount, DynamicGlobalProperties, Discussion, SignedBlock, FollowApiObject, AccountHistoryEntry } from '../types/protocol';
 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;
@@ -10,69 +11,71 @@ type ApiMethodAsync<TParams extends unknown[] = unknown[], TResult = unknown> =
 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
+ * This interface provides type safety for dynamically generated methods.
+ * Return types mirror the C++ node's condenser_api FC_REFLECT structs; see
+ * src/types/protocol.ts for the protocol definitions.
  */
 export interface ApiMethodSignatures {
-    getAccounts(accounts: string[], callback?: ApiCallback<any[]>): Promise<any[]> | void;
-    getAccountsAsync(accounts: string[]): Promise<any[]>;
+    getAccounts(accounts: string[], callback?: ApiCallback<ExtendedAccount[]>): Promise<ExtendedAccount[]> | void;
+    getAccountsAsync(accounts: string[]): Promise<ExtendedAccount[]>;
     getAccountsWith(options: {
         names: string[];
-    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    }, callback?: ApiCallback<ExtendedAccount[]>): Promise<ExtendedAccount[]> | 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[]>;
+    }): Promise<ExtendedAccount[]>;
+    getAccountHistory(account: string, from: number, limit: number, callback?: ApiCallback<AccountHistoryEntry[]>): Promise<AccountHistoryEntry[]> | void;
+    getAccountHistoryAsync(account: string, from: number, limit: number): Promise<AccountHistoryEntry[]>;
     getAccountHistoryWith(options: {
         account: string;
         from: number;
         limit: number;
-    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    }, callback?: ApiCallback<AccountHistoryEntry[]>): Promise<AccountHistoryEntry[]> | 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>;
+    }): Promise<AccountHistoryEntry[]>;
+    getDynamicGlobalProperties(callback?: ApiCallback<DynamicGlobalProperties>): Promise<DynamicGlobalProperties> | void;
+    getDynamicGlobalPropertiesAsync(): Promise<DynamicGlobalProperties>;
+    getDynamicGlobalPropertiesWith(options: Record<string, unknown>, callback?: ApiCallback<DynamicGlobalProperties>): Promise<DynamicGlobalProperties> | void;
+    getDynamicGlobalPropertiesWithAsync(options: Record<string, unknown>): Promise<DynamicGlobalProperties>;
+    getContent(author: string, permlink: string, callback?: ApiCallback<Discussion>): Promise<Discussion> | void;
+    getContentAsync(author: string, permlink: string): Promise<Discussion>;
     getContentWith(options: {
         author: string;
         permlink: string;
-    }, callback?: ApiCallback<any>): Promise<any> | void;
+    }, callback?: ApiCallback<Discussion>): Promise<Discussion> | 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[]>;
+    }): Promise<Discussion>;
+    getFollowers(following: string, startFollower: string, followType: string, limit: number, callback?: ApiCallback<FollowApiObject[]>): Promise<FollowApiObject[]> | void;
+    getFollowersAsync(following: string, startFollower: string, followType: string, limit: number): Promise<FollowApiObject[]>;
     getFollowersWith(options: {
         following: string;
         startFollower: string;
         followType: string;
         limit: number;
-    }, callback?: ApiCallback<any[]>): Promise<any[]> | void;
+    }, callback?: ApiCallback<FollowApiObject[]>): Promise<FollowApiObject[]> | 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>;
+    }): Promise<FollowApiObject[]>;
+    getBlock(blockNum: number, callback?: ApiCallback<SignedBlock>): Promise<SignedBlock> | void;
+    getBlockAsync(blockNum: number): Promise<SignedBlock>;
     getBlockWith(options: {
         blockNum: number;
-    }, callback?: ApiCallback<any>): Promise<any> | void;
+    }, callback?: ApiCallback<SignedBlock>): Promise<SignedBlock> | 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>;
+    }): Promise<SignedBlock>;
+    getConfig(callback?: ApiCallback<Record<string, unknown>>): Promise<Record<string, unknown>> | void;
+    getConfigAsync(): Promise<Record<string, unknown>>;
+    getConfigWith(options: Record<string, unknown>, callback?: ApiCallback<Record<string, unknown>>): Promise<Record<string, unknown>> | void;
+    getConfigWithAsync(options: Record<string, unknown>): Promise<Record<string, unknown>>;
     [methodName: string]: ApiMethodWithParams | ApiMethodNoParams | ApiMethodWith | ApiMethodAsync<unknown[]> | ApiMethodWithAsync | unknown;
 }
 export {};

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

@@ -4,6 +4,5 @@ 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/index.d.ts

@@ -4,6 +4,5 @@ export { PrivateKey } from './key_private';
 export { PublicKey } from './key_public';
 export { Signature } from './signature';
 export { normalize as brainKey } from './brain_key';
-export * as key_utils from './key_utils';
 export * as hash from './hash';
 export { Config as ecc_config } from '../../../config';

package/dist/auth/index.d.ts

@@ -49,3 +49,4 @@ export declare const verifyTransaction: (transaction: unknown, publicKey: string
 export declare const getPublicKey: (privateKey: string) => string;
 export declare const getPrivateKey: (seed: string) => string;
 export declare const signTransaction: (trx: unknown, keys: string[]) => unknown;
+export { serializeTransaction } from './serializer/transaction';

package/dist/browser.esm.js

@@ -17267,7 +17267,7 @@ function recoverPubKey(curve, e, signature, i) {
         const Q = curve.recoverPubKey(msgBuffer, sigObj, i);
         return Q;
     }
-    catch (error) {
+    catch {
         // Fallback to manual implementation if elliptic's method fails
         const G = curve.g;
         // A set LSB signifies that the y-coordinate is odd
@@ -17287,7 +17287,7 @@ function recoverPubKey(curve, e, signature, i) {
         try {
             R = curve.curve.pointFromX(xHexPadded, isYOdd);
         }
-        catch (error) {
+        catch {
             // If hex string fails, try with Buffer
             const xBuffer = x.toArrayLike(bufferExports.Buffer, 'be', 32);
             R = curve.curve.pointFromX(xBuffer, isYOdd);
@@ -26856,18 +26856,34 @@ const verifySignature = (message, signature, publicKey) => {
         return false;
     }
 };
+// Serialize a transaction to its binary form for digest calculation.
+// Alias for transaction.toBuffer() so verifyTransaction mirrors signTransaction's
+// serialization path exactly (signTransaction calls transaction.toBuffer at line 161).
+const serializeTrx = (trx) => transaction.toBuffer(trx);
 const verifyTransaction = (transaction, publicKey) => {
     try {
         const pub = PublicKey.fromString(publicKey);
         if (!pub)
             return false;
-        const serialized = bufferExports.Buffer.from(JSON.stringify(transaction));
         const trx = transaction;
         if (!trx.signatures || !Array.isArray(trx.signatures))
             return false;
+        // Reconstruct the exact digest signTransaction signs over:
+        //   Buffer.concat([chain_id, transaction.toBuffer(normalizedTrx)])
+        // signatures are NOT part of the signed digest — signTransaction serializes
+        // BEFORE attaching signatures — so strip them before serializing, otherwise
+        // serializeTransaction() would emit the signatures array and change the digest.
+        const normalizedTrx = normalizeTransactionForBroadcast(trx);
+        // Build a copy without the signatures key, so serializeTransaction() does not
+        // emit the signatures array into the digest (signTransaction serializes pre-signature).
+        const trxWithoutSigs = { ...normalizedTrx };
+        delete trxWithoutSigs.signatures;
+        const chainId = getConfig().get('chain_id') || '';
+        const cid = bufferExports.Buffer.from(chainId, 'hex');
+        const buf = serializeTrx(trxWithoutSigs);
         return trx.signatures.some((sig) => {
             const signature = Signature.fromHex(sig);
-            return signature.verifyBuffer(serialized, pub);
+            return signature.verifyBuffer(bufferExports.Buffer.concat([cid, buf]), pub);
         });
     }
     catch {
@@ -26912,6 +26928,7 @@ const auth = /*#__PURE__*/Object.freeze({
 	normalizeTransactionForBroadcast: normalizeTransactionForBroadcast,
 	resolveAuthorityForSerialize: resolveAuthorityForSerialize,
 	sanitizeAccountUpdatePayload: sanitizeAccountUpdatePayload,
+	serializeTransaction: serializeTransaction,
 	sign: sign$1,
 	signTransaction: signTransaction,
 	toWif: toWif,
@@ -29720,7 +29737,7 @@ const steem = {
     memo,
     operations,
     utils: utils$3,
-    version: '1.0.19',
+    version: '1.1.0',
     config: {
         set: (options) => {
             // If nodes is provided, extract the first node as url for API