@steemit/steem-js 0.8.0 → 1.0.0

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

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

@@ -0,0 +1,19 @@
+import BigInteger from 'bigi';
+export default class ECSignature {
+    r: BigInteger;
+    s: BigInteger;
+    constructor(r: BigInteger, s: BigInteger);
+    static parseCompact(buffer: Buffer): {
+        compressed: boolean;
+        i: number;
+        signature: ECSignature;
+    };
+    static fromDER(buffer: Buffer): ECSignature;
+    static parseScriptSignature(buffer: Buffer): {
+        signature: ECSignature;
+        hashType: number;
+    };
+    toCompact(i: number, compressed: boolean): Buffer;
+    toDER(): Buffer;
+    toScriptSignature(hashType: number): Buffer;
+}

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

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

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

@@ -0,0 +1,25 @@
+/** @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 sha1(data: string | Buffer, encoding?: BufferEncoding): string | Buffer;
+/** @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 sha256(data: string | Buffer, encoding?: BufferEncoding): Buffer;
+/** @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 HmacSHA256(buffer: Buffer, secret: Buffer): Buffer;
+export declare function ripemd160(data: string | Buffer): Buffer;
+declare const _default: {
+    sha1: typeof sha1;
+    sha256: typeof sha256;
+    sha512: typeof sha512;
+    HmacSHA256: typeof HmacSHA256;
+    ripemd160: typeof ripemd160;
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+export { Address } from './address';
+export { Aes } from './aes';
+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/ecc/src/key_private.d.ts

@@ -0,0 +1,38 @@
+import BigInteger from 'bigi';
+import { PublicKey } from './key_public';
+type Point = any;
+export declare class PrivateKey {
+    d: BigInteger;
+    public_key?: PublicKey;
+    /**
+     * @private see static functions
+     * @param {BigInteger} d
+     */
+    constructor(d: BigInteger);
+    static fromBuffer(buf: Buffer): PrivateKey;
+    /** @arg {string} seed - any length string. This is private, the same seed produces the same private key every time. */
+    static fromSeed(seed: string): PrivateKey;
+    static isWif(text: string): boolean;
+    /**
+     * @throws {AssertError|Error} parsing key
+     * @return {string} Wallet Import Format (still a secret, Not encrypted)
+     */
+    static fromWif(private_wif: string): PrivateKey;
+    toWif(): string;
+    /** Alias for {@link toWif} */
+    toString(): string;
+    /**
+     * @return {Point}
+     */
+    toPublicKeyPoint(): Point;
+    toPublic(): PublicKey;
+    toBuffer(): Buffer;
+    /** ECIES */
+    get_shared_secret(public_key: PublicKey | string): Buffer;
+    /** @throws {Error} - overflow of the key could not be derived */
+    child(offset: Buffer): PrivateKey;
+    static fromHex(hex: string): PrivateKey;
+    toHex(): string;
+    toPublicKey(): PublicKey;
+}
+export {};

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

