@xelis/sdk 0.11.43 → 0.12.0

package/dist/esm/daemon/websocket.js

@@ -231,7 +231,7 @@ export class DaemonMethods {
         return this.dataCall(RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
     }
     getContractsOutputs(params) {
-        return this.dataCall(RPCMethod.GetContractsOutputs);
+        return this.dataCall(RPCMethod.GetContractsOutputs, params);
     }
     getContractModule(params) {
         return this.dataCall(RPCMethod.GetContractModule, params);
@@ -269,6 +269,21 @@ export class DaemonMethods {
     submitBlock(params) {
         return this.dataCall(RPCMethod.SubmitBlock, params);
     }
+    getContractTransactions(params) {
+        return this.dataCall(RPCMethod.GetContractTransactions, params);
+    }
+    simulateContractInvoke(params) {
+        return this.dataCall(RPCMethod.SimulateContractInvoke, params);
+    }
+    rewindChain(params) {
+        return this.dataCall(RPCMethod.RewindChain, params);
+    }
+    clearCaches() {
+        return this.dataCall(RPCMethod.ClearCaches);
+    }
+    pruneChain(params) {
+        return this.dataCall(RPCMethod.PruneChain, params);
+    }
 }
 export class WS extends WSRPC {
     constructor(endpoint) {

package/dist/esm/daemon/websocket.spec.js

@@ -0,0 +1,98 @@
+import { to } from 'await-to-js';
+import { MAINNET_NODE_WS } from '../config.js';
+import { RPCEvent, RPCMethod } from './types.js';
+import DaemonWS from './websocket.js';
+describe('DaemonWS', () => {
+    test('getInfo', async () => {
+        const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+        // we don't need to wait for socket open
+        //daemonWS.socket.addEventListener(`open`, async () => {
+        const [err1, res] = await to(daemonWS.methods.getInfo());
+        expect(err1).toBeNull();
+        console.log(res);
+        expect(res);
+        daemonWS.socket.close();
+        //})
+    });
+    const timeout = 40000;
+    test('listen_NewBlock', () => {
+        return new Promise(async (resolve, reject) => {
+            const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+            daemonWS.socket.addEventListener(`open`, async () => {
+                const doneTest = (err) => {
+                    daemonWS.socket.close();
+                    if (err)
+                        return reject(err);
+                    resolve(null);
+                };
+                daemonWS.methods.addListener(RPCEvent.NewBlock, null, async (data, err) => {
+                    console.log(data);
+                    doneTest(err);
+                });
+            });
+        });
+    }, timeout);
+    test('listen_ContractInvoke', () => {
+        return new Promise(async (resolve, reject) => {
+            const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+            daemonWS.socket.addEventListener(`open`, async () => {
+                const doneTest = (err) => {
+                    daemonWS.socket.close();
+                    if (err)
+                        return reject(err);
+                    resolve(null);
+                };
+                daemonWS.methods.addListener(RPCEvent.ContractInvoke, { contract: "32c5ccae542846696b0cd7f40949023219e123adca44d123d14d467ae8761f83" }, async (data, err) => {
+                    console.log(data);
+                    doneTest(err);
+                });
+            });
+        });
+    }, timeout);
+    test('multi_listen', () => {
+        return new Promise(async (resolve, reject) => {
+            const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+            daemonWS.socket.addEventListener(`open`, async () => {
+                let count = 3;
+                const doneTest = async (err) => {
+                    if (err)
+                        return reject(err);
+                    count--;
+                    if (count === 0) {
+                        daemonWS.socket.close();
+                        resolve(null);
+                    }
+                };
+                for (let i = 0; i < count; i++) {
+                    daemonWS.methods.addListener(RPCEvent.NewBlock, null, async (data, err) => {
+                        console.log(data);
+                        doneTest(err);
+                    });
+                }
+            });
+        });
+    }, timeout);
+    test('check_invalid_event', async () => {
+        const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+        daemonWS.socket.addEventListener(`open`, async () => {
+            daemonWS.addListener(`asdasd`, async (data, err) => {
+            }).catch((err) => {
+                expect(err).toBeDefined();
+                daemonWS.socket.close();
+            });
+        });
+    });
+    test(`batchRequest`, async () => {
+        const daemonWS = new DaemonWS(MAINNET_NODE_WS);
+        daemonWS.socket.addEventListener(`open`, async () => {
+            const requests = [
+                { method: RPCMethod.GetTopoheight },
+                { method: RPCMethod.GetInfo },
+                { method: "invalid" }
+            ];
+            const [err1, res] = await to(daemonWS.batchCall(requests));
+            console.log(err1, res);
+            expect(err1).toBeNull();
+        });
+    });
+});

package/dist/esm/data/element.spec.js

@@ -0,0 +1,65 @@
+import { Element } from './element.js';
+import { Value, ValueType } from './value.js';
+test(`TestElementValue`, () => {
+    let value = new Value(ValueType.String, "Hello world");
+    let element = Element.value(value);
+    let data = element.toBytes();
+    let newElement = Element.fromBytes(data);
+    let obj = element.toObject();
+    let jsonObj = JSON.stringify(obj);
+});
+test(`TestValueNew`, () => {
+    let str = Value.new("hello");
+    if (str.vType !== ValueType.String)
+        throw "";
+    let u8 = Value.new(10);
+    if (u8.vType !== ValueType.U8)
+        throw "";
+    let u16 = Value.new(34523);
+    if (u16.vType !== ValueType.U16)
+        throw "";
+    let u32 = Value.new(3452305469);
+    if (u32.vType !== ValueType.U32)
+        throw "";
+    let u64 = Value.new(BigInt("3452305469567567456"));
+    if (u64.vType !== ValueType.U64)
+        throw "";
+    let u128 = Value.new(BigInt("2093458230498572039452039485702938475"));
+    if (u128.vType !== ValueType.U128)
+        throw "";
+    let blob = Value.new([1, 2, 3, 4, 5]);
+    if (blob.vType !== ValueType.Blob)
+        throw "";
+    let hash = Value.new(new Uint8Array([185, 77, 39, 185, 147, 77, 62, 8, 165, 46, 82, 215, 218, 125, 171, 250, 196, 132, 239, 227, 122, 83, 128, 238, 144, 136, 247, 172, 226, 239, 205, 233]));
+    if (hash.vType !== ValueType.Hash)
+        throw "";
+    let bool = Value.new(true);
+    if (bool.vType !== ValueType.Bool)
+        throw "";
+});
+test(`TestElementArray`, async () => {
+    let encoder = new TextEncoder();
+    let data = encoder.encode("hello world");
+    let hashBuf = await crypto.subtle.digest("SHA-256", data);
+    let hash = new Uint8Array(hashBuf);
+    let element = Element.array([
+        Element.value(new Value(ValueType.String, "Hello world")),
+        Element.value(new Value(ValueType.U8, 34)),
+        Element.value(new Value(ValueType.U16, 34523)),
+        Element.value(new Value(ValueType.U32, 3452305469)),
+        Element.value(new Value(ValueType.U64, BigInt("3452305469567567456"))),
+        Element.value(new Value(ValueType.U128, BigInt("2093458230498572039452039485702938475"))),
+        Element.value(new Value(ValueType.Hash, hash)),
+        Element.value(new Value(ValueType.Blob, [0, 1, 2, 3, 4, 5]))
+    ]);
+    let bytes = element.toBytes();
+    let newElement = Element.fromBytes(bytes);
+    let obj = element.toObject();
+});
+test(`TestElementFields`, () => {
+    let fields = new Map();
+    fields.set(Value.new("hello"), Element.v("world"));
+    let element = Element.fields(fields);
+    let obj = element.toObject();
+    let jsonObj = JSON.stringify(obj);
+});

package/dist/esm/rpc/parse_json/parse_json.spec.js

@@ -0,0 +1,19 @@
+import fs from 'fs';
+import { parseJSON } from './parse_json.js';
+test(`parseJsonPerf`, () => {
+    // load data using fs instead of import or fix-esm will hang
+    const bigData = fs.readFileSync(`./src/rpc/parse_json/test_data.txt`, `utf-8`);
+    console.time();
+    let data = parseJSON(bigData);
+    console.timeEnd();
+    console.time();
+    data = JSON.parse(bigData);
+    console.timeEnd();
+});
+test(`bigNumber`, () => {
+    const test = `{ "nonce": 234905872304968723405968730498576039485, "nbr": 23452, "nonce_string": "234905872304968723405968730498576039485" }`;
+    let data = parseJSON(test);
+    console.log(data, data["nonce"], data["nbr"]);
+    data = JSON.parse(test);
+    console.log(data, data["nonce"], data["nbr"]);
+});

package/dist/esm/rpc/websocket.js

@@ -105,9 +105,14 @@ export class WSRPC {
                     if (data.id === id) {
                         return evaluate_data();
                     }
-                    // special XSWD case - sending first call will return null id
-                    if (data.id === null && id === 0) {
-                        return evaluate_data();
+                    // special XSWD case 
+                    // previously sending first call will return null id
+                    // now it returns the id as app id
+                    if (id === 0) {
+                        const body_data = JSON.parse(body);
+                        if (body_data.id === data.id || data.id === null) {
+                            return evaluate_data();
+                        }
                     }
                 }
             };

package/dist/esm/wallet/rpc.js

@@ -37,6 +37,15 @@ export class RPC extends HttpRPC {
     getTrackedAssets() {
         return this.request(RPCMethod.GetTrackedAssets);
     }
+    isAssetTracked(asset) {
+        return this.request(RPCMethod.IsAssetTracked, { asset });
+    }
+    trackAsset(params) {
+        return this.request(RPCMethod.TrackAsset, params);
+    }
+    untrackAsset(params) {
+        return this.request(RPCMethod.UntrackAsset, params);
+    }
     getAssetPrecision(params) {
         return this.request(RPCMethod.GetAssetPrecision, params);
     }
@@ -70,6 +79,9 @@ export class RPC extends HttpRPC {
     finalizeUnsignedTransaction(params) {
         return this.request(RPCMethod.FinalizeUnsignedTransaction, params);
     }
+    getPendingTransactions() {
+        return this.request(RPCMethod.GetPendingTransactions);
+    }
     clearTxCache() {
         return this.request(RPCMethod.ClearTxCache);
     }
@@ -88,6 +100,9 @@ export class RPC extends HttpRPC {
     signData(data) {
         return this.request(RPCMethod.SignData, data.toObject());
     }
+    verifySignedData(params) {
+        return this.request(RPCMethod.VerifySignedData, params);
+    }
     estimateFees(params) {
         return this.request(RPCMethod.EstimateFees, params);
     }
@@ -103,6 +118,15 @@ export class RPC extends HttpRPC {
     decryptCiphertext(params) {
         return this.request(RPCMethod.DecryptCiphertext, params);
     }
+    createOwnershipProof(params) {
+        return this.request(RPCMethod.CreateOwnershipProof, params);
+    }
+    createBalanceProof(params) {
+        return this.request(RPCMethod.CreateBalanceProof, params);
+    }
+    verifyHumanReadableProof(params) {
+        return this.request(RPCMethod.VerifyHumanReadableProof, params);
+    }
     getMatchingKeys(params) {
         return this.request(RPCMethod.GetMatchingKeys, params);
     }

package/dist/esm/wallet/rpc.spec.js

@@ -0,0 +1,265 @@
+import { to } from 'await-to-js';
+import { Element } from '../data/element.js';
+import { LOCAL_WALLET_RPC, XELIS_ASSET } from '../config.js';
+import WalletRPC from './rpc.js';
+const walletRPC = new WalletRPC(LOCAL_WALLET_RPC, `test`, `test`);
+describe('WalletRPC', () => {
+    test('getVersion', async () => {
+        const [err, res] = await to(walletRPC.getVersion());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getNetwork', async () => {
+        const [err, res] = await to(walletRPC.getNetwork());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getNonce', async () => {
+        const [err, res] = await to(walletRPC.getNonce());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getTopoheight', async () => {
+        const [err, res] = await to(walletRPC.getTopoheight());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getAddress', async () => {
+        const [err, res] = await to(walletRPC.getAddress());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('splitAddress', async () => {
+        const [err, res] = await to(walletRPC.splitAddress({
+            address: `xet:6eadzwf5xdacts6fs4y3csmnsmy4mcxewqt3xyygwfx0hm0tm32szqsrqyzkjar9d4esyqgpq4ehwmmjvsqqypgpq45x2mrvduqqzpthdaexceqpq4mk7unywvqsgqqpq4yx2mrvduqqzp2hdaexceqqqyzxvun0d5qqzp2cg4xyj5ct5udlg`
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getBalance', async () => {
+        const [err, res] = await to(walletRPC.getBalance());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('hasBalance', async () => {
+        const [err, res] = await to(walletRPC.hasBalance());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getTrackedAssets', async () => {
+        const [err, res] = await to(walletRPC.getTrackedAssets());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getAssetPrecision', async () => {
+        const [err, res] = await to(walletRPC.getAssetPrecision({
+            asset: XELIS_ASSET
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('getTransaction', async () => {
+        const [err, res] = await to(walletRPC.getTransaction(`381edf117446514852eace4e48e641d072d285e9c610662e21d2ae5a1cc0367a`));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('buildTransaction', async () => {
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: false,
+            tx_as_hex: true,
+            transfers: [{
+                    amount: 0,
+                    asset: XELIS_ASSET,
+                    destination: `xet:6eadzwf5xdacts6fs4y3csmnsmy4mcxewqt3xyygwfx0hm0tm32sqxdy9zk`
+                }],
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('buildTransactionFeeBuilder', async () => {
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: false,
+            tx_as_hex: true,
+            transfers: [{
+                    amount: 0,
+                    asset: XELIS_ASSET,
+                    destination: `xet:6eadzwf5xdacts6fs4y3csmnsmy4mcxewqt3xyygwfx0hm0tm32sqxdy9zk`
+                }],
+            fee: { extra: { multiplier: 2 } },
+            base_fee: { fixed: 1000 }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('transferTransaction', async () => {
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            transfers: [{
+                    amount: 100,
+                    asset: XELIS_ASSET,
+                    destination: `xet:6eadzwf5xdacts6fs4y3csmnsmy4mcxewqt3xyygwfx0hm0tm32sqxdy9zk`
+                }],
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('burnTransaction', async () => {
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            burn: {
+                amount: 500,
+                asset: XELIS_ASSET
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    const x_place_contract = `180003000027100003000000640008016700030000000a0008015f00080163000300000000000805456d7074790008074d6178203130300008094e6f2063616c6c6572000802636300040000000000000000030002000003ffffffff00080f4e6f2076616c696420706978656c730007000007010003000000010004000000000000000100080c636f6d6d69745f696e64657800080b706978656c5f636f756e740008056f776e6572000802747300061c0200000201000100000000002c090f1b0000000101000000002c2214010b0200000100000001001f14010b0200000100000001001f1401220200000201000002000100000003001812011c0004001c0101000003001812011c1401110200000005000100000003001813011c1401fd026d0200000100001800000006002b0007001830010100001800000001002e00080018300118e901020100010100182500000900183001010100182600020200185b01020300184f01020400010300000a00185c01000b00182700020500000c00020600000d0002070001000011121601000002080001080006000000002d092a0f8e00000001080006010000002d230f9d0000000e6c0000000e9d0000000108000602000e002b0fb50000000e6c0000000eb5000000010700010800180100010800060017010001020900010800060117020001020a00010900010a0017030002020b00010600010b00181d01020c00010c00000d00182700020d00010d00010800180100010600010b00010d00181e01070e6c000000130107001800000208000108000006002b000f0018300101060018240102090001090011120c020000020a00010a003d020b00020c00010300010c00185c01020d00010d00000d00182700020e00010b001112f9010000020f00001000021000000600021100011100010e001800002c0fdd010000010e00011100150600010f00060029090fb0010000010e00011100150601010f00060129220fd1010000010e0001110015010f002f0110000011002f0edd0100000ed1010000011100001200300e7c0100000110002a0ff4010000010e00010f001801000ef40100000e6801000013010300010c00010e00185e01070e3a010000130107000102000104001851011903020a0001030001050017040001010a00185e0107010300000a000105000013001c185e01070014000105000015000108000016000102000017000104001851011b04020b00001300010b0018e301000b001402`;
+    test('deploySmartContractTransaction', async () => {
+        // hello world smart contract
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            deploy_contract: {
+                contract_version: "v1",
+                module: x_place_contract // "0200081868656c6c6f20776f726c642066726f6d20696e766f6b65210004000000000000000000010a000000182b010001001402"
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('deploySmartContractWithConstructor', async () => {
+        // hello world smart contract
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            deploy_contract: {
+                contract_version: "v1",
+                module: "0300081d68656c6c6f20776f726c642066726f6d20636f6e7374727563746f72210004000000000000000000081868656c6c6f20776f726c642066726f6d20696e766f6b652100020a000000182b010001001403000a000200182b010001001402",
+                invoke: {
+                    max_gas: 5000000,
+                    deposits: {
+                        "0000000000000000000000000000000000000000000000000000000000000000": {
+                            amount: 100000000,
+                            private: false
+                        }
+                    }
+                }
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('deplySmartContractAsset', async () => {
+        // hello world smart contract
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            deploy_contract: {
+                contract_version: "v1",
+                module: "0602020001010004000009184e72a0000004000000000000000000080948617368506f77657200080248500001080004000009184e72a00000013c000000020000000100000200000300000400010000186c010201000101000005001876010718d20118260000050001010018720118c90107000100140300",
+                invoke: {
+                    max_gas: 100000000,
+                    deposits: {
+                        "0000000000000000000000000000000000000000000000000000000000000000": {
+                            amount: 100000000,
+                            private: false
+                        }
+                    }
+                }
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('invokeSmartContractMint', async () => {
+        // hello world smart contract
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            invoke_contract: {
+                contract: "4ee56bf69a18c03b5e5ee68f92a8bf73c0ba97801832dcf573231efaadc8548e",
+                entry_id: 1,
+                deposits: {},
+                max_gas: 1000000,
+                parameters: [{
+                        type: "primitive",
+                        value: { type: "u64", value: "1000" }
+                    }],
+                permission: "none"
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('invokeSmartContractTransaction', async () => {
+        // hello world smart contract
+        const [err, res] = await to(walletRPC.buildTransaction({
+            broadcast: true,
+            tx_as_hex: true,
+            invoke_contract: {
+                contract: "16d69521a8b66e3098251d87e9e7e2ed430bac44d0bc56bc881d9bbfe2569297",
+                entry_id: 0,
+                deposits: {},
+                max_gas: 1000,
+                parameters: [],
+                permission: "none"
+            }
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('listTransactions', async () => {
+        const [err, res] = await to(walletRPC.listTransactions());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('isOnline', async () => {
+        const [err, res] = await to(walletRPC.isOnline());
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('estimateFees', async () => {
+        const [err, res] = await to(walletRPC.estimateFees({
+            transfers: [{
+                    amount: 0,
+                    asset: XELIS_ASSET,
+                    destination: `xet:6eadzwf5xdacts6fs4y3csmnsmy4mcxewqt3xyygwfx0hm0tm32sqxdy9zk`
+                }]
+        }));
+        expect(err).toBeNull();
+        console.log(res);
+        expect(res);
+    });
+    test('signData', async () => {
+        let data = Element.v("hello world");
+        const [err, publicKey] = await to(walletRPC.getAddress());
+        expect(err).toBeNull();
+        const [err2, sig] = await to(walletRPC.signData(data));
+        expect(err2).toBeNull();
+    });
+});

package/dist/esm/wallet/types.js

@@ -33,6 +33,9 @@ export var RPCMethod;
     RPCMethod["GetBalance"] = "get_balance";
     RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetTrackedAssets"] = "get_tracked_assets";
+    RPCMethod["IsAssetTracked"] = "is_asset_tracked";
+    RPCMethod["TrackAsset"] = "track_asset";
+    RPCMethod["UntrackAsset"] = "untrack_asset";
     RPCMethod["GetAssetPrecision"] = "get_asset_precision";
     RPCMethod["GetAssets"] = "get_assets";
     RPCMethod["GetAsset"] = "get_asset";
@@ -44,17 +47,22 @@ export var RPCMethod;
     RPCMethod["BuildUnsignedTransaction"] = "build_unsigned_transaction";
     RPCMethod["FinalizeUnsignedTransaction"] = "finalize_unsigned_transaction";
     RPCMethod["SignUnsignedTransaction"] = "sign_unsigned_transaction";
+    RPCMethod["GetPendingTransactions"] = "get_pending_transactions";
     RPCMethod["ClearTxCache"] = "clear_tx_cache";
     RPCMethod["ListTransactions"] = "list_transactions";
     RPCMethod["IsOnline"] = "is_online";
     RPCMethod["SetOnlineMode"] = "set_online_mode";
     RPCMethod["SetOfflineMode"] = "set_offline_mode";
     RPCMethod["SignData"] = "sign_data";
+    RPCMethod["VerifySignedData"] = "verify_signed_data";
     RPCMethod["EstimateFees"] = "estimate_fees";
     RPCMethod["EstimateExtraDataSize"] = "estimate_extra_data_size";
     RPCMethod["NetworkInfo"] = "network_info";
     RPCMethod["DecryptExtraData"] = "decrypt_extra_data";
     RPCMethod["DecryptCiphertext"] = "decrypt_ciphertext";
+    RPCMethod["CreateOwnershipProof"] = "create_ownership_proof";
+    RPCMethod["CreateBalanceProof"] = "create_balance_proof";
+    RPCMethod["VerifyHumanReadableProof"] = "verify_human_readable_proof";
     RPCMethod["GetMatchingKeys"] = "get_matching_keys";
     RPCMethod["CountMatchingEntries"] = "count_matching_entries";
     RPCMethod["GetValueFromKey"] = "get_value_from_key";
@@ -66,9 +74,10 @@ export var RPCMethod;
 })(RPCMethod || (RPCMethod = {}));
 export var RPCEvent;
 (function (RPCEvent) {
-    RPCEvent["NewTopoheight"] = "new_topoheight";
+    RPCEvent["NewTopoheight"] = "new_topo_height";
     RPCEvent["NewAsset"] = "new_asset";
     RPCEvent["NewTransaction"] = "new_transaction";
+    RPCEvent["NewPendingTransaction"] = "new_pending_transaction";
     RPCEvent["BalanceChanged"] = "balance_changed";
     RPCEvent["Rescan"] = "rescan";
     RPCEvent["HistorySynced"] = "history_synced";

package/dist/esm/wallet/websocket.js

@@ -50,6 +50,15 @@ export class WalletMethods {
     getTrackedAssets() {
         return this.dataCall(RPCMethod.GetTrackedAssets);
     }
+    isAssetTracked(asset) {
+        return this.dataCall(RPCMethod.IsAssetTracked, { asset });
+    }
+    trackAsset(params) {
+        return this.dataCall(RPCMethod.TrackAsset, params);
+    }
+    untrackAsset(params) {
+        return this.dataCall(RPCMethod.UntrackAsset, params);
+    }
     getAssetPrecision(params) {
         return this.dataCall(RPCMethod.GetAssetPrecision, params);
     }
@@ -83,17 +92,20 @@ export class WalletMethods {
     finalizeUnsignedTransaction(params) {
         return this.dataCall(RPCMethod.FinalizeUnsignedTransaction, params);
     }
+    getPendingTransactions() {
+        return this.dataCall(RPCMethod.GetPendingTransactions);
+    }
     clearTxCache() {
         return this.dataCall(RPCMethod.ClearTxCache);
     }
     listTransactions(params) {
-        return this.dataCall(RPCMethod.GetTransaction, params);
+        return this.dataCall(RPCMethod.ListTransactions, params);
     }
     isOnline() {
         return this.dataCall(RPCMethod.IsOnline);
     }
     setOnlineMode(params) {
-        return this.dataCall(RPCMethod.SetOfflineMode, params);
+        return this.dataCall(RPCMethod.SetOnlineMode, params);
     }
     setOfflineMode() {
         return this.dataCall(RPCMethod.SetOfflineMode);
@@ -101,6 +113,9 @@ export class WalletMethods {
     signData(data) {
         return this.dataCall(RPCMethod.SignData, data.toObject());
     }
+    verifySignedData(params) {
+        return this.dataCall(RPCMethod.VerifySignedData, params);
+    }
     estimateFees(params) {
         return this.dataCall(RPCMethod.EstimateFees, params);
     }
@@ -116,6 +131,15 @@ export class WalletMethods {
     decryptCiphertext(params) {
         return this.dataCall(RPCMethod.DecryptCiphertext, params);
     }
+    createOwnershipProof(params) {
+        return this.dataCall(RPCMethod.CreateOwnershipProof, params);
+    }
+    createBalanceProof(params) {
+        return this.dataCall(RPCMethod.CreateBalanceProof, params);
+    }
+    verifyHumanReadableProof(params) {
+        return this.dataCall(RPCMethod.VerifyHumanReadableProof, params);
+    }
     getMatchingKeys(params) {
         return this.dataCall(RPCMethod.GetMatchingKeys, params);
     }

package/dist/esm/wallet/websocket.spec.js

@@ -0,0 +1,15 @@
+import { to } from 'await-to-js';
+import { LOCAL_WALLET_WS } from '../config.js';
+import WalletWS from './websocket.js';
+describe('WalletWS', () => {
+    test('getAddress', async () => {
+        const walletWS = new WalletWS(LOCAL_WALLET_WS, `test`, `test`);
+        walletWS.socket.addEventListener(`open`, async () => {
+            const [err2, res] = await to(walletWS.methods.getAddress());
+            expect(err2).toBeNull();
+            console.log(res);
+            expect(res);
+            walletWS.socket.close();
+        });
+    });
+});