@xelis/sdk 0.9.11 → 0.10.1

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

@@ -1,29 +1,48 @@
-import { GetAssetParams, HasBalanceResult, SplitAddressParams, SplitAddressResult } from '../daemon/types';
-import { GetAddressParams, BuildTransactionParams, BuildTransactionResult, ListTransactionParams, Signature, TransactionEntry, RescanParams, SetOnlineModeParams, EstimateFeesParams } from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-import { RPCResponse } from '../lib/types';
-export declare class RPC extends BaseRPC {
-    auth: string;
+import * as daemonTypes from '../daemon/types';
+import * as types from './types';
+import { HttpRPC } from '../rpc/http';
+import { Element } from '../data/element';
+export declare class RPC extends HttpRPC {
     constructor(endpoint: string, username: string, password: string);
-    post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
-    getVersion(): Promise<RPCResponse<string>>;
-    getNetwork(): Promise<RPCResponse<string>>;
-    getNonce(): Promise<RPCResponse<number>>;
-    getTopoheight(): Promise<RPCResponse<number>>;
-    getAddress(params?: GetAddressParams): Promise<RPCResponse<string>>;
-    splitAddress(params: SplitAddressParams): Promise<RPCResponse<SplitAddressResult>>;
-    rescan(params: RescanParams): Promise<RPCResponse<boolean>>;
-    getBalance(asset?: string): Promise<RPCResponse<number>>;
-    hasBalance(asset?: string): Promise<RPCResponse<HasBalanceResult>>;
-    getTrackedAssets(): Promise<RPCResponse<string[]>>;
-    getAssetPrecision(params: GetAssetParams): Promise<RPCResponse<number>>;
-    getTransaction(hash: string): Promise<RPCResponse<TransactionEntry>>;
-    buildTransaction(params: BuildTransactionParams): Promise<RPCResponse<BuildTransactionResult>>;
-    listTransactions(params?: ListTransactionParams): Promise<RPCResponse<TransactionEntry[]>>;
-    isOnline(): Promise<RPCResponse<boolean>>;
-    signData(data: any): Promise<RPCResponse<Signature>>;
-    estimateFees(params: EstimateFeesParams): Promise<RPCResponse<number>>;
-    setOnlineMode(params: SetOnlineModeParams): Promise<RPCResponse<boolean>>;
-    setOfflineMode(): Promise<RPCResponse<boolean>>;
+    getVersion(): Promise<string>;
+    getNetwork(): Promise<string>;
+    getNonce(): Promise<number>;
+    getTopoheight(): Promise<number>;
+    getAddress(params?: types.GetAddressParams): Promise<string>;
+    splitAddress(params: daemonTypes.SplitAddressParams): Promise<daemonTypes.SplitAddressResult>;
+    rescan(params: types.RescanParams): Promise<boolean>;
+    getBalance(asset?: string): Promise<number>;
+    hasBalance(asset?: string): Promise<daemonTypes.HasBalanceResult>;
+    getTrackedAssets(): Promise<string[]>;
+    getAssetPrecision(params: daemonTypes.GetAssetParams): Promise<number>;
+    getAssets(): Promise<{
+        [key: string]: types.Asset;
+    }>;
+    getAsset(params: daemonTypes.GetAssetParams): Promise<types.Asset>;
+    getTransaction(hash: string): Promise<types.TransactionEntry>;
+    buildTransaction(params: types.BuildTransactionParams): Promise<types.TransactionResponse>;
+    buildTransactionOffline(params: types.BuildTransactionOfflineParams): Promise<types.TransactionResponse>;
+    buildUnsignedTransaction(params: types.BuildTransactionParams): Promise<types.UnsignedTransactionResponse>;
+    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<types.SignatureId>;
+    finalizeUnsignedTransaction(params: types.FinalizeUnsignedTransactionParams): Promise<types.TransactionResponse>;
+    clearTxCache(): Promise<boolean>;
+    listTransactions(params?: types.ListTransactionParams): Promise<types.TransactionEntry[]>;
+    isOnline(): Promise<boolean>;
+    setOnlineMode(params: types.SetOnlineModeParams): Promise<boolean>;
+    setOfflineMode(): Promise<boolean>;
+    signData(data: Element): Promise<string>;
+    estimateFees(params: types.EstimateFeesParams): Promise<number>;
+    estimateExtraDataSize(params: types.EstimateExtraDataSizeParams): Promise<types.EstimateExtraDataSizeResult>;
+    networkInfo(): Promise<types.NetworkInfoResult>;
+    decryptExtraData(params: types.DecryptExtraDataParams): Promise<types.PlaintextCiphertext>;
+    decryptCiphertext(params: types.DecryptCiphertextParams): Promise<number>;
+    getMatchingKeys(params: types.GetMatchingKeysParams): Promise<any>;
+    countMatchingEntries(params: types.CountMatchingKeysParams): Promise<number>;
+    getValueFromKey(params: types.GetValueFromKeyParams): Promise<any>;
+    store(params: types.StoreParams): Promise<boolean>;
+    delete(params: types.DeleteParams): Promise<boolean>;
+    deleteTreeEntries(tree: string): Promise<boolean>;
+    hasKey(params: types.HasKeyParams): Promise<boolean>;
+    queryDB(params: types.QueryDBParams): Promise<types.QueryResult>;
 }
 export default RPC;

package/dist/types/wallet/types.d.ts

@@ -1,4 +1,4 @@
-import { Transaction } from '../daemon/types';
+import * as daemonTypes from '../daemon/types';
 export interface GetAddressParams {
     integrated_data?: string;
 }
@@ -6,16 +6,78 @@ export interface FeeBuilder {
     multiplier?: number;
     value?: number;
 }
+export interface MultiSigBuilder {
+    participants: string[];
+    threshold: number;
+}
+export interface ContractDepositBuilder {
+    amount: number;
+    private: boolean;
+}
+export interface InvokeContractBuilder {
+    contract: string;
+    max_gas: number;
+    chunk_id: number;
+    parameters: any[];
+    deposits: {
+        [key: string]: ContractDepositBuilder;
+    };
+}
+export interface TransferBuilder {
+    destination: string;
+    asset: string;
+    amount: number;
+    extra_data?: any;
+}
+export interface SignerId {
+    id: number;
+    private_key: number[];
+}
 export interface BuildTransactionParams {
-    transfers: TransferOut[];
-    burn?: TxBurn;
-    broadcast: boolean;
+    transfers?: TransferBuilder[];
+    burn?: daemonTypes.Burn;
+    multi_sig?: MultiSigBuilder;
+    invoke_contract?: InvokeContractBuilder;
+    deploy_contract?: string;
     fee?: FeeBuilder;
+    nonce?: number;
+    tx_version?: number;
+    broadcast: boolean;
     tx_as_hex: boolean;
+    signers?: SignerId[];
+}
+export interface BuildTransactionOfflineParams extends BuildTransactionParams {
+    nonce: number;
+    reference: daemonTypes.Reference;
 }
-export interface BuildTransactionResult extends Transaction {
+export interface TransactionResponse extends daemonTypes.Transaction {
     txt_as_hex?: string;
 }
+export interface SignatureId {
+    id: number;
+    signature: string;
+}
+export interface MultiSig {
+    signatures: {
+        [id: number]: SignatureId;
+    };
+}
+export interface UnsignedTransaction {
+    version: number;
+    source: string;
+    data: daemonTypes.TransactionData;
+    fee: number;
+    nonce: number;
+    source_commitments: daemonTypes.SourceCommitment[];
+    reference: daemonTypes.Reference;
+    range_proof: number[];
+    multisig?: MultiSig;
+}
+export interface UnsignedTransactionResponse extends UnsignedTransaction {
+    hash: string;
+    threshold: number;
+    tx_as_hex?: string;
+}
 export interface ListTransactionParams {
     min_topoheight?: number;
     max_topoheight?: number;
@@ -29,29 +91,29 @@ export interface Signature {
     s: number[];
     e: number[];
 }
-export interface TxCoinbase {
+export interface Coinbase {
     reward: number;
 }
-export interface TxBurn {
-    asset: string;
+export interface PlaintextExtraData {
+    shared_key: string;
+    data: any;
+}
+export interface TransferOut {
     amount: number;
+    asset: string;
+    destination: string;
+    extra_data: PlaintextExtraData | null;
 }
 export interface TransferIn {
     asset: string;
     amount: number;
-    extra_data?: any;
+    extra_data?: PlaintextExtraData | null;
 }
-export interface TxIncoming {
+export interface Incoming {
     from: string;
     transfers: TransferIn[];
 }
-export interface TransferOut {
-    destination: string;
-    asset: string;
-    amount: number;
-    extra_data?: any;
-}
-export interface TxOutgoing {
+export interface Outgoing {
     transfers: TransferOut;
     fees: number;
     nonce: number;
@@ -59,7 +121,10 @@ export interface TxOutgoing {
 export interface TransactionEntry {
     hash: string;
     topoheight: number;
-    entry: TxCoinbase | TxBurn | TxIncoming | TxOutgoing;
+    outgoing: Outgoing | null;
+    incoming: Incoming | null;
+    burn: daemonTypes.Burn | null;
+    coinbase: Coinbase | null;
 }
 export interface RescanParams {
     until_topoheight?: number;
@@ -70,8 +135,11 @@ export interface SetOnlineModeParams {
     auto_reconnect: boolean;
 }
 export interface EstimateFeesParams {
-    transfers: TransferOut[];
-    burn?: TxBurn;
+    transfers?: TransferBuilder[];
+    burn?: daemonTypes.Burn;
+    multi_sig?: MultiSigBuilder;
+    invoke_contract?: InvokeContractBuilder;
+    deploy_contract?: string;
 }
 export interface BalanceChangedResult {
     asset: string;
@@ -83,6 +151,141 @@ export interface NewTopoheightResult {
 export interface RescanResult {
     start_topoheight: number;
 }
+export interface Asset {
+    decimals: number;
+    name: string;
+    max_supply: number | null;
+}
+export interface EstimateExtraDataSizeParams {
+    destinations: string[];
+}
+export interface EstimateExtraDataSizeResult {
+    size: number;
+}
+export interface NetworkInfoResult extends daemonTypes.GetInfoResult {
+    connected_to: string;
+}
+export declare enum TxRole {
+    Sender = "sender",
+    Receiver = "receiver"
+}
+export interface DecryptExtraDataParams {
+    extra_data: number[];
+    role: TxRole;
+}
+export interface CompressedCiphertext {
+    commitment: number[];
+    handle: number[];
+}
+export interface PlaintextCiphertext {
+    shared_key: string;
+    data: any;
+}
+export interface DecryptCiphertextParams {
+    ciphertext: CompressedCiphertext;
+}
+export interface SignUnsignedTransactionParams {
+    hash: string;
+    signer_id: number;
+}
+export interface FinalizeUnsignedTransactionParams {
+    unsigned: string;
+    signatures: SignatureId[];
+    broadcast: boolean;
+    tx_as_hex: boolean;
+}
+export interface HistorySyncedResult {
+    topoheight: number;
+}
+export interface GetMatchingKeysParams {
+    tree: string;
+    query?: Query;
+}
+export interface CountMatchingKeysParams {
+    tree: string;
+    key?: Query;
+    value?: Query;
+}
+export interface GetValueFromKeyParams {
+    tree: string;
+    key: any;
+}
+export interface StoreParams {
+    tree: string;
+    key: any;
+    value: any;
+}
+export interface DeleteParams {
+    tree: string;
+    key: any;
+}
+export interface HasKeyParams {
+    tree: string;
+    key: any;
+}
+export interface QueryDBParams {
+    tree: string;
+    key?: Query;
+    value?: Query;
+    return_on_first: boolean;
+}
+export interface QueryResult {
+    entries: {
+        [key: string]: any;
+    };
+    next?: number;
+}
+export declare enum ValueType {
+    Bool = 0,
+    String = 1,
+    U8 = 2,
+    U16 = 3,
+    U32 = 4,
+    U64 = 5,
+    U128 = 6,
+    Hash = 7,
+    Blob = 8
+}
+export declare enum ElementType {
+    Value = 0,
+    Array = 1,
+    Fields = 2
+}
+export interface QueryAtKey {
+    key: any;
+    query?: Query;
+}
+export interface QueryNumber {
+    greater?: number;
+    greater_or_equal?: number;
+    lesser?: number;
+    lesser_or_equal?: number;
+}
+export interface QueryPosition {
+    position: number;
+    query?: Query;
+}
+export interface QueryElement {
+    has_key?: QueryAtKey;
+    at_key?: QueryAtKey;
+    len?: QueryNumber;
+    contains_element?: any;
+    at_position?: QueryPosition;
+    element_type?: ElementType;
+}
+export interface QueryValue extends QueryNumber {
+    equal?: any;
+    starts_with?: any;
+    ends_width?: any;
+    contains_value?: any;
+    is_of_type?: ValueType;
+    matches?: string;
+}
+export interface Query extends QueryValue, QueryElement {
+    not?: Query;
+    and?: Query[];
+    or?: Query[];
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetNetwork = "get_network",
@@ -95,14 +298,33 @@ export declare enum RPCMethod {
     HasBalance = "has_balance",
     GetTrackedAssets = "get_tracked_assets",
     GetAssetPrecision = "get_asset_precision",
+    GetAssets = "get_assets",
+    GetAsset = "get_asset",
     GetTransaction = "get_transaction",
     BuildTransaction = "build_transaction",
+    BuildTransactionOffline = "build_transaction_offline",
+    BuildUnsignedTransaction = "build_unsigned_transaction",
+    SignUnsignedTransaction = "sign_unsigned_transaction",
+    FinalizeUnsignedTransaction = "finalize_unsigned_transaction",
+    ClearTxCache = "clear_tx_cache",
     ListTransactions = "list_transactions",
     IsOnline = "is_online",
     SetOnlineMode = "set_online_mode",
     SetOfflineMode = "set_offline_mode",
     SignData = "sign_data",
-    EstimateFees = "estimate_fees"
+    EstimateFees = "estimate_fees",
+    EstimateExtraDataSize = "estimate_extra_data_size",
+    NetworkInfo = "network_info",
+    DecryptExtraData = "decrypt_extra_data",
+    DecryptCiphertext = "decrypt_ciphertext",
+    GetMatchingKeys = "get_matching_keys",
+    CountMatchingEntries = "count_matching_entries",
+    GetValueFromKey = "get_value_from_key",
+    Store = "store",
+    Delete = "delete",
+    DeleteTreeEntries = "delete_tree_entries",
+    HasKey = "has_key",
+    QueryDB = "query_db"
 }
 export declare enum RPCEvent {
     NewTopoheight = "new_topoheight",
@@ -110,6 +332,7 @@ export declare enum RPCEvent {
     NewTransaction = "new_transaction",
     BalanceChanged = "balance_changed",
     Rescan = "rescan",
+    HistorySynced = "history_synced",
     Online = "online",
     Offline = "offline"
 }

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

@@ -1,39 +1,64 @@
-import { WS as BaseWS } from '../lib/websocket';
+import { WSRPC } from '../rpc/websocket';
 import { MessageEvent } from 'ws';
-import { AssetWithData, GetAssetParams, RPCEventResult, SplitAddressParams, SplitAddressResult } from '../daemon/types';
-import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, Signature, RescanParams, SetOnlineModeParams, EstimateFeesParams, TransactionEntry, BalanceChangedResult, NewTopoheightResult, RescanResult } from './types';
+import { RPCEventResult } from '../daemon/types';
+import * as daemonTypes from '../daemon/types';
+import * as types from './types';
+import { Element } from '../data/element';
 export declare class WalletMethods {
-    ws: BaseWS;
+    ws: WSRPC;
     prefix: string;
-    constructor(ws: BaseWS, prefix?: string);
+    constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    onNewTopoheight(onData: (msgEvent: MessageEvent, data?: NewTopoheightResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewAsset(onData: (msgEvent: MessageEvent, data?: AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewTransaction(onData: (msgEvent: MessageEvent, data?: TransactionEntry & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBalanceChanged(onData: (msgEvent: MessageEvent, data?: BalanceChangedResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onRescan(onData: (msgEvent: MessageEvent, data?: RescanResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewTopoheight(onData: (msgEvent: MessageEvent, data?: types.NewTopoheightResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewAsset(onData: (msgEvent: MessageEvent, data?: daemonTypes.AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onNewTransaction(onData: (msgEvent: MessageEvent, data?: types.TransactionEntry & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onBalanceChanged(onData: (msgEvent: MessageEvent, data?: types.BalanceChangedResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onRescan(onData: (msgEvent: MessageEvent, data?: types.RescanResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onHistorySynced(onData: (msgEvent: MessageEvent, data?: types.HistorySyncedResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onOnline(onData: (msgEvent: MessageEvent, data?: RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onOffline(onData: (msgEvent: MessageEvent, data?: RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     getVersion(): Promise<string>;
     getNetwork(): Promise<string>;
     getNonce(): Promise<number>;
     getTopoheight(): Promise<number>;
-    getAddress(params?: GetAddressParams): Promise<string>;
-    splitAddress(params: SplitAddressParams): Promise<SplitAddressResult>;
-    rescan(params: RescanParams): Promise<boolean>;
-    getBalance(asset?: string): Promise<number>;
+    getAddress(params?: types.GetAddressParams): Promise<string>;
+    splitAddress(params: daemonTypes.SplitAddressParams): Promise<daemonTypes.SplitAddressResult>;
+    rescan(params: types.RescanParams): Promise<boolean>;
+    getBalance(asset: string): Promise<number>;
+    hasBalance(asset: string): Promise<daemonTypes.HasBalanceResult>;
     getTrackedAssets(): Promise<string[]>;
-    getAssetPrecision(params: GetAssetParams): Promise<number>;
-    getTransaction(hash: string): Promise<TransactionEntry>;
-    buildTransaction(params: BuildTransactionParams): Promise<BuildTransactionResult>;
-    listTransactions(params?: ListTransactionParams): Promise<TransactionEntry[]>;
+    getAssetPrecision(params: daemonTypes.GetAssetParams): Promise<number>;
+    getAssets(): Promise<{
+        [key: string]: types.Asset;
+    }>;
+    getAsset(params: daemonTypes.GetAssetParams): Promise<types.Asset>;
+    getTransaction(hash: string): Promise<types.TransactionEntry>;
+    buildTransaction(params: types.BuildTransactionParams): Promise<types.TransactionResponse>;
+    buildTransactionOffline(params: types.BuildTransactionOfflineParams): Promise<types.TransactionResponse>;
+    buildUnsignedTransaction(params: types.BuildTransactionParams): Promise<types.UnsignedTransactionResponse>;
+    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<types.SignatureId>;
+    finalizeUnsignedTransaction(params: types.FinalizeUnsignedTransactionParams): Promise<types.TransactionResponse>;
+    clearTxCache(): Promise<boolean>;
+    listTransactions(params?: types.ListTransactionParams): Promise<types.TransactionEntry[]>;
     isOnline(): Promise<boolean>;
-    signData(data: any): Promise<Signature>;
-    estimateFees(params: EstimateFeesParams): Promise<number>;
-    setOnlineMode(params: SetOnlineModeParams): Promise<boolean>;
+    setOnlineMode(params: types.SetOnlineModeParams): Promise<boolean>;
     setOfflineMode(): Promise<boolean>;
+    signData(data: Element): Promise<string>;
+    estimateFees(params: types.EstimateFeesParams): Promise<number>;
+    estimateExtraDataSize(params: types.EstimateExtraDataSizeParams): Promise<types.EstimateExtraDataSizeResult>;
+    networkInfo(): Promise<types.NetworkInfoResult>;
+    decryptExtraData(params: types.DecryptExtraDataParams): Promise<types.PlaintextCiphertext>;
+    decryptCiphertext(params: types.DecryptCiphertextParams): Promise<number>;
+    getMatchingKeys(params: types.GetMatchingKeysParams): Promise<any>;
+    countMatchingEntries(params: types.CountMatchingKeysParams): Promise<number>;
+    getValueFromKey(params: types.GetValueFromKeyParams): Promise<any>;
+    store(params: types.StoreParams): Promise<boolean>;
+    delete(params: types.DeleteParams): Promise<boolean>;
+    deleteTreeEntries(tree: string): Promise<boolean>;
+    hasKey(params: types.HasKeyParams): Promise<boolean>;
+    queryDB(params: types.QueryDBParams): Promise<types.QueryResult>;
 }
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     methods: WalletMethods;
     constructor(username: string, password: string);
 }

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

@@ -1,11 +1,11 @@
-import { WS as BaseWS } from '../lib/websocket';
+import { WSRPC } from '../rpc/websocket';
 import { ApplicationData } from '../wallet/types';
 import { DaemonMethods } from '../daemon/websocket';
 import { WalletMethods } from '../wallet/websocket';
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     daemon: DaemonMethods;
     wallet: WalletMethods;
     constructor();
-    authorize(app: ApplicationData): Promise<import("../lib/types").RPCResponse<unknown>>;
+    authorize(app: ApplicationData): Promise<unknown>;
 }
 export default WS;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.9.11",
+  "version": "0.10.1",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "exports": {
@@ -29,9 +29,10 @@
   },
   "devDependencies": {
     "@types/jest": "^29.4.0",
+    "@types/json-bigint": "^1.0.4",
     "@types/react": "^18.2.23",
     "@types/ws": "^8.5.4",
-    "fix-esm-import-path": "^1.5.0",
+    "fix-esm-import-path": "^1.10.1",
     "ts-jest": "^29.0.5",
     "typescript": "^4.9.5"
   },
@@ -39,8 +40,8 @@
     "await-to-js": "^3.0.0",
     "isomorphic-ws": "^5.0.0",
     "js-base64": "^3.7.6",
-    "lossless-json": "^4.0.1",
+    "json-bigint": "^1.0.0",
     "react": "^18.2.0",
     "ws": "^8.12.1"
   }
-}
+}

package/dist/cjs/lib/parse_data.js

@@ -1,15 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.parseData = void 0;
-var lossless_json_1 = require("lossless-json");
-// do not use JSON.parse() or we loose precision on big numbers
-// for ex: the API returns the nonce as a number instead of a string and JSON.parse() is rounding the number because of overflow
-// instead we will return any big number as a string and avoid precision loss
-var parseData = function (data) {
-    return (0, lossless_json_1.parse)(data, null, function (value) {
-        if ((0, lossless_json_1.isSafeNumber)(value))
-            return parseFloat(value);
-        return value;
-    });
-};
-exports.parseData = parseData;

package/dist/esm/lib/parse_data.js

@@ -1,11 +0,0 @@
-import { parse, isSafeNumber } from 'lossless-json';
-// do not use JSON.parse() or we loose precision on big numbers
-// for ex: the API returns the nonce as a number instead of a string and JSON.parse() is rounding the number because of overflow
-// instead we will return any big number as a string and avoid precision loss
-export var parseData = function (data) {
-    return parse(data, null, function (value) {
-        if (isSafeNumber(value))
-            return parseFloat(value);
-        return value;
-    });
-};

package/dist/types/lib/parse_data.d.ts

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

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

@@ -1,7 +0,0 @@
-import { RPCResponse } from './types';
-export declare class RPC {
-    endpoint: string;
-    timeout: number;
-    constructor(endpoint: string);
-    post<T>(method: string, params?: any, headers?: Headers): Promise<RPCResponse<T>>;
-}