@xelis/sdk 0.9.11 → 0.10.1

package/dist/types/daemon/types.d.ts

@@ -1,18 +1,21 @@
 export interface GetInfoResult {
-    average_block_time: number;
-    block_reward: number;
-    block_time_target: number;
-    circulating_supply: number;
-    difficulty: string;
     height: number;
-    maximum_supply: number;
-    mempool_size: number;
-    network: string;
-    pruned_topoheight?: number;
+    topoheight: number;
     stableheight: number;
+    pruned_topoheight?: number;
     top_block_hash: string;
-    topoheight: number;
+    circulating_supply: number;
+    burned_supply: number;
+    maximum_supply: number;
+    difficulty: string;
+    block_time_target: number;
+    average_block_time: number;
+    block_reward: number;
+    dev_reward: number;
+    miner_reward: number;
+    mempool_size: number;
     version: string;
+    network: string;
 }
 export interface Block {
     hash: string;
@@ -162,9 +165,28 @@ export interface Burn {
     asset: string;
     amount: number;
 }
+export interface MultiSigPayload {
+    participants: string[];
+    threshold: number;
+}
+export interface ContractDeposit {
+    public: number;
+}
+export interface InvokeContractPayload {
+    contract: string;
+    deposits: {
+        [key: string]: ContractDeposit;
+    };
+    chunk_id: number;
+    max_gas: number;
+    parameters: number[][];
+}
 export interface TransactionData {
-    transfers: Transfer[];
-    burn: Burn;
+    transfers: Transfer[] | null;
+    burn: Burn | null;
+    multi_sig: MultiSigPayload | null;
+    invoke_contract: InvokeContractPayload | null;
+    deploy_contract: Module | null;
 }
 export interface SourceCommitment {
     commitment: number[];
@@ -184,16 +206,10 @@ export interface Transaction {
     nonce: number;
     source_commitments: SourceCommitment[];
     range_proof: number[];
-    signature: string;
     reference: Reference;
+    signature: string;
     size: number;
 }
-export interface TransactionResponse extends Transaction {
-    blocks: string[];
-    executed_in_block: string;
-    in_mempool: boolean;
-    first_seen?: number;
-}
 export interface TransactionExecuted {
     tx_hash: string;
     block_hash: string;
@@ -360,69 +376,225 @@ export interface SplitAddressResult {
     address: string;
     integrated_data: string;
 }
+export interface HardFork {
+    height: number;
+    version: number;
+    changelog: string;
+    version_requirement: string | null;
+}
+export interface GetTransactionExecutorResult {
+    block_topoheight: number;
+    block_timestamp: number;
+    block_hash: string;
+}
+export interface FeeRatesEstimated {
+    low: number;
+    medium: number;
+    high: number;
+    default: number;
+}
+export interface MakeIntegratedAddressParams {
+    address: string;
+    integrated_data: any;
+}
+export interface DecryptExtraDataParams {
+    shared_key: number[];
+    extra_data: number[];
+}
+export interface GetMutilsigAtTopoheightParams {
+    address: string;
+    topoheight: number;
+}
+export interface HasMultisigAtTopoheightParams {
+    address: string;
+    topoheight: number;
+}
+export interface GetMutilsigAtTopoheightResult {
+    state: string;
+}
+export interface GetMultisigParams {
+    address: string;
+}
+export interface GetMultisigResult {
+    state: string;
+    topoheight: number;
+}
+export interface HasMultisigParams {
+    address: string;
+    topoheight?: number;
+}
+export interface GetContractOutputsParams {
+    transaction: string;
+}
+export interface GetContractModuleParams {
+    contract: string;
+}
+export interface GetContractDataPrams {
+    contract: string;
+    key: any;
+}
+export interface GetContractDataAtTopoheightParams {
+    contract: string;
+    key: any;
+    topoheight: number;
+}
+export interface GetContractBalanceParams {
+    contract: string;
+    asset: string;
+}
+export interface GetContractBalanceAtTopoheightParams {
+    contract: string;
+    asset: string;
+    topoheight: number;
+}
+export interface Chunk {
+    instructions: number[];
+}
+export interface Module {
+    constants: any;
+    chunks: Chunk[];
+    entry_chunk_ids: number[];
+    structs: any[];
+    enums: any[];
+}
+export interface GetContractModuleResult {
+    previous_topoheight: number | null;
+    data: Module | null;
+}
+export interface GetContractDataResult {
+    previous_topoheight: number | null;
+    data: any | null;
+}
+export interface GetContractBalanceAtTopoheightResult {
+    data: number;
+    previous_topoheight: number | null;
+}
+export interface GetContractBalanceResult {
+    topoheight: number;
+    amount: number;
+    previous_topoheight: number | null;
+}
+export interface ContractOutputRefundGas {
+    amount: number;
+}
+export interface ContractOutputTransfer {
+    amount: number;
+    asset: string;
+    destination: string;
+}
+export interface ContractOutputExitCode {
+    exit_code: number;
+}
+export interface ContractOutputRefundDeposits {
+}
+export type ContractOutput = ContractOutputRefundGas | ContractOutputTransfer | ContractOutputExitCode | ContractOutputRefundDeposits;
+export interface TransactionResponse extends Transaction {
+    blocks: string[];
+    executed_in_block: string;
+    in_mempool: boolean;
+    first_seen?: number;
+}
+export interface StableTopoHeightChanged {
+    previous_stable_topoheight: number;
+    new_stable_topoheight: number;
+}
+export interface InvokeContractParams {
+    contract: string;
+}
+export interface InvokeContract {
+    block_hash: string;
+    tx_hash: string;
+    topoheight: number;
+    contract_outputs: ContractOutput[];
+}
+export interface NewContract {
+    contract: string;
+    block_hash: string;
+    topoheight: number;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
-    GetInfo = "get_info",
     GetHeight = "get_height",
     GetTopoheight = "get_topoheight",
+    GetPrunedTopoheight = "get_pruned_topoheight",
+    GetInfo = "get_info",
+    GetDifficulty = "get_difficulty",
+    GetTips = "get_tips",
+    GetDevFeeThresholds = "get_dev_fee_thresholds",
+    GetSizeOnDisk = "get_size_on_disk",
     GetStableHeight = "get_stable_height",
     GetStableTopoheight = "get_stable_topoheight",
-    GetStableBalance = "get_stable_balance",
-    GetBlockTemplate = "get_block_template",
+    GetHardForks = "get_hard_forks",
     GetBlockAtTopoheight = "get_block_at_topoheight",
     GetBlocksAtHeight = "get_blocks_at_height",
     GetBlockByHash = "get_block_by_hash",
     GetTopBlock = "get_top_block",
-    GetNonce = "get_nonce",
-    GetNonceAtTopoheight = "get_nonce_at_topoheight",
-    HasNonce = "has_nonce",
     GetBalance = "get_balance",
+    GetStableBalance = "get_stable_balance",
     HasBalance = "has_balance",
     GetBalanceAtTopoheight = "get_balance_at_topoheight",
+    GetNonce = "get_nonce",
+    HasNonce = "has_nonce",
+    GetNonceAtTopoheight = "get_nonce_at_topoheight",
     GetAsset = "get_asset",
     GetAssets = "get_assets",
     CountAssets = "count_assets",
     CountTransactions = "count_transactions",
-    GetTips = "get_tips",
-    P2PStatus = "p2p_status",
-    GetDAGOrder = "get_dag_order",
-    GetMempool = "get_mempool",
+    CountAccounts = "count_accounts",
+    CountContracts = "count_contracts",
+    SubmitTransaction = "submit_transaction",
+    GetTransactionExecutor = "get_transaction_executor",
     GetTransaction = "get_transaction",
     GetTransactions = "get_transactions",
+    IsTxExecutedInBlock = "is_tx_executed_in_block",
+    P2PStatus = "p2p_status",
+    GetPeers = "get_peers",
+    GetMempool = "get_mempool",
+    GetMempoolCache = "get_mempool_cache",
+    GetEstimatedFeeRates = "get_estimated_fee_rates",
+    GetDAGOrder = "get_dag_order",
     GetBlocksRangeByTopoheight = "get_blocks_range_by_topoheight",
     GetBlocksRangeByHeight = "get_blocks_range_by_height",
-    GetAccounts = "get_accounts",
-    SubmitBlock = "submit_block",
-    SubmitTransaction = "submit_transaction",
-    CountAccounts = "count_accounts",
     GetAccountHistory = "get_account_history",
     GetAccountAssets = "get_account_assets",
-    GetPeers = "get_peers",
-    GetDevFeeThresholds = "get_dev_fee_thresholds",
-    GetSizeOnDisk = "get_size_on_disk",
-    IsTxExecutedInBlock = "is_tx_executed_in_block",
-    GetAccountRegistrationTopoheight = "get_account_registration_topoheight",
+    GetAccounts = "get_accounts",
     IsAccountRegistered = "is_account_registered",
-    GetMempoolCache = "get_mempool_cache",
-    GetDifficulty = "get_difficulty",
+    GetAccountRegistrationTopoheight = "get_account_registration_topoheight",
     ValidateAddress = "validate_address",
+    SplitAddress = "split_address",
     ExtractKeyFromAddress = "extract_key_from_address",
+    MakeIntegratedAddress = "make_integrated_address",
+    DecryptExtraData = "decrypt_extra_data",
+    GetMultisigAtTopoheight = "get_multisig_at_topoheight",
+    GetMultisig = "get_multisig",
+    HasMultisig = "has_multisig",
+    HasMultisigAtTopoheight = "has_multisig_at_topoheight",
+    GetContractOutputs = "get_contract_outputs",
+    GetContractModule = "get_contract_module",
+    GetContractData = "get_contract_data",
+    GetContractDataAtTopoheight = "get_contract_data_at_topoheight",
+    GetContractBalance = "get_contract_balance",
+    GetContractBalanceAtTopoheight = "get_contract_balance_at_topoheight",
+    GetBlockTemplate = "get_block_template",
     GetMinerWork = "get_miner_work",
-    SplitAddress = "split_address"
+    SubmitBlock = "submit_block"
 }
 export declare enum RPCEvent {
     NewBlock = "new_block",
     BlockOrdered = "block_ordered",
     BlockOrphaned = "block_orphaned",
     StableHeightChanged = "stable_height_changed",
+    StableTopoHeightChanged = "stable_topo_height_changed",
     TransactionOrphaned = "transaction_orphaned",
     TransactionAddedInMempool = "transaction_added_in_mempool",
     TransactionExecuted = "transaction_executed",
-    TransactionSCResult = "transaction_sc_result",
+    InvokeContract = "invoke_contract",
+    DeployContract = "deploy_contract",
     NewAsset = "new_asset",
     PeerConnected = "peer_connected",
     PeerDisconnected = "peer_disconnected",
-    PeerPeerListUpdated = "peer_peer_list_updated",
     PeerStateUpdated = "peer_state_updated",
-    PeerPeerDisconnected = "peer_peer_disconnected"
+    PeerPeerListUpdated = "peer_peer_list_updated",
+    PeerPeerDisconnected = "peer_peer_disconnected",
+    NewBlockTemplate = "new_block_template"
 }

package/dist/types/daemon/websocket.d.ts

@@ -1,74 +1,95 @@
 import { MessageEvent } from 'ws';
-import { Block, GetInfoResult, GetPeersResult, RPCEventResult, TopoheightRangeParams, P2PStatusResult, GetBalanceAtTopoheightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoheightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned, VersionedBalance, StableHeightChanged, HasNonceResult, HasNonceParams, TransactionResponse, IsAccountRegisteredParams, GetMempoolCacheResult, GetDifficultyResult, ValidateAddressParams, ExtractKeyFromAddressParams, SubmitBlockParams, GetMinerWorkParams, GetMinerWorkResult, ValidateAddressResult, TransactionExecuted, GetStableBalanceResult, GetAssetsParams, SplitAddressParams, SplitAddressResult } from './types';
-import { WS as BaseWS } from '../lib/websocket';
+import * as types from './types';
+import { WSRPC } from '../rpc/websocket';
 export declare class DaemonMethods {
-    ws: BaseWS;
+    ws: WSRPC;
     prefix: string;
-    constructor(ws: BaseWS, prefix?: string);
-    listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+    constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    onNewBlock(onData: (msgEvent: MessageEvent, data?: Block & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: TransactionResponse & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: TransactionExecuted & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBlockOrdered(onData: (msgEvent: MessageEvent, data?: BlockOrdered & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerConnected(onData: (msgEvent: MessageEvent, data?: Peer & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerDisconnected(onData: (msgEvent: MessageEvent, data?: number & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerPeerListUpdated(onData: (msgEvent: MessageEvent, data?: PeerPeerListUpdated & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerPeerDisconnected(onData: (msgEvent: MessageEvent, data?: PeerPeerDisconnected & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerStateUpdated(onData: (msgEvent: MessageEvent, data?: Peer & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewAsset(onData: (msgEvent: MessageEvent, data?: AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBlockOrphaned(onData: (msgEvent: MessageEvent, data?: BlockOrphaned & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionOrphaned(onData: (msgEvent: MessageEvent, data?: TransactionResponse & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onStableHeightChanged(onData: (msgEvent: MessageEvent, data?: StableHeightChanged & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewBlock(onData: (msgEvent: MessageEvent, data?: types.Block & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onBlockOrdered(onData: (msgEvent: MessageEvent, data?: types.BlockOrdered & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onBlockOrphaned(onData: (msgEvent: MessageEvent, data?: types.BlockOrphaned & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onStableHeightChanged(onData: (msgEvent: MessageEvent, data?: types.StableHeightChanged & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onStableTopoHeightChanged(onData: (msgEvent: MessageEvent, data?: types.StableTopoHeightChanged & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onTransactionOrphaned(onData: (msgEvent: MessageEvent, data?: types.TransactionResponse & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: types.TransactionResponse & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: types.TransactionExecuted & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onInvokeContract(contract: string, onData: (msgEvent: MessageEvent, data?: types.InvokeContract & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onDeployContract(onData: (msgEvent: MessageEvent, data?: types.NewContract & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewAsset(onData: (msgEvent: MessageEvent, data?: types.AssetWithData & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onPeerConnected(onData: (msgEvent: MessageEvent, data?: types.Peer & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onPeerDisconnected(onData: (msgEvent: MessageEvent, data?: number & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onPeerStateUpdated(onData: (msgEvent: MessageEvent, data?: types.Peer & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onPeerPeerListUpdated(onData: (msgEvent: MessageEvent, data?: types.PeerPeerListUpdated & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onPeerPeerDisconnected(onData: (msgEvent: MessageEvent, data?: types.PeerPeerDisconnected & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewBlockTemplate(onData: (msgEvent: MessageEvent, data?: types.GetBlockTemplateResult & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     getVersion(): Promise<string>;
     getHeight(): Promise<number>;
     getTopoheight(): Promise<number>;
+    getPrunedTopoheight(): Promise<number>;
+    getInfo(): Promise<types.GetInfoResult>;
+    getDifficulty(): Promise<types.GetDifficultyResult>;
+    getTips(): Promise<string[]>;
+    getDevFeeThresholds(): Promise<types.DevFee[]>;
+    getSizeOnDisk(): Promise<types.DiskSize>;
     getStableHeight(): Promise<number>;
     getStableTopoheight(): Promise<number>;
-    getStableBalance(params: GetBalanceParams): Promise<GetStableBalanceResult>;
-    getBlockTemplate(address: string): Promise<string>;
-    getBlockAtTopoheight(params: GetBlockAtTopoheightParams): Promise<Block>;
-    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<Block[]>;
-    getBlockByHash(params: GetBlockByHashParams): Promise<Block>;
-    getTopBlock(params: GetTopBlockParams): Promise<Block>;
-    submitBlock(params: SubmitBlockParams): Promise<boolean>;
-    getBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
-    hasBalance(params: HasBalanceParams): Promise<HasBalanceResult>;
-    getBalanceAtTopoheight(params: GetBalanceAtTopoheightParams): Promise<VersionedBalance>;
-    getInfo(): Promise<GetInfoResult>;
-    getNonce(params: GetNonceParams): Promise<GetNonceResult>;
-    hasNonce(params: HasNonceParams): Promise<HasNonceResult>;
-    getAsset(params: GetAssetParams): Promise<AssetData>;
-    getAssets(params?: GetAssetsParams): Promise<string[]>;
+    getHardForks(): Promise<types.HardFork[]>;
+    getBlockAtTopoheight(params: types.GetBlockAtTopoheightParams): Promise<types.Block>;
+    getBlocksAtHeight(params: types.GetBlocksAtHeightParams): Promise<types.Block[]>;
+    getBlockByHash(params: types.GetBlockByHashParams): Promise<types.Block>;
+    getTopBlock(params: types.GetTopBlockParams): Promise<types.Block>;
+    getBalance(params: types.GetBalanceParams): Promise<types.GetBalanceResult>;
+    getStableBalance(params: types.GetBalanceParams): Promise<types.GetStableBalanceResult>;
+    hasBalance(params: types.HasBalanceParams): Promise<types.HasBalanceResult>;
+    getBalanceAtTopoheight(params: types.GetBalanceAtTopoheightParams): Promise<types.VersionedBalance>;
+    getNonce(params: types.GetNonceParams): Promise<types.GetNonceResult>;
+    hasNonce(params: types.HasNonceParams): Promise<types.HasNonceResult>;
+    getNonceAtTopoheight(params: types.GetNonceAtTopoheightParams): Promise<types.VersionedNonce>;
+    getAsset(params: types.GetAssetParams): Promise<types.AssetData>;
+    getAssets(params?: types.GetAssetsParams): Promise<string[]>;
     countAssets(): Promise<number>;
-    countAccounts(): Promise<number>;
     countTransactions(): Promise<number>;
+    countAccounts(): Promise<number>;
+    countContracts(): Promise<number>;
     submitTransaction(hexData: string): Promise<boolean>;
-    getTransaction(hash: string): Promise<TransactionResponse>;
-    p2pStatus(): Promise<P2PStatusResult>;
-    getPeers(): Promise<GetPeersResult>;
-    getMemPool(): Promise<TransactionResponse[]>;
-    getTips(): Promise<string[]>;
-    getDAGOrder(params: TopoheightRangeParams): Promise<string[]>;
-    getBlocksRangeByTopoheight(params: TopoheightRangeParams): Promise<Block[]>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<Block[]>;
-    getTransactions(txHashes: string[]): Promise<TransactionResponse[]>;
-    getAccountHistory(params: GetAccountHistoryParams): Promise<AccounHistory[]>;
+    getTransactionExecutor(hash: string): Promise<types.GetTransactionExecutorResult>;
+    getTransaction(hash: string): Promise<types.TransactionResponse>;
+    getTransactions(txHashes: string[]): Promise<types.TransactionResponse[]>;
+    isTxExecutedInBlock(params: types.IsTxExecutedInBlockParams): Promise<boolean>;
+    p2pStatus(): Promise<types.P2PStatusResult>;
+    getPeers(): Promise<types.GetPeersResult>;
+    getMemPool(): Promise<types.TransactionResponse[]>;
+    getMempoolCache(address: string): Promise<types.GetMempoolCacheResult>;
+    getEstimatedFeeRates(): Promise<types.FeeRatesEstimated>;
+    getDAGOrder(params: types.TopoheightRangeParams): Promise<string[]>;
+    getBlocksRangeByTopoheight(params: types.TopoheightRangeParams): Promise<types.Block[]>;
+    getBlocksRangeByHeight(params: types.HeightRangeParams): Promise<types.Block[]>;
+    getAccountHistory(params: types.GetAccountHistoryParams): Promise<types.AccounHistory[]>;
     getAccountAssets(address: string): Promise<string[]>;
-    getAccounts(params: GetAccountsParams): Promise<string[]>;
-    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<boolean>;
-    getDevFeeThresholds(): Promise<DevFee[]>;
-    getSizeOnDisk(): Promise<DiskSize>;
+    getAccounts(params: types.GetAccountsParams): Promise<string[]>;
+    isAccountRegistered(params: types.IsAccountRegisteredParams): Promise<boolean>;
     getAccountRegistrationTopoheight(address: String): Promise<Number>;
-    isAccountRegistered(params: IsAccountRegisteredParams): Promise<boolean>;
-    getMempoolCacheResult(address: string): Promise<GetMempoolCacheResult>;
-    getDifficulty(): Promise<GetDifficultyResult>;
-    validateAddress(params: ValidateAddressParams): Promise<ValidateAddressResult>;
-    extractKeyFromAddress(params: ExtractKeyFromAddressParams): Promise<string | number[]>;
-    getMinerWork(params: GetMinerWorkParams): Promise<GetMinerWorkResult>;
-    splitAddress(params: SplitAddressParams): Promise<SplitAddressResult>;
+    validateAddress(params: types.ValidateAddressParams): Promise<types.ValidateAddressResult>;
+    splitAddress(params: types.SplitAddressParams): Promise<types.SplitAddressResult>;
+    extractKeyFromAddress(params: types.ExtractKeyFromAddressParams): Promise<string | number[]>;
+    makeIntegratedAddress(params: types.MakeIntegratedAddressParams): Promise<string>;
+    decryptExtraData(params: types.DecryptExtraDataParams): Promise<unknown>;
+    getMultisigAtTopoheight(params: types.GetMutilsigAtTopoheightParams): Promise<types.GetMutilsigAtTopoheightResult>;
+    getMultisig(params: types.GetMultisigParams): Promise<types.GetMultisigResult>;
+    hasMultisig(params: types.HasMultisigParams): Promise<boolean>;
+    hasMultisigAtTopoheight(params: types.HasMultisigAtTopoheightParams): Promise<boolean>;
+    getContractOutputs(params: types.GetContractOutputsParams): Promise<types.ContractOutput[]>;
+    getContractModule(params: types.GetContractModuleParams): Promise<types.GetContractModuleResult>;
+    getContractData(params: types.GetContractModuleParams): Promise<unknown>;
+    getContractDataAtTopoheight(params: types.GetContractDataAtTopoheightParams): Promise<unknown>;
+    getContractBalance(params: types.GetContractBalanceParams): Promise<types.GetContractBalanceResult>;
+    getContractBalanceAtTopoheight(params: types.GetContractBalanceAtTopoheightParams): Promise<types.GetContractBalanceAtTopoheightResult>;
+    getBlockTemplate(address: string): Promise<string>;
+    getMinerWork(params: types.GetMinerWorkParams): Promise<types.GetMinerWorkResult>;
+    submitBlock(params: types.SubmitBlockParams): Promise<boolean>;
 }
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     methods: DaemonMethods;
     constructor();
 }

package/dist/types/data/element.d.ts

@@ -0,0 +1,20 @@
+import { Value } from "./value";
+export declare enum ElementType {
+    Value = 0,
+    Array = 1,
+    Fields = 2
+}
+export declare class Element {
+    value?: Value;
+    array?: Element[];
+    fields?: Map<Value, Element>;
+    constructor();
+    static v(data: any): Element;
+    static value(value: Value): Element;
+    static array(arr: Element[]): Element;
+    static fields(fields: Map<Value, Element>): Element;
+    validate(): ElementType;
+    static fromBytes(data: Uint8Array): Element;
+    toBytes(): Uint8Array;
+    toObject(): {};
+}

package/dist/types/data/value.d.ts

@@ -0,0 +1,50 @@
+import { Element } from "./element";
+export declare enum ValueType {
+    Bool = 0,
+    String = 1,
+    U8 = 2,
+    U16 = 3,
+    U32 = 4,
+    U64 = 5,
+    U128 = 6,
+    Hash = 7,
+    Blob = 8
+}
+export declare class Value {
+    vType: ValueType;
+    data: any;
+    constructor(vType: ValueType, data: any);
+    static new(data: any): Value;
+}
+export declare class ValueReader {
+    data: number[];
+    constructor(data: Uint8Array);
+    read(): Element;
+    readByte(): number;
+    readU16(): number;
+    readU32(): number;
+    readU64(): bigint;
+    readU128(): bigint;
+    readString(): string;
+    readBool(): boolean;
+    readHash(): number[];
+    readBlob(): number[];
+    readValue(): Value;
+}
+export declare class ValueWriter {
+    data: number[];
+    constructor();
+    write(dataElement: Element): void;
+    appendData(data: Uint8Array): void;
+    appendBuffer(buf: ArrayBuffer): void;
+    writeU8(value: number): void;
+    writeU16(value: number): void;
+    writeU32(value: number): void;
+    writeU64(value: bigint): void;
+    writeU128(value: BigInt): void;
+    writeString(value: string): void;
+    writeBool(value: boolean): void;
+    writeBlob(value: []): void;
+    writeHash(value: Uint8Array): void;
+    writeValue(value: Value): void;
+}

package/dist/types/rpc/http.d.ts

@@ -0,0 +1,9 @@
+import { RPCRequest } from './types';
+export declare class HttpRPC {
+    endpoint: string;
+    timeout: number;
+    headers: Headers;
+    constructor(endpoint: string);
+    batchRequest(requests: RPCRequest[]): Promise<any | Error[]>;
+    request<T>(method: string, params?: any): Promise<T>;
+}

package/dist/types/rpc/parse_json/parse_json.d.ts

@@ -0,0 +1 @@
+export declare const parseJSON: (data: string) => any;

package/dist/types/{lib → rpc}/websocket.d.ts

@@ -2,8 +2,15 @@
 import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { ClientRequestArgs } from 'http';
-import { RPCResponse } from './types';
-export declare class WS {
+import { RPCRequest } from './types';
+export type EventWithParams = {
+    [event: string]: {};
+};
+export type EventKey = string | EventWithParams;
+export type IdRefObj = {
+    id?: number;
+};
+export declare class WSRPC {
     endpoint: string;
     socket?: WebSocket;
     timeout: number;
@@ -19,12 +26,9 @@ export declare class WS {
     tryReconnect(): void;
     close(): void;
     private clearEvent;
-    closeAllListens(event: string): Promise<void>;
-    listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
-    call<T>(method: string, params?: any, overwriteData?: string): Promise<RPCResponse<T>>;
-    dataCall<T>(method: string, params?: any): Promise<T>;
-    createRequestMethod(method: string, params?: any): {
-        data: string;
-        id: number | null;
-    };
+    closeAllListens(event: EventKey): Promise<void>;
+    listenEvent<T>(event: EventKey, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+    batchCall(requests: RPCRequest[]): Promise<any[]>;
+    rawCall<T>(id: number, body: string): Promise<T>;
+    dataCall<T>(method: string, params?: any, idRefObj?: IdRefObj): Promise<T>;
 }