@@ -0,0 +1,41 @@
+type Point = any;
+export declare class PublicKey {
+    Q: Point | null;
+    pubdata?: string;
+    /** @param {Point} public key */
+    constructor(Q: Point | null);
+    static fromBinary(bin: string): PublicKey;
+    static fromBuffer(buffer: Buffer): PublicKey;
+    toBuffer(compressed?: any): Buffer;
+    static fromPoint(point: Point): PublicKey;
+    toUncompressed(): PublicKey;
+    /** bts::blockchain::address (unique but not a full public key) */
+    toBlockchainAddress(): Buffer;
+    toString(address_prefix?: any): string;
+    /**
+     * Full public key
+     * {return} string
+     */
+    toPublicKeyString(address_prefix?: any): 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;
+    /**
+     * @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;
+    toPtsAddy(): string;
+    child(offset: Buffer): PublicKey;
+    static fromHex(hex: string): PublicKey;
+    toHex(): string;
+    static fromStringHex(hex: string): PublicKey;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import { PrivateKey } from './key_private';
+export declare function addEntropy(...ints: number[]): void;
+/**
+ * A weak random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.
+ * @param entropy string entropy of at least 32 bytes
+ */
+export declare function random32ByteBuffer(entropy?: string): Buffer;
+export declare function get_random_key(entropy?: string): PrivateKey;
+export declare function browserEntropy(): string;

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

@@ -0,0 +1,18 @@
+import bigi from 'bigi';
+import { PrivateKey } from './key_private';
+import { PublicKey } from './key_public';
+export declare class Signature {
+    r: bigi;
+    s: bigi;
+    i: number;
+    constructor(r: bigi, s: bigi, i: number);
+    static fromBuffer(buffer: Buffer): Signature;
+    toBuffer(): Buffer;
+    static signBuffer(buf: Buffer, private_key: PrivateKey | string): Signature;
+    static signBufferSha256(buf_sha256: Buffer, private_key: PrivateKey | string): Signature;
+    static sign(string: string, private_key: PrivateKey | string): Signature;
+    verifyBuffer(buf: Buffer, public_key: PublicKey): boolean;
+    verifyHash(hash: Buffer, public_key: PublicKey): boolean;
+    static fromHex(hex: string): Signature;
+    toHex(): string;
+}

package/dist/auth/ecc.d.ts

@@ -0,0 +1,3 @@
+export declare const hash: {
+    sha256: (data: Buffer | string) => Buffer;
+};

package/dist/auth/index.d.ts

@@ -0,0 +1,48 @@
+export interface KeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export interface KeyPairs {
+    [role: string]: KeyPair;
+}
+export interface Authority {
+    key_auths: [string, number][];
+}
+export interface Auth {
+    verify(name: string, password: string, auths: any): boolean;
+    generateKeys(name: string, password: string, roles: string[]): {
+        [key: string]: string;
+    };
+    getPrivateKeys(name: string, password: string, roles?: string[]): {
+        [key: string]: string;
+    };
+    isWif(privWif: string): boolean;
+    toWif(name: string, password: string, role: string): string;
+    wifIsValid(privWif: string, pubWif: string): boolean;
+    wifToPublic(privWif: string): string;
+    isPubkey(pubkey: string, address_prefix?: string): boolean;
+    signTransaction(trx: any, keys: string[]): any;
+}
+export declare const Auth: Auth;
+export default Auth;
+export declare const verify: (name: string, password: string, auths: any) => boolean;
+export declare const generateKeys: (name: string, password: string, roles: string[]) => {
+    [key: string]: string;
+};
+export declare const getPrivateKeys: (name: string, password: string, roles?: string[]) => {
+    [key: string]: string;
+};
+export declare const isWif: (privWif: string) => boolean;
+export declare const toWif: (name: string, password: string, role: string) => string;
+export declare const wifIsValid: (privWif: string, pubWif: string) => boolean;
+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 { 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 getPublicKey: (privateKey: string) => string;
+export declare const getPrivateKey: (seed: string) => string;
+export declare const signTransaction: (trx: any, keys: string[]) => any;

package/dist/auth/key_classes.d.ts

@@ -0,0 +1,3 @@
+export { PrivateKey } from './ecc/src/key_private';
+export { PublicKey } from './ecc/src/key_public';
+export { Address } from './ecc/src/address';

package/dist/auth/serializer.d.ts

@@ -0,0 +1,19 @@
+import { PublicKey } from './ecc/src/key_public';
+export interface EncryptedMemo {
+    from: PublicKey;
+    to: PublicKey;
+    nonce: string;
+    check: number;
+    encrypted: string;
+}
+export declare class Serializer {
+    static fromBuffer(buffer: Buffer): EncryptedMemo;
+    static toBuffer(memo: EncryptedMemo): Buffer;
+}
+export declare const transaction: {
+    toBuffer(trx: any): Buffer;
+};
+export declare const signed_transaction: {
+    toObject(trx: any): any;
+    toBuffer(trx: any): Buffer;
+};

package/dist/broadcast/helpers.d.ts

@@ -0,0 +1,11 @@
+import { Operation } from './operations';
+export interface BroadcastOptions {
+    roles: string[];
+    operation: string;
+    params: any[];
+}
+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;

package/dist/broadcast/index.d.ts

@@ -0,0 +1,43 @@
+import { Api } from '../api';
+import Auth from '../auth';
+import { BroadcastOptions } from './helpers';
+export interface BroadcastConfig {
+    api: Api;
+    auth: Auth;
+}
+export declare class Broadcast {
+    private api;
+    private auth;
+    constructor(config: BroadcastConfig);
+    send(tx: {
+        operations: any[];
+        extensions?: any[];
+    }, privKeys: any, callback?: (err: any, result?: any) => void): Promise<any>;
+    sendOperations(operations: BroadcastOptions[]): Promise<any>;
+    sendTransaction(transaction: any): Promise<any>;
+    sendSignedTransaction(signedTransaction: any): Promise<any>;
+}
+/**
+ * Top-level broadcast function for compatibility with tests and original API.
+ */
+export declare function broadcast(api: any, transaction: any): Promise<any>;
+/**
+ * Set the API reference for the broadcast module
+ */
+export declare function setApi(api: any): void;
+export declare const _prepareTransaction: any, claimAccount: any, claimAccountAsync: any, createClaimedAccount: any, createClaimedAccountAsync: any, createProposal: any, createProposalAsync: any, updateProposalVotes: any, updateProposalVotesAsync: any, removeProposal: any, removeProposalAsync: any, generated: {
+    [x: string]: any;
+};
+export declare const vote: any;
+export declare const voteAsync: any;
+export declare const voteWith: any;
+export declare const comment: any;
+export declare const transfer: any;
+export declare const transferAsync: any;
+export declare const sendAsync: Function;
+export declare const send: (tx: {
+    operations: any[];
+    extensions?: any[];
+}, privKeys: any, callback?: (err: any, result?: any) => void) => Promise<any>;
+export declare const customJson: any;
+export declare const customJsonAsync: any;

package/dist/broadcast/operations.d.ts

@@ -0,0 +1,6 @@
+export interface Operation {
+    roles: string[];
+    operation: string;
+    params: string[];
+}
+export declare const operations: Operation[];

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+interface SteemConfig {
+    node?: string;
+    nodes?: string[];
+    uri?: string;
+    websocket?: string;
+    address_prefix?: string;
+    chain_id?: string;
+}
+export declare class Config {
+    private config;
+    get(key: string): any;
+    getBoolean(key: string): boolean;
+    getNumber(key: string): number;
+    getString(key: string): string;
+    set(key: string, value: any): void;
+    all(): {
+        [key: string]: any;
+    };
+}
+export declare const getConfig: () => Config;
+export declare const setConfig: (newConfig: Partial<SteemConfig>) => void;
+export declare const resetConfig: () => void;
+export declare const setOptions: (newConfig: Partial<SteemConfig>) => void;
+export declare function get(key: string): any;
+export {};

package/dist/crypto/index.d.ts

@@ -0,0 +1,25 @@
+import type { KeyPair } from '../auth';
+export declare const sha256: (data: string | Buffer) => Buffer;
+export declare const ripemd160: (data: string | Buffer) => Buffer;
+export declare const doubleSha256: (data: string | Buffer) => Buffer;
+export declare const hmacSha256: (key: string | Buffer, data: string | Buffer) => Buffer;
+/**
+ * Generate a cryptographically secure key pair using ECC secp256k1
+ * @returns A key pair with private key in WIF format and public key in Steem format
+ */
+export declare const generateKeyPair: () => KeyPair;
+/**
+ * Sign a message with a private key using ECC secp256k1
+ * @param message - The message to sign (string or Buffer)
+ * @param privateKey - Private key in WIF format
+ * @returns Hexadecimal signature string
+ */
+export declare const sign: (message: string | Buffer, privateKey: string) => string;
+/**
+ * Verify a message signature with a public key
+ * @param message - The message that was signed (string or Buffer)
+ * @param signature - Hexadecimal signature string
+ * @param publicKey - Public key in Steem format (e.g., "STM...")
+ * @returns True if signature is valid, false otherwise
+ */
+export declare const verify: (message: string | Buffer, signature: string, publicKey: string) => boolean;

package/dist/formatter/index.d.ts

@@ -0,0 +1,92 @@
+import { Api } from '../api';
+export interface Account {
+    name: string;
+    vesting_shares: string;
+    balance: string;
+    savings_balance: string;
+    savings_sbd_balance: string;
+    sbd_balance: string;
+    other_history?: any[];
+}
+export interface GlobalProperties {
+    total_vesting_shares: string;
+    total_vesting_fund_steem: string;
+}
+export interface FeedPrice {
+    base: string;
+    quote: string;
+}
+export interface OpenOrder {
+    sell_price: {
+        base: string;
+    };
+    for_sale: number;
+}
+export interface SavingsWithdraw {
+    amount: string;
+}
+export interface AccountValueOptions {
+    gprops?: GlobalProperties;
+    feed_price?: FeedPrice;
+    open_orders?: OpenOrder[];
+    savings_withdraws?: SavingsWithdraw[];
+    vesting_steem?: number;
+}
+export declare function formatAmount(amount: number | string, symbol?: string): string;
+export declare function formatVests(vests: number | string): string;
+export declare function formatReputation(reputation: number | string | null | undefined, decimal_places?: number): string;
+export declare function formatPercent(value: number | string): string;
+export declare function formatTime(time: Date | number | string): string;
+export declare function formatNumber(value: number | string, decimals?: number): string;
+export declare class Formatter {
+    private api;
+    constructor(api: Api);
+    private vestingSteem;
+    private processOrders;
+    private calculateSaving;
+    private pricePerSteem;
+    estimateAccountValue(account: Account, options?: AccountValueOptions): Promise<string>;
+    createSuggestedPassword(): string;
+    reputation(reputation: number | null | undefined, decimal_places?: number): number | null | undefined;
+    vestToSteem(vestingShares: string, totalVestingShares: string, totalVestingFundSteem: string): number;
+    commentPermlink(parentAuthor: string, parentPermlink: string): string;
+}
+/**
+ * Calculate vesting STEEM from vesting shares and global properties.
+ * @param account Account object
+ * @param gprops GlobalProperties object
+ * @returns Number of STEEM
+ */
+export declare function vestingSteem(account: Account, gprops: GlobalProperties): number;
+/**
+ * Calculate price per STEEM from feed price.
+ * @param feed_price FeedPrice object
+ * @returns Price per STEEM or undefined
+ */
+export declare function pricePerSteem(feed_price: FeedPrice): number | undefined;
+/**
+ * Alias for formatAmount for backward compatibility.
+ */
+export declare const amount: typeof formatAmount;
+/**
+ * Convert vesting shares to STEEM.
+ * @param vestingShares Vesting shares string
+ * @param totalVestingShares Total vesting shares string
+ * @param totalVestingFundSteem Total vesting fund STEEM string
+ * @returns Number of STEEM
+ */
+export declare function vestToSteem(vestingShares: string, totalVestingShares: string, totalVestingFundSteem: string): number;
+/**
+ * Generate a comment permlink based on parent author and permlink.
+ * @param parentAuthor Parent author string
+ * @param parentPermlink Parent permlink string
+ * @returns Generated permlink string
+ */
+export declare function commentPermlink(parentAuthor: string, parentPermlink: string): string;
+/**
+ * Calculate Steem reputation score as a number, matching the original implementation.
+ * @param reputation Raw reputation value
+ * @param decimal_places Number of decimal places (optional)
+ * @returns Reputation score as number, or null/undefined if input is null/undefined
+ */
+export declare function reputation(reputation: number | null | undefined, decimal_places?: number): number | null | undefined;