@xelis/sdk 0.9.11 → 0.10.1

package/dist/esm/wallet/websocket.js

@@ -13,7 +13,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { WS as BaseWS } from '../lib/websocket.js';
+import { WSRPC } from '../rpc/websocket.js';
 import { RPCMethod, RPCEvent } from './types.js';
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
@@ -25,25 +25,28 @@ var WalletMethods = /** @class */ (function () {
         return this.ws.dataCall(this.prefix + method, params);
     };
     WalletMethods.prototype.onNewTopoheight = function (onData) {
-        return this.ws.listenEvent(RPCEvent.NewTopoheight, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.NewTopoheight, onData);
     };
     WalletMethods.prototype.onNewAsset = function (onData) {
-        return this.ws.listenEvent(RPCEvent.NewAsset, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.NewAsset, onData);
     };
     WalletMethods.prototype.onNewTransaction = function (onData) {
-        return this.ws.listenEvent(RPCEvent.NewTransaction, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.NewTransaction, onData);
     };
     WalletMethods.prototype.onBalanceChanged = function (onData) {
-        return this.ws.listenEvent(RPCEvent.BalanceChanged, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.BalanceChanged, onData);
     };
     WalletMethods.prototype.onRescan = function (onData) {
-        return this.ws.listenEvent(RPCEvent.Rescan, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.Rescan, onData);
+    };
+    WalletMethods.prototype.onHistorySynced = function (onData) {
+        return this.ws.listenEvent(this.prefix + RPCEvent.HistorySynced, onData);
     };
     WalletMethods.prototype.onOnline = function (onData) {
-        return this.ws.listenEvent(RPCEvent.Online, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.Online, onData);
     };
     WalletMethods.prototype.onOffline = function (onData) {
-        return this.ws.listenEvent(RPCEvent.Offline, onData);
+        return this.ws.listenEvent(this.prefix + RPCEvent.Offline, onData);
     };
     WalletMethods.prototype.getVersion = function () {
         return this.dataCall(RPCMethod.GetVersion);
@@ -70,35 +73,95 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.getBalance = function (asset) {
         return this.dataCall(RPCMethod.GetBalance, { asset: asset });
     };
+    WalletMethods.prototype.hasBalance = function (asset) {
+        return this.dataCall(RPCMethod.HasBalance, { asset: asset });
+    };
     WalletMethods.prototype.getTrackedAssets = function () {
         return this.dataCall(RPCMethod.GetTrackedAssets);
     };
     WalletMethods.prototype.getAssetPrecision = function (params) {
         return this.dataCall(RPCMethod.GetAssetPrecision, params);
     };
+    WalletMethods.prototype.getAssets = function () {
+        return this.dataCall(RPCMethod.GetAssets);
+    };
+    WalletMethods.prototype.getAsset = function (params) {
+        return this.dataCall(RPCMethod.GetAsset, params);
+    };
     WalletMethods.prototype.getTransaction = function (hash) {
         return this.dataCall(RPCMethod.GetTransaction, { hash: hash });
     };
     WalletMethods.prototype.buildTransaction = function (params) {
         return this.dataCall(RPCMethod.BuildTransaction, params);
     };
+    WalletMethods.prototype.buildTransactionOffline = function (params) {
+        return this.dataCall(RPCMethod.BuildTransactionOffline, params);
+    };
+    WalletMethods.prototype.buildUnsignedTransaction = function (params) {
+        return this.dataCall(RPCMethod.BuildUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.signUnsignedTransaction = function (params) {
+        return this.dataCall(RPCMethod.SignUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.finalizeUnsignedTransaction = function (params) {
+        return this.dataCall(RPCMethod.FinalizeUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.clearTxCache = function () {
+        return this.dataCall(RPCMethod.ClearTxCache);
+    };
     WalletMethods.prototype.listTransactions = function (params) {
         return this.dataCall(RPCMethod.GetTransaction, params);
     };
     WalletMethods.prototype.isOnline = function () {
         return this.dataCall(RPCMethod.IsOnline);
     };
+    WalletMethods.prototype.setOnlineMode = function (params) {
+        return this.dataCall(RPCMethod.SetOfflineMode, params);
+    };
+    WalletMethods.prototype.setOfflineMode = function () {
+        return this.dataCall(RPCMethod.SetOfflineMode);
+    };
     WalletMethods.prototype.signData = function (data) {
-        return this.dataCall(RPCMethod.SignData, data);
+        return this.dataCall(RPCMethod.SignData, data.toObject());
     };
     WalletMethods.prototype.estimateFees = function (params) {
         return this.dataCall(RPCMethod.EstimateFees, params);
     };
-    WalletMethods.prototype.setOnlineMode = function (params) {
-        return this.dataCall(RPCMethod.SetOfflineMode, params);
+    WalletMethods.prototype.estimateExtraDataSize = function (params) {
+        return this.dataCall(RPCMethod.EstimateExtraDataSize, params);
     };
-    WalletMethods.prototype.setOfflineMode = function () {
-        return this.dataCall(RPCMethod.SetOfflineMode);
+    WalletMethods.prototype.networkInfo = function () {
+        return this.dataCall(RPCMethod.NetworkInfo);
+    };
+    WalletMethods.prototype.decryptExtraData = function (params) {
+        return this.dataCall(RPCMethod.DecryptExtraData, params);
+    };
+    WalletMethods.prototype.decryptCiphertext = function (params) {
+        return this.dataCall(RPCMethod.DecryptCiphertext, params);
+    };
+    WalletMethods.prototype.getMatchingKeys = function (params) {
+        return this.dataCall(RPCMethod.GetMatchingKeys, params);
+    };
+    WalletMethods.prototype.countMatchingEntries = function (params) {
+        return this.dataCall(RPCMethod.CountMatchingEntries, params);
+    };
+    WalletMethods.prototype.getValueFromKey = function (params) {
+        return this.dataCall(RPCMethod.GetValueFromKey, params);
+    };
+    WalletMethods.prototype.store = function (params) {
+        return this.dataCall(RPCMethod.Store, params);
+    };
+    WalletMethods.prototype["delete"] = function (params) {
+        return this.dataCall(RPCMethod.Delete, params);
+    };
+    WalletMethods.prototype.deleteTreeEntries = function (tree) {
+        return this.dataCall(RPCMethod.DeleteTreeEntries, { tree: tree });
+    };
+    WalletMethods.prototype.hasKey = function (params) {
+        return this.dataCall(RPCMethod.HasKey, params);
+    };
+    WalletMethods.prototype.queryDB = function (params) {
+        return this.dataCall(RPCMethod.QueryDB, params);
     };
     return WalletMethods;
 }());
@@ -111,6 +174,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(BaseWS));
+}(WSRPC));
 export { WS };
 export default WS;

package/dist/esm/xswd/websocket.js

@@ -13,7 +13,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { WS as BaseWS } from '../lib/websocket.js';
+import { WSRPC } from '../rpc/websocket.js';
 import { DaemonMethods } from '../daemon/websocket.js';
 import { WalletMethods } from '../wallet/websocket.js';
 var WS = /** @class */ (function (_super) {
@@ -27,9 +27,9 @@ var WS = /** @class */ (function (_super) {
     }
     WS.prototype.authorize = function (app) {
         var data = JSON.stringify(app);
-        return this.call("", {}, data);
+        return this.rawCall(0, data);
     };
     return WS;
-}(BaseWS));
+}(WSRPC));
 export { WS };
 export default WS;

package/dist/types/address/address.d.ts

@@ -0,0 +1,12 @@
+import { Element } from "../data/element";
+declare class Address {
+    publicKey: number[];
+    isMainnet: boolean;
+    isIntegrated: boolean;
+    extraData?: Element;
+    constructor(data: number[], hrp: string);
+    static fromString(addr: string): Address;
+    static isValid(addr: string): boolean;
+    format(): string;
+}
+export default Address;

package/dist/types/address/bech32.d.ts

@@ -0,0 +1,6 @@
+export declare function convertBits(data: number[], from: number, to: number, pad: boolean): number[];
+export declare function decode(bech: string): {
+    hrp: string;
+    decoded: number[];
+};
+export declare function encode(hrp: string, data: number[]): string;

package/dist/types/config.d.ts

@@ -16,6 +16,7 @@ export declare const LOCAL_WALLET_WS: string;
 export declare const LOCAL_XSWD_URL: string;
 export declare const LOCAL_XSWD_WS: string;
 export declare const XELIS_ASSET = "0000000000000000000000000000000000000000000000000000000000000000";
+export declare const XELIS_DECIMALS = 8;
 declare const _default: {
     MAINNET_NODE_URL: string;
     TESTNET_NODE_URL: string;
@@ -34,5 +35,6 @@ declare const _default: {
     LOCAL_XSWD_URL: string;
     LOCAL_XSWD_WS: string;
     XELIS_ASSET: string;
+    XELIS_DECIMALS: number;
 };
 export default _default;

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

@@ -1,53 +1,70 @@
-import { Block, TopoheightRangeParams, GetInfoResult, HeightRangeParams, GetBalanceResult, P2PStatusResult, GetBalanceParams, GetBalanceAtTopoheightParams, GetAccountsParams, GetBlockAtTopoheightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceResult, GetNonceParams, GetAccountHistoryParams, AccounHistory, DevFee, DiskSize, HasBalanceParams, HasBalanceResult, AssetData, IsTxExecutedInBlockParams, GetAssetParams, GetPeersResult, GetBlockTemplateResult, VersionedBalance, VersionedNonce, GetNonceAtTopoheightParams, HasNonceParams, HasNonceResult, TransactionResponse, IsAccountRegisteredParams, GetMempoolCacheResult, GetDifficultyResult, ValidateAddressParams, ExtractKeyFromAddressParams, SubmitBlockParams, GetMinerWorkParams, GetMinerWorkResult, ValidateAddressResult, GetStableBalanceResult, GetAssetsParams, SplitAddressParams, SplitAddressResult } from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-export declare class RPC extends BaseRPC {
-    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
-    getHeight(): Promise<import("../lib/types").RPCResponse<number>>;
-    getTopoheight(): Promise<import("../lib/types").RPCResponse<number>>;
-    getStableHeight(): Promise<import("../lib/types").RPCResponse<number>>;
-    getStableTopoheight(): Promise<import("../lib/types").RPCResponse<number>>;
-    getStableBalance(params: GetBalanceParams): Promise<import("../lib/types").RPCResponse<GetStableBalanceResult>>;
-    getBlockTemplate(address: string): Promise<import("../lib/types").RPCResponse<GetBlockTemplateResult>>;
-    getBlockAtTopoheight(params: GetBlockAtTopoheightParams): Promise<import("../lib/types").RPCResponse<Block>>;
-    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
-    getBlockByHash(params: GetBlockByHashParams): Promise<import("../lib/types").RPCResponse<Block>>;
-    getTopBlock(params?: GetTopBlockParams): Promise<import("../lib/types").RPCResponse<Block>>;
-    submitBlock(params: SubmitBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
-    getBalance(params: GetBalanceParams): Promise<import("../lib/types").RPCResponse<GetBalanceResult>>;
-    hasBalance(params: HasBalanceParams): Promise<import("../lib/types").RPCResponse<HasBalanceResult>>;
-    getBalanceAtTopoheight(params: GetBalanceAtTopoheightParams): Promise<import("../lib/types").RPCResponse<VersionedBalance>>;
-    getInfo(): Promise<import("../lib/types").RPCResponse<GetInfoResult>>;
-    getNonce(params: GetNonceParams): Promise<import("../lib/types").RPCResponse<GetNonceResult>>;
-    hasNonce(params: HasNonceParams): Promise<import("../lib/types").RPCResponse<HasNonceResult>>;
-    getNonceAtTopoheight(params: GetNonceAtTopoheightParams): Promise<import("../lib/types").RPCResponse<VersionedNonce>>;
-    getAsset(params: GetAssetParams): Promise<import("../lib/types").RPCResponse<AssetData>>;
-    getAssets(params: GetAssetsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
-    countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
-    countAccounts(): Promise<import("../lib/types").RPCResponse<number>>;
-    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
-    submitTransaction(hexData: string): Promise<import("../lib/types").RPCResponse<boolean>>;
-    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<TransactionResponse>>;
-    p2pStatus(): Promise<import("../lib/types").RPCResponse<P2PStatusResult>>;
-    getPeers(): Promise<import("../lib/types").RPCResponse<GetPeersResult>>;
-    getMemPool(): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
-    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
-    getDAGOrder(params?: TopoheightRangeParams): Promise<import("../lib/types").RPCResponse<string[]>>;
-    getBlocksRangeByTopoheight(params: TopoheightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
-    getTransactions(txHashes: string[]): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
-    getAccountHistory(params: GetAccountHistoryParams): Promise<import("../lib/types").RPCResponse<AccounHistory[]>>;
-    getAccountAssets(address: string): Promise<import("../lib/types").RPCResponse<string[]>>;
-    getAccounts(params: GetAccountsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
-    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
-    getDevFeeThresholds(): Promise<import("../lib/types").RPCResponse<DevFee[]>>;
-    getSizeOnDisk(): Promise<import("../lib/types").RPCResponse<DiskSize>>;
-    getAccountRegistrationTopoheight(address: String): Promise<import("../lib/types").RPCResponse<Number>>;
-    isAccountRegistered(params: IsAccountRegisteredParams): Promise<import("../lib/types").RPCResponse<boolean>>;
-    getMempoolCache(address: String): Promise<import("../lib/types").RPCResponse<GetMempoolCacheResult>>;
-    getDifficulty(): Promise<import("../lib/types").RPCResponse<GetDifficultyResult>>;
-    validateAddress(params: ValidateAddressParams): Promise<import("../lib/types").RPCResponse<ValidateAddressResult>>;
-    extractKeyFromAddress(params: ExtractKeyFromAddressParams): Promise<import("../lib/types").RPCResponse<string | number[]>>;
-    getMinerWork(params: GetMinerWorkParams): Promise<import("../lib/types").RPCResponse<GetMinerWorkResult>>;
-    splitAddress(params: SplitAddressParams): Promise<import("../lib/types").RPCResponse<SplitAddressResult>>;
+import * as types from './types';
+import { HttpRPC } from '../rpc/http';
+export declare class RPC extends HttpRPC {
+    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>;
+    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>;
+    countTransactions(): Promise<number>;
+    countAccounts(): Promise<number>;
+    countContracts(): Promise<number>;
+    submitTransaction(hexData: string): Promise<boolean>;
+    getTransationExecutor(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: types.GetAccountsParams): Promise<string[]>;
+    isAccountRegistered(params: types.IsAccountRegisteredParams): Promise<boolean>;
+    getAccountRegistrationTopoheight(address: String): Promise<Number>;
+    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<types.GetBlockTemplateResult>;
+    getMinerWork(params: types.GetMinerWorkParams): Promise<types.GetMinerWorkResult>;
+    submitBlock(params: types.SubmitBlockParams): Promise<boolean>;
 }
 export default RPC;