dworthjs
Version:
Wortheum blockchain RPC client library
1,351 lines (1,343 loc) • 86 kB
TypeScript
declare module 'dworth/version' {
const _default: string;
export default _default;
}
declare module 'dworth/worth/asset' {
/**
* Asset symbol string.
*/
export type AssetSymbol = 'WORTH' | 'VESTS' | 'WBD';
/**
* Class representing a wortheum asset, e.g. `1.000 WORTH` or `12.112233 VESTS`.
*/
export class Asset {
readonly amount: number;
readonly symbol: AssetSymbol;
/**
* Create a new Asset instance from a string, e.g. `42.000 WORTH`.
*/
static fromString(string: string, expectedSymbol?: AssetSymbol): Asset;
/**
* Convenience to create new Asset.
* @param symbol Symbol to use when created from number. Will also be used to validate
* the asset, throws if the passed value has a different symbol than this.
*/
static from(value: string | Asset | number, symbol?: AssetSymbol): Asset;
/**
* Return the smaller of the two assets.
*/
static min(a: Asset, b: Asset): Asset;
/**
* Return the larger of the two assets.
*/
static max(a: Asset, b: Asset): Asset;
constructor(amount: number, symbol: AssetSymbol);
/**
* Return asset precision.
*/
getPrecision(): number;
/**
* Return a string representation of this asset, e.g. `42.000 WORTH`.
*/
toString(): string;
/**
* Return a new Asset instance with amount added.
*/
add(amount: Asset | string | number): Asset;
/**
* Return a new Asset instance with amount subtracted.
*/
subtract(amount: Asset | string | number): Asset;
/**
* Return a new Asset with the amount multiplied by factor.
*/
multiply(factor: Asset | string | number): Asset;
/**
* Return a new Asset with the amount divided.
*/
divide(divisor: Asset | string | number): Asset;
/**
* For JSON serialization, same as toString().
*/
toJSON(): string;
}
/**
* Represents quotation of the relative value of asset against another asset.
* Similar to 'currency pair' used to determine value of currencies.
*
* For example:
* 1 EUR / 1.25 USD where:
* 1 EUR is an asset specified as a base
* 1.25 USD us an asset specified as a qute
*
* can determine value of EUR against USD.
*/
export class Price {
readonly base: Asset;
readonly quote: Asset;
/**
* Convenience to create new Price.
*/
static from(value: Price | {
base: Asset | string;
quote: Asset | string;
}): Price;
/**
* @param base - represents a value of the price object to be expressed relatively to quote
* asset. Cannot have amount == 0 if you want to build valid price.
* @param quote - represents an relative asset. Cannot have amount == 0, otherwise
* asertion fail.
*
* Both base and quote shall have different symbol defined.
*/
constructor(base: Asset, quote: Asset);
/**
* Return a string representation of this price pair.
*/
toString(): string;
/**
* Return a new Asset with the price converted between the symbols in the pair.
* Throws if passed asset symbol is not base or quote.
*/
convert(asset: Asset): Asset;
}
}
declare module 'dworth/worth/misc' {
/// <reference types="node" />
/**
* @file Misc wortheum type definitions.
* @author Johan Nordberg <code@johan-nordberg.com>
* @license
* Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You acknowledge that this software is not designed, licensed or intended for use
* in the design, construction, operation or maintenance of any military facility.
*/
import { Asset, Price } from 'dworth/worth/asset';
/**
* Large number that may be unsafe to represent natively in JavaScript.
*/
export type Bignum = string;
/**
* Buffer wrapper that serializes to a hex-encoded string.
*/
export class HexBuffer {
buffer: Buffer;
/**
* Convenience to create a new HexBuffer, does not copy data if value passed is already a buffer.
*/
static from(value: Buffer | HexBuffer | number[] | string): HexBuffer;
constructor(buffer: Buffer);
toString(encoding?: string): string;
toJSON(): string;
}
/**
* Chain roperties that are decided by the witnesses.
*/
export interface ChainProperties {
/**
* This fee, paid in WORTH, is converted into VESTING SHARES for the new account. Accounts
* without vesting shares cannot earn usage rations and therefore are powerless. This minimum
* fee requires all accounts to have some kind of commitment to the network that includes the
* ability to vote and make transactions.
*
* @note This has to be multiplied by `WORTH_CREATE_ACCOUNT_WITH_WORTH_MODIFIER`
* (defined as 30 on the main chain) to get the minimum fee needed to create an account.
*
*/
account_creation_fee: string | Asset;
/**
* This witnesses vote for the maximum_block_size which is used by the network
* to tune rate limiting and capacity.
*/
maximum_block_size: number;
/**
* The WBD interest percentage rate decided by witnesses, expressed 0 to 10000.
*/
sbd_interest_rate: number;
}
export interface VestingDelegation {
/**
* Delegation id.
*/
id: number;
/**
* Account that is delegating vests to delegatee.
*/
delegator: string;
/**
* Account that is receiving vests from delegator.
*/
delegatee: string;
/**
* Amount of VESTS delegated.
*/
vesting_shares: Asset | string;
/**
* Earliest date delegation can be removed.
*/
min_delegation_time: string;
}
/**
* Node state.
*/
export interface DynamicGlobalProperties {
id: number;
/**
* Current block height.
*/
head_block_number: number;
head_block_id: string;
/**
* UTC Server time, e.g. 2020-01-15T00:42:00
*/
time: string;
/**
* Currently elected witness.
*/
current_witness: string;
/**
* The total POW accumulated, aka the sum of num_pow_witness at the time
* new POW is added.
*/
total_pow: number;
/**
* The current count of how many pending POW witnesses there are, determines
* the difficulty of doing pow.
*/
num_pow_witnesses: number;
virtual_supply: Asset | string;
current_supply: Asset | string;
/**
* Total asset held in confidential balances.
*/
confidential_supply: Asset | string;
current_sbd_supply: Asset | string;
/**
* Total asset held in confidential balances.
*/
confidential_sbd_supply: Asset | string;
total_vesting_fund_worth: Asset | string;
total_vesting_shares: Asset | string;
total_reward_fund_worth: Asset | string;
/**
* The running total of REWARD^2.
*/
total_reward_shares2: string;
pending_rewarded_vesting_shares: Asset | string;
pending_rewarded_vesting_worth: Asset | string;
/**
* This property defines the interest rate that WBD deposits receive.
*/
sbd_interest_rate: number;
sbd_print_rate: number;
/**
* Average block size is updated every block to be:
*
* average_block_size = (99 * average_block_size + new_block_size) / 100
*
* This property is used to update the current_reserve_ratio to maintain
* approximately 50% or less utilization of network capacity.
*/
average_block_size: number;
/**
* Maximum block size is decided by the set of active witnesses which change every round.
* Each witness posts what they think the maximum size should be as part of their witness
* properties, the median size is chosen to be the maximum block size for the round.
*
* @note the minimum value for maximum_block_size is defined by the protocol to prevent the
* network from getting stuck by witnesses attempting to set this too low.
*/
maximum_block_size: number;
/**
* The current absolute slot number. Equal to the total
* number of slots since genesis. Also equal to the total
* number of missed slots plus head_block_number.
*/
current_aslot: number;
/**
* Used to compute witness participation.
*/
recent_slots_filled: Bignum;
participation_count: number;
last_irreversible_block_num: number;
/**
* The maximum bandwidth the blockchain can support is:
*
* max_bandwidth = maximum_block_size * WORTH_BANDWIDTH_AVERAGE_WINDOW_SECONDS / WORTH_BLOCK_INTERVAL
*
* The maximum virtual bandwidth is:
*
* max_bandwidth * current_reserve_ratio
*/
max_virtual_bandwidth: Bignum;
/**
* Any time average_block_size <= 50% maximum_block_size this value grows by 1 until it
* reaches WORTH_MAX_RESERVE_RATIO. Any time average_block_size is greater than
* 50% it falls by 1%. Upward adjustments happen once per round, downward adjustments
* happen every block.
*/
current_reserve_ratio: number;
/**
* The number of votes regenerated per day. Any user voting slower than this rate will be
* "wasting" voting power through spillover; any user voting faster than this rate will have
* their votes reduced.
*/
vote_power_reserve_rate: number;
}
/**
* Return the vesting share price.
*/
export function getVestingSharePrice(props: DynamicGlobalProperties): Price;
}
declare module 'dworth/worth/serializer' {
/// <reference types="node" />
/**
* @file Wortheum protocol serialization.
* @author Johan Nordberg <code@johan-nordberg.com>
* @license
* Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You acknowledge that this software is not designed, licensed or intended for use
* in the design, construction, operation or maintenance of any military facility.
*/
import * as ByteBuffer from 'bytebuffer';
import { PublicKey } from 'dworth/crypto';
import { Asset } from 'dworth/worth/asset';
import { HexBuffer } from 'dworth/worth/misc';
import { Operation } from 'dworth/worth/operation';
export interface SerializerOptions {
addressPrefix: string;
}
export type Serializer = (buffer: ByteBuffer, data: any, options: SerializerOptions) => void;
export const Types: {
Array: (itemSerializer: Serializer) => (buffer: ByteBuffer, data: any[], options: SerializerOptions) => void;
Asset: (buffer: ByteBuffer, data: string | number | Asset) => void;
Authority: (buffer: ByteBuffer, data: {
[key: string]: any;
}, options: SerializerOptions) => void;
Binary: (size?: number | undefined) => (buffer: ByteBuffer, data: HexBuffer | Buffer) => void;
Boolean: (buffer: ByteBuffer, data: boolean) => void;
Date: (buffer: ByteBuffer, data: string) => void;
FlatMap: (keySerializer: Serializer, valueSerializer: Serializer) => (buffer: ByteBuffer, data: [any, any][], options: SerializerOptions) => void;
Int16: (buffer: ByteBuffer, data: number) => void;
Int32: (buffer: ByteBuffer, data: number) => void;
Int64: (buffer: ByteBuffer, data: number) => void;
Int8: (buffer: ByteBuffer, data: number) => void;
Object: (keySerializers: [string, Serializer][]) => (buffer: ByteBuffer, data: {
[key: string]: any;
}, options: SerializerOptions) => void;
Operation: (buffer: ByteBuffer, operation: Operation, options: SerializerOptions) => void;
Optional: (valueSerializer: Serializer) => (buffer: ByteBuffer, data: any, options: SerializerOptions) => void;
Price: (buffer: ByteBuffer, data: {
[key: string]: any;
}, options: SerializerOptions) => void;
PublicKey: (buffer: ByteBuffer, data: string | Buffer | PublicKey, options: SerializerOptions) => void;
StaticVariant: (itemSerializers: Serializer[]) => (buffer: ByteBuffer, data: [number, any], options: SerializerOptions) => void;
String: (buffer: ByteBuffer, data: string) => void;
Transaction: (buffer: ByteBuffer, data: {
[key: string]: any;
}, options: SerializerOptions) => void;
UInt16: (buffer: ByteBuffer, data: number) => void;
UInt32: (buffer: ByteBuffer, data: number) => void;
UInt64: (buffer: ByteBuffer, data: number) => void;
UInt8: (buffer: ByteBuffer, data: number) => void;
Void: (buffer: ByteBuffer) => never;
};
}
declare module 'dworth/utils' {
/// <reference types="node" />
/**
* @file Misc utility functions.
* @author Johan Nordberg <code@johan-nordberg.com>
* @license
* Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You acknowledge that this software is not designed, licensed or intended for use
* in the design, construction, operation or maintenance of any military facility.
*/
import { EventEmitter } from 'events';
/**
* Return a promise that will resove when a specific event is emitted.
*/
export function waitForEvent<T>(emitter: EventEmitter, eventName: string | symbol): Promise<T>;
/**
* Sleep for N milliseconds.
*/
export function sleep(ms: number): Promise<void>;
/**
* Return a stream that emits iterator values.
*/
export function iteratorStream<T>(iterator: AsyncIterableIterator<T>): NodeJS.ReadableStream;
/**
* Return a deep copy of a JSON-serializable object.
*/
export function copy<T>(object: T): T;
/**
* Fetch API wrapper that retries until timeout is reached.
*/
export function retryingFetch(url: string, opts: any, timeout: number, backoff: (tries: number) => number, fetchTimeout?: (tries: number) => number): Promise<any>;
}
declare module 'dworth/crypto' {
/// <reference types="node" />
import { SignedTransaction, Transaction } from 'dworth/worth/transaction';
/**
* Network id used in WIF-encoding.
*/
export const NETWORK_ID: Buffer;
/**
* ECDSA (secp256k1) public key.
*/
export class PublicKey {
readonly key: Buffer;
readonly prefix: string;
/**
* Create a new instance from a WIF-encoded key.
*/
static fromString(wif: string, prefix?: string): PublicKey;
/**
* Create a new instance.
*/
static from(value: string | PublicKey | Buffer, prefix?: string): PublicKey;
constructor(key: Buffer, prefix?: string);
/**
* Verify a 32-byte signature.
* @param message 32-byte message to verify.
* @param signature Signature to verify.
*/
verify(message: Buffer, signature: Signature): boolean;
/**
* Return a WIF-encoded representation of the key.
*/
toString(): string;
/**
* Return JSON representation of this key, same as toString().
*/
toJSON(): string;
/**
* Used by `utils.inspect` and `console.log` in node.js.
*/
inspect(): string;
}
export type KeyRole = 'owner' | 'active' | 'posting' | 'memo';
/**
* ECDSA (secp256k1) private key.
*/
export class PrivateKey {
private key;
/**
* Convenience to create a new instance from WIF string or buffer.
*/
static from(value: string | Buffer): PrivateKey;
/**
* Create a new instance from a WIF-encoded key.
*/
static fromString(wif: string): PrivateKey;
/**
* Create a new instance from a seed.
*/
static fromSeed(seed: string): PrivateKey;
/**
* Create key from username and password.
*/
static fromLogin(username: string, password: string, role?: KeyRole): PrivateKey;
constructor(key: Buffer);
/**
* Sign message.
* @param message 32-byte message.
*/
sign(message: Buffer): Signature;
/**
* Derive the public key for this private key.
*/
createPublic(prefix?: string): PublicKey;
/**
* Return a WIF-encoded representation of the key.
*/
toString(): string;
/**
* Used by `utils.inspect` and `console.log` in node.js. Does not show the full key
* to get the full encoded key you need to explicitly call {@link toString}.
*/
inspect(): string;
}
/**
* ECDSA (secp256k1) signature.
*/
export class Signature {
data: Buffer;
recovery: number;
static fromBuffer(buffer: Buffer): Signature;
static fromString(string: string): Signature;
constructor(data: Buffer, recovery: number);
/**
* Recover public key from signature by providing original signed message.
* @param message 32-byte message that was used to create the signature.
*/
recover(message: Buffer, prefix?: string): PublicKey;
toBuffer(): Buffer;
toString(): string;
}
/** Misc crypto utility functions. */
export const cryptoUtils: {
decodePrivate: (encodedKey: string) => Buffer;
doubleSha256: (input: string | Buffer) => Buffer;
encodePrivate: (key: Buffer) => string;
encodePublic: (key: Buffer, prefix: string) => string;
isCanonicalSignature: (signature: Buffer) => boolean;
ripemd160: (input: string | Buffer) => Buffer;
sha256: (input: string | Buffer) => Buffer;
signTransaction: (transaction: Transaction, keys: PrivateKey | PrivateKey[], options: {
chainId: Buffer;
addressPrefix: string;
}) => SignedTransaction;
};
}
declare module 'dworth/worth/account' {
import { PublicKey } from 'dworth/crypto';
import { Asset } from 'dworth/worth/asset';
export interface AuthorityType {
weight_threshold: number;
account_auths: Array<[string, number]>;
key_auths: Array<[string | PublicKey, number]>;
}
export class Authority implements AuthorityType {
/**
* Convenience to create a new instance from PublicKey or authority object.
*/
static from(value: string | PublicKey | AuthorityType): Authority;
weight_threshold: number;
account_auths: Array<[string, number]>;
key_auths: Array<[string | PublicKey, number]>;
constructor({weight_threshold, account_auths, key_auths}: AuthorityType);
}
export interface Account {
id: number;
name: string;
owner: Authority;
active: Authority;
posting: Authority;
memo_key: string;
json_metadata: string;
proxy: string;
last_owner_update: string;
last_account_update: string;
created: string;
mined: boolean;
owner_challenged: boolean;
active_challenged: boolean;
last_owner_proved: string;
last_active_proved: string;
recovery_account: string;
reset_account: string;
last_account_recovery: string;
comment_count: number;
lifetime_vote_count: number;
post_count: number;
can_vote: boolean;
voting_power: number;
last_vote_time: string;
balance: string | Asset;
savings_balance: string | Asset;
sbd_balance: string | Asset;
sbd_seconds: string;
sbd_seconds_last_update: string;
sbd_last_interest_payment: string;
savings_sbd_balance: string | Asset;
savings_sbd_seconds: string;
savings_sbd_seconds_last_update: string;
savings_sbd_last_interest_payment: string;
savings_withdraw_requests: number;
reward_sbd_balance: string | Asset;
reward_worth_balance: string | Asset;
reward_vesting_balance: string | Asset;
reward_vesting_worth: string | Asset;
curation_rewards: number | string;
posting_rewards: number | string;
vesting_shares: string | Asset;
delegated_vesting_shares: string | Asset;
received_vesting_shares: string | Asset;
vesting_withdraw_rate: string | Asset;
next_vesting_withdrawal: string;
withdrawn: number | string;
to_withdraw: number | string;
withdraw_routes: number;
proxied_vsf_votes: number[];
witnesses_voted_for: number;
average_bandwidth: number | string;
lifetime_bandwidth: number | string;
last_bandwidth_update: string;
average_market_bandwidth: number | string;
lifetime_market_bandwidth: number | string;
last_market_bandwidth_update: string;
last_post: string;
last_root_post: string;
}
export interface ExtendedAccount extends Account {
/**
* Convert vesting_shares to vesting worth.
*/
vesting_balance: string | Asset;
reputation: string | number;
/**
* Transfer to/from vesting.
*/
transfer_history: any[];
/**
* Limit order / cancel / fill.
*/
market_history: any[];
post_history: any[];
vote_history: any[];
other_history: any[];
witness_votes: string[];
tags_usage: string[];
guest_bloggers: string[];
open_orders?: any[];
comments?: any[];
blog?: any[];
feed?: any[];
recent_replies?: any[];
recommended?: any[];
}
}
declare module 'dworth/worth/comment' {
/**
* @file Wortheum type definitions related to comments and posting.
* @author Johan Nordberg <code@johan-nordberg.com>
* @license
* Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You acknowledge that this software is not designed, licensed or intended for use
* in the design, construction, operation or maintenance of any military facility.
*/
import { Asset } from 'dworth/worth/asset';
export interface Comment {
id: number;
category: string;
parent_author: string;
parent_permlink: string;
author: string;
permlink: string;
title: string;
body: string;
json_metadata: string;
last_update: string;
created: string;
active: string;
last_payout: string;
depth: number;
children: number;
net_rshares: string;
abs_rshares: string;
vote_rshares: string;
children_abs_rshares: string;
cashout_time: string;
max_cashout_time: string;
total_vote_weight: number;
reward_weight: number;
total_payout_value: Asset | string;
curator_payout_value: Asset | string;
author_rewards: string;
net_votes: number;
root_comment: number;
max_accepted_payout: string;
percent_worth_dollars: number;
allow_replies: boolean;
allow_votes: boolean;
allow_curation_rewards: boolean;
beneficiaries: BeneficiaryRoute[];
}
/**
* Discussion a.k.a. Post.
*/
export interface Discussion extends Comment {
url: string;
root_title: string;
pending_payout_value: Asset | string;
total_pending_payout_value: Asset | string;
active_votes: any[];
replies: string[];
author_reputation: number;
promoted: Asset | string;
body_length: string;
reblogged_by: any[];
first_reblogged_by?: any;
first_reblogged_on?: any;
}
export interface BeneficiaryRoute {
account: string;
weight: number;
}
}
declare module 'dworth/worth/operation' {
/// <reference types="node" />
/**
* @file Wortheum operation type definitions.
* @author Johan Nordberg <code@johan-nordberg.com>
* @license
* Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You acknowledge that this software is not designed, licensed or intended for use
* in the design, construction, operation or maintenance of any military facility.
*/
import { PublicKey } from 'dworth/crypto';
import { AuthorityType } from 'dworth/worth/account';
import { Asset, Price } from 'dworth/worth/asset';
import { SignedBlockHeader } from 'dworth/worth/block';
import { BeneficiaryRoute } from 'dworth/worth/comment';
import { ChainProperties, HexBuffer } from 'dworth/worth/misc';
/**
* Operation name.
*/
export type OperationName = 'account_create' | 'account_create_with_delegation' | 'account_update' | 'account_witness_proxy' | 'account_witness_vote' | 'cancel_transfer_from_savings' | 'challenge_authority' | 'change_recovery_account' | 'claim_reward_balance' | 'comment' | 'comment_options' | 'convert' | 'custom' | 'custom_binary' | 'custom_json' | 'decline_voting_rights' | 'delegate_vesting_shares' | 'delete_comment' | 'escrow_approve' | 'escrow_dispute' | 'escrow_release' | 'escrow_transfer' | 'feed_publish' | 'limit_order_cancel' | 'limit_order_create' | 'limit_order_create2' | 'pow' | 'pow2' | 'prove_authority' | 'recover_account' | 'report_over_production' | 'request_account_recovery' | 'reset_account' | 'set_reset_account' | 'set_withdraw_vesting_route' | 'transfer' | 'transfer_from_savings' | 'transfer_to_savings' | 'transfer_to_vesting' | 'vote' | 'withdraw_vesting' | 'witness_update';
/**
* Virtual operation name.
*/
export type VirtualOperationName = 'author_reward' | 'comment_benefactor_reward' | 'comment_payout_update' | 'comment_reward' | 'curation_reward' | 'fill_convert_request' | 'fill_order' | 'fill_transfer_from_savings' | 'fill_vesting_withdraw' | 'hardfork' | 'interest' | 'liquidity_reward' | 'return_vesting_delegation' | 'shutdown_witness';
/**
* Generic operation.
*/
export interface Operation {
0: OperationName | VirtualOperationName;
1: {
[key: string]: any;
};
}
export interface AppliedOperation {
trx_id: string;
block: number;
trx_in_block: number;
op_in_trx: number;
virtual_op: number;
timestamp: string;
op: Operation;
}
export interface AccountCreateOperation extends Operation {
0: 'account_create';
1: {
fee: string | Asset;
creator: string;
new_account_name: string;
owner: AuthorityType;
active: AuthorityType;
posting: AuthorityType;
memo_key: string | PublicKey;
json_metadata: string;
};
}
export interface AccountCreateWithDelegationOperation extends Operation {
0: 'account_create_with_delegation';
1: {
fee: string | Asset;
delegation: string | Asset;
creator: string;
new_account_name: string;
owner: AuthorityType;
active: AuthorityType;
posting: AuthorityType;
memo_key: string | PublicKey;
json_metadata: string;
/**
* Extensions. Not currently used.
*/
extensions: any[];
};
}
export interface AccountUpdateOperation extends Operation {
0: 'account_update';
1: {
account: string;
owner?: AuthorityType;
active?: AuthorityType;
posting?: AuthorityType;
memo_key: string | PublicKey;
json_metadata: string;
};
}
export interface AccountWitnessProxyOperation extends Operation {
0: 'account_witness_proxy';
1: {
account: string;
proxy: string;
};
}
export interface AccountWitnessVoteOperation extends Operation {
0: 'account_witness_vote';
1: {
account: string;
witness: string;
approve: boolean;
};
}
export interface CancelTransferFromSavingsOperation extends Operation {
0: 'cancel_transfer_from_savings';
1: {
from: string;
request_id: number;
};
}
export interface ChallengeAuthorityOperation extends Operation {
0: 'challenge_authority';
1: {
challenger: string;
challenged: string;
require_owner: boolean;
};
}
/**
* Each account lists another account as their recovery account.
* The recovery account has the ability to create account_recovery_requests
* for the account to recover. An account can change their recovery account
* at any time with a 30 day delay. This delay is to prevent
* an attacker from changing the recovery account to a malicious account
* during an attack. These 30 days match the 30 days that an
* owner authority is valid for recovery purposes.
*
* On account creation the recovery account is set either to the creator of
* the account (The account that pays the creation fee and is a signer on the transaction)
* or to the empty string if the account was mined. An account with no recovery
* has the top voted witness as a recovery account, at the time the recover
* request is created. Note: This does mean the effective recovery account
* of an account with no listed recovery account can change at any time as
* witness vote weights. The top voted witness is explicitly the most trusted
* witness according to stake.
*/
export interface ChangeRecoveryAccountOperation extends Operation {
0: 'change_recovery_account';
1: {
/**
* The account that would be recovered in case of compromise.
*/
account_to_recover: string;
/**
* The account that creates the recover request.
*/
new_recovery_account: string;
/**
* Extensions. Not currently used.
*/
extensions: any[];
};
}
export interface ClaimRewardBalanceOperation extends Operation {
0: 'claim_reward_balance';
1: {
account: string;
reward_worth: string | Asset;
reward_sbd: string | Asset;
reward_vests: string | Asset;
};
}
export interface CommentOperation extends Operation {
0: 'comment';
1: {
parent_author: string;
parent_permlink: string;
author: string;
permlink: string;
title: string;
body: string;
json_metadata: string;
};
}
export interface CommentOptionsOperation extends Operation {
0: 'comment_options';
1: {
author: string;
permlink: string;
/** WBD value of the maximum payout this post will receive. */
max_accepted_payout: Asset | string;
/** The percent of Wortheum Dollars to key, unkept amounts will be received as Wortheum Power. */
percent_worth_dollars: number;
/** Whether to allow post to receive votes. */
allow_votes: boolean;
/** Whether to allow post to recieve curation rewards. */
allow_curation_rewards: boolean;
extensions: Array<[0, {
beneficiaries: BeneficiaryRoute[];
}]>;
};
}
export interface ConvertOperation extends Operation {
0: 'convert';
1: {
owner: string;
requestid: number;
amount: Asset | string;
};
}
export interface CustomOperation extends Operation {
0: 'custom';
1: {
required_auths: string[];
id: number;
data: Buffer | HexBuffer | number[];
};
}
export interface CustomBinaryOperation extends Operation {
0: 'custom_binary';
1: {
required_owner_auths: string[];
required_active_auths: string[];
required_posting_auths: string[];
required_auths: AuthorityType[];
/**
* ID string, must be less than 32 characters long.
*/
id: string;
data: Buffer | HexBuffer | number[];
};
}
export interface CustomJsonOperation extends Operation {
0: 'custom_json';
1: {
required_auths: string[];
required_posting_auths: string[];
/**
* ID string, must be less than 32 characters long.
*/
id: string;
/**
* JSON encoded string, must be valid JSON.
*/
json: string;
};
}
export interface DeclineVotingRightsOperation extends Operation {
0: 'decline_voting_rights';
1: {
account: string;
decline: boolean;
};
}
export interface DelegateVestingSharesOperation extends Operation {
0: 'delegate_vesting_shares';
1: {
/**
* The account delegating vesting shares.
*/
delegator: string;
/**
* The account receiving vesting shares.
*/
delegatee: string;
/**
* The amount of vesting shares delegated.
*/
vesting_shares: string | Asset;
};
}
export interface DeleteCommentOperation extends Operation {
0: 'delete_comment';
1: {
author: string;
permlink: string;
};
}
/**
* The agent and to accounts must approve an escrow transaction for it to be valid on
* the blockchain. Once a part approves the escrow, the cannot revoke their approval.
* Subsequent escrow approve operations, regardless of the approval, will be rejected.
*/
export interface EscrowApproveOperation extends Operation {
0: 'escrow_approve';
1: {
from: string;
to: string;
agent: string;
/**
* Either to or agent.
*/
who: string;
escrow_id: number;
approve: boolean;
};
}
/**
* If either the sender or receiver of an escrow payment has an issue, they can
* raise it for dispute. Once a payment is in dispute, the agent has authority over
* who gets what.
*/
export interface EscrowDisputeOperation extends Operation {
0: 'escrow_dispute';
1: {
from: string;
to: string;
agent: string;
who: string;
escrow_id: number;
};
}
/**
* This operation can be used by anyone associated with the escrow transfer to
* release funds if they have permission.
*
* The permission scheme is as follows:
* If there is no dispute and escrow has not expired, either party can release funds to the other.
* If escrow expires and there is no dispute, either party can release funds to either party.
* If there is a dispute regardless of expiration, the agent can release funds to either party
* following whichever agreement was in place between the parties.
*/
export interface EscrowReleaseOperation extends Operation {
0: 'escrow_release';
1: {
from: string;
/**
* The original 'to'.
*/
to: string;
agent: string;
/**
* The account that is attempting to release the funds, determines valid 'receiver'.
*/
who: string;
/**
* The account that should receive funds (might be from, might be to).
*/
receiver: string;
escrow_id: number;
/**
* The amount of sbd to release.
*/
sbd_amount: Asset | string;
/**
* The amount of worth to release.
*/
worth_amount: Asset | string;
};
}
/**
* The purpose of this operation is to enable someone to send money contingently to
* another individual. The funds leave the *from* account and go into a temporary balance
* where they are held until *from* releases it to *to* or *to* refunds it to *from*.
*
* In the event of a dispute the *agent* can divide the funds between the to/from account.
* Disputes can be raised any time before or on the dispute deadline time, after the escrow
* has been approved by all parties.
*
* This operation only creates a proposed escrow transfer. Both the *agent* and *to* must
* agree to the terms of the arrangement by approving the escrow.
*
* The escrow agent is paid the fee on approval of all parties. It is up to the escrow agent
* to determine the fee.
*
* Escrow transactions are uniquely identified by 'from' and 'escrow_id', the 'escrow_id' is defined
* by the sender.
*/
export interface EscrowTransferOperation extends Operation {
0: 'escrow_transfer';
1: {
from: string;
to: string;
agent: string;
escrow_id: number;
sbd_amount: Asset | string;
worth_amount: Asset | string;
fee: Asset | string;
ratification_deadline: string;
escrow_expiration: string;
json_meta: string;
};
}
export interface FeedPublishOperation extends Operation {
0: 'feed_publish';
1: {
publisher: string;
exchange_rate: Price | {
base: Asset | string;
quote: Asset | string;
};
};
}
/**
* Cancels an order and returns the balance to owner.
*/
export interface LimitOrderCancelOperation extends Operation {
0: 'limit_order_cancel';
1: {
owner: string;
orderid: number;
};
}
/**
* This operation creates a limit order and matches it against existing open orders.
*/
export interface LimitOrderCreateOperation extends Operation {
0: 'limit_order_create';
1: {
owner: string;
orderid: number;
amount_to_sell: Asset | string;
min_to_receive: Asset | string;
fill_or_kill: boolean;
expiration: string;
};
}
/**
* This operation is identical to limit_order_create except it serializes the price rather
* than calculating it from other fields.
*/
export interface LimitOrderCreate2Operation extends Operation {
0: 'limit_order_create2';
1: {
owner: string;
orderid: number;
amount_to_sell: Asset | string;
fill_or_kill: boolean;
exchange_rate: Price | {
base: Asset | string;
quote: Asset | string;
};
expiration: string;
};
}
/**
* Legacy proof of work operation.
*/
export interface PowOperation extends Operation {
0: 'pow';
1: {
worker_account: string;
block_id: any;
nonce: number;
work: any;
props: any;
};
}
/**
* Legacy equihash proof of work operation.
*/
export interface Pow2Operation extends Operation {
0: 'pow2';
1: {
work: any;
new_owner_key?: string | PublicKey;
props: any;
};
}
export interface ProveAuthorityOperation extends Operation {
0: 'prove_authority';
1: {
challenged: string;
require_owner: boolean;
};
}
/**
* Recover an account to a new authority using a previous authority and verification
* of the recovery account as proof of identity. This operation can only succeed
* if there was a recovery request sent by the account's recover account.
*
* In order to recover the account, the account holder must provide proof
* of past ownership and proof of identity to the recovery account. Being able
* to satisfy an owner authority that was used in the past 30 days is sufficient
* to prove past ownership. The get_owner_history function in the database API
* returns past owner authorities that are valid for account recovery.
*
* Proving identity is an off chain contract between the account holder and
* the recovery account. The recovery request contains a new authority which
* must be satisfied by the account holder to regain control. The actual process
* of verifying authority may become complicated, but that is an application
* level concern, not a blockchain concern.
*
* This operation requires both the past and future owner authorities in the
* operation because neither of them can be derived from the current chain state.
* The operation must be signed by keys that satisfy both the new owner authority
* and the recent owner authority. Failing either fails the operation entirely.
*
* If a recovery request was made inadvertantly, the account holder should
* contact the recovery account to have the request deleted.
*
* The two setp combination of the account recovery request and recover is
* safe because the recovery account never has access to secrets of the account
* to recover. They simply act as an on chain endorsement of off chain identity.
* In other systems, a fork would be required to enforce such off chain state.
* Additionally, an account cannot be permanently recovered to the wrong account.
* While any owner authority from the past 30 days can be used, including a compromised
* authority, the account can be continually recovered until the recovery account
* is confident a combination of uncompromised authorities were used to
* recover the account. The actual process of verifying authority may become
* complicated, but that is an application level concern, not the blockchain's
* concern.
*/
export interface RecoverAccountOperation extends Operation {
0: 'recover_account';
1: {
/**
* The account to be recovered.
*/
account_to_recover: string;
/**
* The new owner authority as specified in the request account recovery operation.
*/
new_owner_authority: AuthorityType;
/**
* A previous owner authority that the account holder will use to prove
* past ownership of the account to be recovered.
*/
recent_owner_authority: AuthorityType;
/**
* Extensions. Not currently used.
*/
extensions: any[];
};
}
/**
* This operation is used to report a miner who signs two blocks
* at the same time. To be valid, the violation must be reported within
* WORTH_MAX_WITNESSES blocks of the head block (1 round) and the
* producer must be in the ACTIVE witness set.
*
* Users not in the ACTIVE witness set should not have to worry about their
* key getting compromised and being used to produced multiple blocks so
* the attacker can report it and steel their vesting worth.
*
* The result of the operation is to transfer the full VESTING WORTH balance
* of the block producer to the reporter.
*/
export interface ReportOverProductionOperation extends Operation {
0: 'report_over_production';
1: {
reporter: string;
first_block: SignedBlockHeader;
second_block: SignedBlockHeader;
};
}
/**
* All account recovery requests come from a listed recovery account. This
* is secure based on the assumption that only a trusted account should be
* a recovery account. It is the responsibility of the recovery account to
* verify the identity of the account holder of the account to recover by
* whichever means they have agreed upon. The blockchain assumes identity
* has been verified when this operation is broadcast.
*
* This operation creates an account recovery request which the account to
* recover has 24 hours to respond to before the request expires and is
* invalidated.
*
* T