@steemit/steem-js 1.0.10 → 1.0.11

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;

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 {};

package/dist/browser.esm.js

@@ -17213,6 +17213,77 @@ function sign$3(curve, hash, d, nonce) {
     const finalS = s.gt(N_OVER_TWO) ? n.sub(s) : s;
     return new ECSignature(r, finalS);
 }
+/**
+ * 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
+ */
+function recoverPubKey(curve, e, signature, i) {
+    if ((i & 3) !== i) {
+        throw new Error('Recovery param is more than two bits');
+    }
+    const n = new BN(curve.n.toString());
+    const r = signature.r;
+    const s = signature.s;
+    if (r.isNeg() || r.isZero() || !r.lt(n))
+        throw new Error('Invalid r value');
+    if (s.isNeg() || s.isZero() || !s.lt(n))
+        throw new Error('Invalid s value');
+    // Try using elliptic's built-in recoverPubKey method
+    // It expects: msg (Buffer), signature ({r: BN, s: BN}), j (recovery param)
+    try {
+        // Convert e (BN) to Buffer
+        const msgBuffer = e.toArrayLike(bufferExports.Buffer, 'be', 32);
+        // Create signature object compatible with elliptic's recoverPubKey
+        // elliptic expects {r: BN, s: BN} format
+        const sigObj = { r: r, s: s };
+        // Use elliptic's built-in method
+        const Q = curve.recoverPubKey(msgBuffer, sigObj, i);
+        return Q;
+    }
+    catch (error) {
+        // Fallback to manual implementation if elliptic's method fails
+        const G = curve.g;
+        // A set LSB signifies that the y-coordinate is odd
+        const isYOdd = !!(i & 1);
+        // The more significant bit specifies whether we should use the
+        // first or second candidate key.
+        const isSecondKey = i >> 1;
+        // 1.1 Let x = r + jn
+        const x = isSecondKey ? r.add(n) : r;
+        // pointFromX expects a hex string (not BN object)
+        // Convert BN to hex string and ensure proper padding
+        const xHex = x.toString(16);
+        // Ensure hex string is properly padded to 64 characters (32 bytes)
+        const xHexPadded = xHex.padStart(64, '0');
+        // pointFromX may also accept a Buffer, but hex string is more reliable
+        let R;
+        try {
+            R = curve.curve.pointFromX(xHexPadded, isYOdd);
+        }
+        catch (error) {
+            // If hex string fails, try with Buffer
+            const xBuffer = x.toArrayLike(bufferExports.Buffer, 'be', 32);
+            R = curve.curve.pointFromX(xBuffer, isYOdd);
+        }
+        // 1.4 Check that nR is at infinity
+        const nR = R.mul(n);
+        if (!nR.isInfinity())
+            throw new Error('nR is not a valid curve point');
+        // Compute -e from e
+        const eNeg = e.neg().mod(n);
+        // 1.6.1 Compute Q = r^-1 (sR -  eG)
+        //               Q = r^-1 (sR + -eG)
+        const rInv = r.invm(n);
+        const sR = R.mul(s);
+        const eGNeg = G.mul(eNeg);
+        const Q = sR.add(eGNeg).mul(rInv);
+        return Q;
+    }
+}
 /**
  * Calculate pubkey extraction parameter.
  *
@@ -17227,11 +17298,15 @@ function sign$3(curve, hash, d, nonce) {
 function calcPubKeyRecoveryParam(curve, e, signature, Q) {
     for (let i = 0; i < 4; i++) {
         try {
-            // Use elliptic's built-in recovery method
-            const Qprime = curve.recoverPubKey(e, signature, i);
+            // Use our own recoverPubKey function instead of curve.recoverPubKey
+            const Qprime = recoverPubKey(curve, e, signature, i);
             // 1.6.2 Verify Q = Q'
-            // Compare points by checking if they are the same point
-            if (Qprime.eq(Q)) {
+            // Compare points by checking coordinates (more reliable than eq method)
+            const Qx = Q.getX().toString(16);
+            const Qy = Q.getY().toString(16);
+            const QprimeX = Qprime.getX().toString(16);
+            const QprimeY = Qprime.getY().toString(16);
+            if (Qx === QprimeX && Qy === QprimeY) {
                 return i;
             }
         }
@@ -17265,7 +17340,13 @@ class Signature {
             throw new Error('Invalid signature length');
         }
         const i = buffer.readUInt8(0);
-        if ((i - 27) !== ((i - 27) & 7)) {
+        // Support both formats: 27-30 (old/legacy) and 31-34 (dsteem compatible)
+        // Check if it's in the old format (27-30) or new format (31-34)
+        const recoveryOld = i - 27;
+        const recoveryNew = i - 31;
+        const isValidOld = recoveryOld >= 0 && recoveryOld <= 3 && (recoveryOld === (recoveryOld & 7));
+        const isValidNew = recoveryNew >= 0 && recoveryNew <= 3 && (recoveryNew === (recoveryNew & 7));
+        if (!isValidOld && !isValidNew) {
             throw new Error('Invalid signature parameter');
         }
         const r = new BN(buffer.slice(1, 33));
@@ -17314,7 +17395,9 @@ class Signature {
             }
         }
         const i = calcPubKeyRecoveryParam(secp256k1, new BN(buf_sha256), ecsignature, privKey.toPublic().Q);
-        return new Signature(ecsignature.r, ecsignature.s, i + 27);
+        // Use recovery byte 31-34 (instead of 27-30) to be compatible with dsteem
+        // dsteem expects: recovery = byte - 31, so byte = recovery + 31
+        return new Signature(ecsignature.r, ecsignature.s, i + 31);
     }
     static isCanonical(r, s) {
         // See libraries/fc/src/crypto/elliptic_common.cpp is_fc_canonical
@@ -29062,7 +29145,7 @@ const steem = {
     operations,
     serializer,
     utils: utils$3,
-    version: '1.0.10',
+    version: '1.0.11',
     config: {
         set: (options) => {
             // If nodes is provided, extract the first node as url for API
@@ -29102,5 +29185,5 @@ if (typeof window !== 'undefined' || typeof globalThis !== 'undefined') {
     }
 }
 
-export { Api, doubleSha256, generateKeyPair, hmacSha256, ripemd160, sha256, sign, steem, verify };
+export { Api, doubleSha256, generateKeyPair, hmacSha256, ripemd160, sha256, sign, sign$2 as signRequest, steem, validate as validateRequest, verify };
 //# sourceMappingURL=browser.esm.js.map