phantasma-sdk-ts 0.2.0-rc.8 → 0.2.0

package/dist/cjs/core/rpc/interfaces/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ABIContract"), exports);
+__exportStar(require("./ABIEvent"), exports);
+__exportStar(require("./ABIMethod"), exports);
+__exportStar(require("./ABIParameter"), exports);
+__exportStar(require("./Account"), exports);
+__exportStar(require("./AccountTransactions"), exports);
+__exportStar(require("./Archive"), exports);
+__exportStar(require("./Auction"), exports);
+__exportStar(require("./Balance"), exports);
+__exportStar(require("./Block"), exports);
+__exportStar(require("./Chain"), exports);
+__exportStar(require("./Channel"), exports);
+__exportStar(require("./Contract"), exports);
+__exportStar(require("./Dapp"), exports);
+__exportStar(require("./Event"), exports);
+__exportStar(require("./EventExtended"), exports);
+__exportStar(require("./Governance"), exports);
+__exportStar(require("./Interop"), exports);
+__exportStar(require("./KeyValue"), exports);
+__exportStar(require("./Leaderboard"), exports);
+__exportStar(require("./LeaderboardRow"), exports);
+__exportStar(require("./Nexus"), exports);
+__exportStar(require("./NFT"), exports);
+__exportStar(require("./Oracle"), exports);
+__exportStar(require("./Organization"), exports);
+__exportStar(require("./Paginated"), exports);
+__exportStar(require("./Peer"), exports);
+__exportStar(require("./Platform"), exports);
+__exportStar(require("./Receipt"), exports);
+__exportStar(require("./Script"), exports);
+__exportStar(require("./SendRawTx"), exports);
+__exportStar(require("./SignatureResult"), exports);
+__exportStar(require("./Stake"), exports);
+__exportStar(require("./Storage"), exports);
+__exportStar(require("./Swap"), exports);
+__exportStar(require("./Token"), exports);
+__exportStar(require("./TokenData"), exports);
+__exportStar(require("./TokenExternal"), exports);
+__exportStar(require("./TokenPrice"), exports);
+__exportStar(require("./TokenSeries"), exports);
+__exportStar(require("./TransactionData"), exports);
+__exportStar(require("./Validator"), exports);
+__exportStar(require("./CursorPaginatedResult"), exports);
+__exportStar(require("./TokenSeriesResult"), exports);
+__exportStar(require("./TokenSchemasResult"), exports);
+__exportStar(require("./VmNamedVariableSchemaResult"), exports);
+__exportStar(require("./VmStructSchemaResult"), exports);
+__exportStar(require("./VmVariableSchemaResult"), exports);

package/dist/cjs/core/rpc/phantasma.js

@@ -0,0 +1,435 @@
+"use strict";
+/* eslint-disable */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhantasmaAPI = void 0;
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+class PhantasmaAPI {
+    pingAsync(host) {
+        return new Promise((resolve, reject) => {
+            var started = new Date().getTime();
+            var http = new XMLHttpRequest();
+            http.open('GET', host + '/rpc', true);
+            http.timeout = 4500;
+            http.onreadystatechange = function () {
+                if (http.readyState == 4 && http.status == 200) {
+                    var ended = new Date().getTime();
+                    var milliseconds = ended - started;
+                    resolve(milliseconds);
+                }
+                http.ontimeout = function () {
+                    resolve(100000);
+                };
+                http.onerror = function () {
+                    resolve(100000);
+                };
+            };
+            try {
+                http.send(null);
+            }
+            catch (exception) {
+                // this is expected
+                reject();
+            }
+        });
+    }
+    constructor(defHost, peersUrlJson, nexus) {
+        this.rpcName = 'Auto';
+        this.nexus = nexus;
+        this.host = defHost;
+        this.availableHosts = [];
+        if (peersUrlJson != undefined && peersUrlJson != null) {
+            (0, cross_fetch_1.default)(peersUrlJson + '?_=' + new Date().getTime()).then(async (res) => {
+                const data = await res.json();
+                for (var i = 0; i < data.length; i++) {
+                    console.log('Checking RPC: ', data[i]);
+                    try {
+                        const msecs = await this.pingAsync(data[i].url);
+                        data[i].info = data[i].location + ' • ' + msecs + ' ms';
+                        data[i].msecs = msecs;
+                        console.log(data[i].location + ' • ' + msecs + ' ms • ' + data[i].url + '/rpc');
+                        this.availableHosts.push(data[i]);
+                    }
+                    catch (err) {
+                        console.log('Error with RPC: ' + data[i]);
+                    }
+                }
+                this.availableHosts.sort((a, b) => a.msecs - b.msecs);
+                this.updateRpc();
+            });
+        }
+    }
+    async JSONRPC(method, params) {
+        let res = await (0, cross_fetch_1.default)(this.host, {
+            method: 'POST',
+            mode: 'cors',
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: method,
+                params: params,
+                id: '1',
+            }),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        let resJson = await res.json();
+        console.log('method', method, resJson);
+        if (resJson.error) {
+            if (resJson.error.message)
+                return { error: resJson.error.message };
+            return { error: resJson.error };
+        }
+        return await resJson.result;
+    }
+    setRpcHost(rpcHost) {
+        this.host = rpcHost;
+    }
+    setRpcByName(rpcName) {
+        this.rpcName = rpcName;
+        if (this.nexus === 'mainnet')
+            this.updateRpc();
+    }
+    setNexus(nexus) {
+        this.nexus = nexus.toLowerCase();
+    }
+    updateRpc() {
+        if (this.nexus === 'mainnet' && this.availableHosts.length > 0) {
+            console.log('%cUpdate RPC with name ' + this.rpcName, 'font-size: 20px');
+            if (this.rpcName == 'Auto') {
+                this.host = this.availableHosts[0].url + '/rpc';
+            }
+            else {
+                const rpc = this.availableHosts.find((h) => h.location == this.rpcName);
+                if (rpc)
+                    this.host = rpc.url + '/rpc';
+                else
+                    this.host = this.availableHosts[0].url + '/rpc';
+            }
+            console.log('%cSet RPC api to ' + this.host, 'font-size: 20px');
+        }
+    }
+    convertDecimals(amount, decimals) {
+        let mult = Math.pow(10, decimals);
+        return amount / mult;
+    }
+    //Returns the account name and balance of given address.
+    async getAccount(account, extended = true) {
+        let params = [account, extended];
+        return (await this.JSONRPC('getAccount', params));
+    }
+    //Returns the accounts name and balance of given addresses.
+    async getAccounts(accounts, extended = true) {
+        let params = [accounts.join(','), extended];
+        return (await this.JSONRPC('getAccounts', params));
+    }
+    //Returns the address that owns a given name.
+    async lookUpName(name) {
+        let params = [name];
+        return (await this.JSONRPC('lookUpName', params));
+    }
+    //Returns the address that owns a given name.
+    async getAddressesBySymbol(symbol, extended = false) {
+        let params = [symbol, extended];
+        return (await this.JSONRPC('getAddressesBySymbol', params));
+    }
+    //Returns the height of a chain.
+    async getBlockHeight(chainInput) {
+        let params = [chainInput];
+        return (await this.JSONRPC('getBlockHeight', params));
+    }
+    //Returns the number of transactions of given block hash or error if given hash is invalid or is not found.
+    async getBlockTransactionCountByHash(blockHash) {
+        let params = [blockHash];
+        return (await this.JSONRPC('getBlockTransactionCountByHash', params));
+    }
+    //Returns information about a block by hash.
+    async getBlockByHash(blockHash) {
+        let params = [blockHash];
+        return (await this.JSONRPC('getBlockByHash', params));
+    }
+    //Returns a serialized string, containing information about a block by hash.
+    async getRawBlockByHash(blockHash) {
+        let params = [blockHash];
+        return (await this.JSONRPC('getRawBlockByHash', params));
+    }
+    //Returns information about a block by height and chain.
+    async getBlockByHeight(chainInput, height) {
+        let params = [chainInput, height];
+        return (await this.JSONRPC('getBlockByHeight', params));
+    }
+    //Returns information about a block by height and chain.
+    async getLatestBlock(chainInput) {
+        let params = [chainInput];
+        return (await this.JSONRPC('getLatestBlock', params));
+    }
+    //Returns a serialized string, in hex format, containing information about a block by height and chain.
+    async getRawBlockByHeight(chainInput, height) {
+        let params = [chainInput, height];
+        return (await this.JSONRPC('getRawBlockByHeight', params));
+    }
+    //Returns a serialized string, in hex format, containing information about a block by height and chain.
+    async getRawLatestBlock(chainInput) {
+        let params = [chainInput];
+        return (await this.JSONRPC('getRawLatestBlock', params));
+    }
+    //Returns the information about a transaction requested by a block hash and transaction index.
+    async getTransactionByBlockHashAndIndex(blockHash, index) {
+        let params = [blockHash, index];
+        return (await this.JSONRPC('getTransactionByBlockHashAndIndex', params));
+    }
+    //Returns last X transactions of given address.
+    async getAddressTransactions(account, page, pageSize) {
+        let params = [account, page, pageSize];
+        return (await this.JSONRPC('getAddressTransactions', params));
+    }
+    //Get number of transactions in a specific address and chain
+    async getAddressTransactionCount(account, chainInput) {
+        let params = [account, chainInput];
+        return (await this.JSONRPC('getAddressTransactionCount', params));
+    }
+    //Allows to broadcast a signed operation on the network, but it&apos;s required to build it manually.
+    async sendRawTransaction(txData) {
+        let params = [txData];
+        return (await this.JSONRPC('sendRawTransaction', params));
+    }
+    //Allows to broadcast a signed carbon transaction on the network.
+    async sendCarbonTransaction(txData) {
+        let params = [txData];
+        return (await this.JSONRPC('sendCarbonTransaction', params));
+    }
+    //Allows to invoke script based on network state, without state changes.
+    async invokeRawScript(chainInput, scriptData) {
+        let params = [chainInput, scriptData];
+        return (await this.JSONRPC('invokeRawScript', params));
+    }
+    //Returns information about a transaction by hash.
+    async getTransaction(hashText) {
+        let params = [hashText];
+        return (await this.JSONRPC('getTransaction', params));
+    }
+    //Removes a pending transaction from the mempool.
+    async cancelTransaction(hashText) {
+        let params = [hashText];
+        return (await this.JSONRPC('cancelTransaction', params));
+    }
+    //Returns an array of all chains deployed in Phantasma.
+    async getChains(extended = true) {
+        let params = [extended];
+        return (await this.JSONRPC('getChains', params));
+    }
+    //Return the chain
+    async getChain(name, extended = true) {
+        let params = [name, extended];
+        return (await this.JSONRPC('getChain', params));
+    }
+    //Returns info about the nexus.
+    async getNexus(extended = true) {
+        let params = [extended];
+        return (await this.JSONRPC('getNexus', params));
+    }
+    //Returns an array of contracts  deployed in Phantasma.
+    async getContracts(chainAddressOrName = 'main', extended = true) {
+        let params = [chainAddressOrName, extended];
+        return (await this.JSONRPC('getContracts', params));
+    }
+    //Returns the contract info deployed in Phantasma.
+    async getContract(chainAddressOrName = 'main', contractName) {
+        let params = [chainAddressOrName, contractName];
+        return (await this.JSONRPC('getContract', params));
+    }
+    async getContractByAddress(chainAddressOrName = 'main', contractAddress) {
+        let params = [chainAddressOrName, contractAddress];
+        return (await this.JSONRPC('getContractByAddress', params));
+    }
+    //Returns info about an organization.
+    async getOrganization(ID, extended = true) {
+        let params = [ID, extended];
+        return (await this.JSONRPC('getOrganization', params));
+    }
+    async getOrganizationByName(name, extended = true) {
+        let params = [name, extended];
+        return (await this.JSONRPC('getOrganizationByName', params));
+    }
+    async getOrganizations(extended = false) {
+        let params = [extended];
+        return (await this.JSONRPC('getOrganizations', params));
+    }
+    //Returns content of a Phantasma leaderboard.
+    async getLeaderboard(name) {
+        let params = [name];
+        return (await this.JSONRPC('getLeaderboard', params));
+    }
+    //Returns an array of tokens deployed in Phantasma.
+    async getTokens(ownerAddress, extended = true) {
+        let params = [extended, ownerAddress];
+        return (await this.JSONRPC('getTokens', params));
+    }
+    //Returns info about a specific token deployed in Phantasma.
+    async getToken(symbol, extended = true, carbonTokenId = 0n) {
+        let params = [symbol, extended, carbonTokenId.toString()];
+        return (await this.JSONRPC('getToken', params));
+    }
+    //Returns data of a non-fungible token, in hexadecimal format.
+    async getTokenData(symbol, IDtext) {
+        let params = [symbol, IDtext];
+        return (await this.JSONRPC('getTokenData', params));
+    }
+    //Returns the balance for a specific token and chain, given an address.
+    async getTokenBalance(account, tokenSymbol, chainInput, checkAddressResevedByte = true) {
+        let params = [account, tokenSymbol, chainInput, checkAddressResevedByte];
+        return (await this.JSONRPC('getTokenBalance', params));
+    }
+    //Returns series for specified token.
+    // Returns NFT series for a specific token using cursor-based pagination.
+    async getTokenSeries(symbol, carbonTokenId, pageSize = 10, cursor = '') {
+        let params = [symbol, carbonTokenId.toString(), pageSize, cursor];
+        return (await this.JSONRPC('getTokenSeries', params));
+    }
+    // Returns NFTs for a token (optionally restricted to a series) with cursor pagination.
+    async getTokenNFTs(carbonTokenId, carbonSeriesId = 0, pageSize = 10, cursor = '', extended = false) {
+        let params = [
+            carbonTokenId.toString(),
+            carbonSeriesId,
+            pageSize,
+            cursor,
+            extended,
+        ];
+        return (await this.JSONRPC('getTokenNFTs', params));
+    }
+    // Returns fungible token balances owned by an address, optionally filtered to one token.
+    async getAccountFungibleTokens(account, tokenSymbol = '', carbonTokenId = 0n, pageSize = 10, cursor = '', checkAddressReservedByte = true) {
+        let params = [
+            account,
+            tokenSymbol,
+            carbonTokenId.toString(),
+            pageSize,
+            cursor,
+            checkAddressReservedByte,
+        ];
+        return (await this.JSONRPC('getAccountFungibleTokens', params));
+    }
+    // Returns NFTs owned by an address, with optional token/series filters and extended properties.
+    async getAccountNFTs(account, tokenSymbol = '', carbonTokenId = 0n, carbonSeriesId = 0, pageSize = 10, cursor = '', extended = false, checkAddressReservedByte = true) {
+        let params = [
+            account,
+            tokenSymbol,
+            carbonTokenId.toString(),
+            carbonSeriesId,
+            pageSize,
+            cursor,
+            extended,
+            checkAddressReservedByte,
+        ];
+        return (await this.JSONRPC('getAccountNFTs', params));
+    }
+    // Returns NFT tokens for which the address owns at least one NFT instance.
+    async getAccountOwnedTokens(account, tokenSymbol = '', carbonTokenId = 0n, pageSize = 10, cursor = '', checkAddressReservedByte = true) {
+        let params = [
+            account,
+            tokenSymbol,
+            carbonTokenId.toString(),
+            pageSize,
+            cursor,
+            checkAddressReservedByte,
+        ];
+        return (await this.JSONRPC('getAccountOwnedTokens', params));
+    }
+    // Returns NFT series for which the address owns at least one NFT instance.
+    async getAccountOwnedTokenSeries(account, tokenSymbol = '', carbonTokenId = 0n, pageSize = 10, cursor = '', checkAddressReservedByte = true) {
+        let params = [
+            account,
+            tokenSymbol,
+            carbonTokenId.toString(),
+            pageSize,
+            cursor,
+            checkAddressReservedByte,
+        ];
+        return (await this.JSONRPC('getAccountOwnedTokenSeries', params));
+    }
+    //Returns the number of active auctions.
+    async getAuctionsCount(chainAddressOrName, symbol) {
+        let params = [chainAddressOrName, symbol];
+        return (await this.JSONRPC('getAuctionsCount', params));
+    }
+    //Returns the auctions available in the market.
+    async getAuctions(chainAddressOrName, symbol, page, pageSize) {
+        let params = [chainAddressOrName, symbol, page, pageSize];
+        return (await this.JSONRPC('getAuctions', params));
+    }
+    //Returns the auction for a specific token.
+    async getAuction(chainAddressOrName, symbol, IDtext) {
+        let params = [chainAddressOrName, symbol, IDtext];
+        return (await this.JSONRPC('getAuction', params));
+    }
+    //Returns info about a specific archive.
+    async getArchive(hashText) {
+        let params = [hashText];
+        return (await this.JSONRPC('getArchive', params));
+    }
+    //Writes the contents of an incomplete archive.
+    async writeArchive(hashText, blockIndex, blockContent) {
+        let params = [hashText, blockIndex, blockContent];
+        return (await this.JSONRPC('writeArchive', params));
+    }
+    //Returns the ABI interface of specific contract.
+    async getABI(chainAddressOrName, contractName) {
+        let params = [chainAddressOrName, contractName];
+        return (await this.JSONRPC('getABI', params));
+    }
+    //Returns list of known peers.
+    async getPeers() {
+        let params = [];
+        return (await this.JSONRPC('getPeers', params));
+    }
+    //Writes a message to the relay network.
+    async relaySend(receiptHex) {
+        let params = [receiptHex];
+        return (await this.JSONRPC('relaySend', params));
+    }
+    //Receives messages from the relay network.
+    async relayReceive(account) {
+        let params = [account];
+        return (await this.JSONRPC('relayReceive', params));
+    }
+    //Reads pending messages from the relay network.
+    async getEvents(account) {
+        let params = [account];
+        return (await this.JSONRPC('getEvents', params));
+    }
+    //Returns an array of available interop platforms.
+    async getPlatforms() {
+        let params = [];
+        return (await this.JSONRPC('getPlatforms', params));
+    }
+    //Returns an array of available validators.
+    async getValidators() {
+        let params = [];
+        return (await this.JSONRPC('getValidators', params));
+    }
+    //Tries to settle a pending swap for a specific hash.
+    async settleSwap(sourcePlatform, destPlatform, hashText) {
+        let params = [sourcePlatform, destPlatform, hashText];
+        return (await this.JSONRPC('settleSwap', params));
+    }
+    //Returns platform swaps for a specific address.
+    async getSwapsForAddressOld(account) {
+        let params = [account];
+        return (await this.JSONRPC('getSwapsForAddress', params));
+    }
+    //Returns platform swaps for a specific address.
+    async getSwapsForAddress(account, platform) {
+        let params = [account, platform, false];
+        return (await this.JSONRPC('getSwapsForAddress', params));
+    }
+    //Returns info of a nft.
+    async getNFT(symbol, nftId, extended = true) {
+        let params = [symbol, nftId, extended];
+        return (await this.JSONRPC('getNFT', params));
+    }
+    async getNFTs(symbol, nftIDs, extended = true) {
+        let params = [symbol, nftIDs.join(','), extended];
+        return (await this.JSONRPC('getNFTs', params));
+    }
+}
+exports.PhantasmaAPI = PhantasmaAPI;