phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/cjs/rpc/phantasma.js

@@ -0,0 +1,439 @@
+"use strict";
+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 logger_js_1 = require("../utils/logger.js");
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const rpc_result_js_1 = require("./rpc-result.js");
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function rpcHttpError(status, statusText) {
+    return {
+        error: statusText ? `HTTP ${status}: ${statusText}` : `HTTP ${status}`,
+        status,
+        statusText,
+    };
+}
+function parseRpcNumber(result) {
+    return typeof result === 'string' ? parseInt(result, 10) : result;
+}
+class PhantasmaAPI {
+    pingAsync(host) {
+        return new Promise((resolve, reject) => {
+            const started = new Date().getTime();
+            const http = new XMLHttpRequest();
+            http.open('GET', host + '/rpc', true);
+            http.timeout = 4500;
+            http.onreadystatechange = function () {
+                if (http.readyState == 4 && http.status == 200) {
+                    const ended = new Date().getTime();
+                    const milliseconds = ended - started;
+                    resolve(milliseconds);
+                }
+                http.ontimeout = function () {
+                    resolve(100000);
+                };
+                http.onerror = function () {
+                    resolve(100000);
+                };
+            };
+            try {
+                http.send(null);
+            }
+            catch {
+                // 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 (let i = 0; i < data.length; i++) {
+                    const peer = data[i];
+                    logger_js_1.logger.log('Checking RPC: ', peer);
+                    try {
+                        const msecs = await this.pingAsync(peer.url);
+                        peer.info = peer.location + ' • ' + msecs + ' ms';
+                        peer.msecs = msecs;
+                        logger_js_1.logger.log(peer.location + ' • ' + msecs + ' ms • ' + peer.url + '/rpc');
+                        this.availableHosts.push(peer);
+                    }
+                    catch {
+                        logger_js_1.logger.log('Error with RPC: ' + peer.url);
+                    }
+                }
+                this.availableHosts.sort((a, b) => (a.msecs ?? Number.MAX_SAFE_INTEGER) - (b.msecs ?? Number.MAX_SAFE_INTEGER));
+                this.updateRpc();
+            });
+        }
+    }
+    async JSONRPCResult(method, params) {
+        let res;
+        try {
+            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' },
+            });
+        }
+        catch (error) {
+            return (0, rpc_result_js_1.normalizeRpcError)(error, `RPC request ${method} failed`);
+        }
+        if (!res.ok) {
+            return rpcHttpError(res.status, res.statusText);
+        }
+        let resJson;
+        try {
+            resJson = await res.json();
+        }
+        catch (error) {
+            return (0, rpc_result_js_1.normalizeRpcError)(error, `RPC request ${method} returned invalid JSON`);
+        }
+        logger_js_1.logger.log('method', method, resJson);
+        if (!isObjectRecord(resJson)) {
+            return (0, rpc_result_js_1.normalizeRpcError)(undefined, `RPC request ${method} returned an invalid response`);
+        }
+        const response = resJson;
+        if (response.error !== undefined && response.error !== null) {
+            return (0, rpc_result_js_1.normalizeRpcError)(response.error, `RPC request ${method} failed`);
+        }
+        if (!('result' in response)) {
+            return (0, rpc_result_js_1.normalizeRpcError)(undefined, `RPC request ${method} returned no result`);
+        }
+        return response.result;
+    }
+    async JSONRPC(method, params) {
+        const 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' },
+        });
+        const resJson = (await res.json());
+        logger_js_1.logger.log('method', method, resJson);
+        if (resJson.error) {
+            if (typeof resJson.error === 'object' && resJson.error.message)
+                return { error: resJson.error.message };
+            return { error: resJson.error };
+        }
+        return 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) {
+            logger_js_1.logger.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';
+            }
+            logger_js_1.logger.log('%cSet RPC api to ' + this.host, 'font-size: 20px');
+        }
+    }
+    convertDecimals(amount, decimals) {
+        const mult = Math.pow(10, decimals);
+        return amount / mult;
+    }
+    //Returns the account name and balance of given address.
+    async getAccount(account, extended = true) {
+        const params = [account, extended];
+        return (await this.JSONRPC('getAccount', params));
+    }
+    //Returns the accounts name and balance of given addresses.
+    async getAccounts(accounts, extended = true) {
+        const params = [accounts.join(','), extended];
+        return (await this.JSONRPC('getAccounts', params));
+    }
+    //Returns the address that owns a given name.
+    async lookUpName(name) {
+        const params = [name];
+        return (await this.JSONRPC('lookUpName', params));
+    }
+    //Returns the height of a chain.
+    async getBlockHeight(chainInput) {
+        const params = [chainInput];
+        const result = await this.JSONRPC('getBlockHeight', params);
+        return parseRpcNumber(result);
+    }
+    //Returns the number of transactions of given block hash or error if given hash is invalid or is not found.
+    async getBlockTransactionCountByHash(chainAddressOrName, blockHash) {
+        const params = [chainAddressOrName, blockHash];
+        const result = await this.JSONRPC('getBlockTransactionCountByHash', params);
+        return parseRpcNumber(result);
+    }
+    //Returns information about a block by hash.
+    async getBlockByHash(blockHash) {
+        const params = [blockHash];
+        return (await this.JSONRPC('getBlockByHash', params));
+    }
+    //Returns information about a block by height and chain.
+    async getBlockByHeight(chainInput, height) {
+        const params = [chainInput, height];
+        return (await this.JSONRPC('getBlockByHeight', params));
+    }
+    //Returns information about a block by height and chain.
+    async getLatestBlock(chainInput) {
+        const params = [chainInput];
+        return (await this.JSONRPC('getLatestBlock', params));
+    }
+    //Returns the information about a transaction requested by a block hash and transaction index.
+    async getTransactionByBlockHashAndIndex(chainAddressOrName, blockHash, index) {
+        const params = [chainAddressOrName, blockHash, index];
+        return (await this.JSONRPC('getTransactionByBlockHashAndIndex', params));
+    }
+    //Returns last X transactions of given address.
+    async getAddressTransactions(account, page, pageSize) {
+        const params = [account, page, pageSize];
+        return (await this.JSONRPC('getAddressTransactions', params));
+    }
+    //Get number of transactions in a specific address and chain
+    async getAddressTransactionCount(account, chainInput) {
+        const params = [account, chainInput];
+        return (await this.JSONRPC('getAddressTransactionCount', params));
+    }
+    // Broadcasts a manually built signed operation to the network.
+    async sendRawTransaction(txData) {
+        const params = [txData];
+        return (await this.JSONRPC('sendRawTransaction', params));
+    }
+    // Broadcasts a signed Carbon transaction to the network.
+    async sendCarbonTransaction(txData) {
+        const params = [txData];
+        return (await this.JSONRPC('sendCarbonTransaction', params));
+    }
+    // Invokes a script against network state without state changes.
+    async invokeRawScript(chainInput, scriptData) {
+        const params = [chainInput, scriptData];
+        return (await this.JSONRPC('invokeRawScript', params));
+    }
+    //Returns information about a transaction by hash.
+    async getTransaction(hashText) {
+        const params = [hashText];
+        return (await this.JSONRPC('getTransaction', params));
+    }
+    //Returns an array of all chains deployed in Phantasma.
+    // Warning: current Carbon RPC endpoint is stubbed and returns an empty array.
+    async getChains(extended = true) {
+        const params = [extended];
+        return (await this.JSONRPC('getChains', params));
+    }
+    //Return the chain
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default chain object.
+    async getChain(name, extended = true) {
+        const params = [name, extended];
+        return (await this.JSONRPC('getChain', params));
+    }
+    //Returns info about the nexus.
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default nexus object.
+    async getNexus(extended = true) {
+        const params = [extended];
+        return (await this.JSONRPC('getNexus', params));
+    }
+    //Returns an array of contracts  deployed in Phantasma.
+    async getContracts(chainAddressOrName = 'main', extended = true) {
+        const params = [chainAddressOrName, extended];
+        return (await this.JSONRPC('getContracts', params));
+    }
+    //Returns the contract info deployed in Phantasma.
+    async getContract(chainAddressOrName = 'main', contractName) {
+        const params = [chainAddressOrName, contractName];
+        return (await this.JSONRPC('getContract', params));
+    }
+    async getContractByAddress(chainAddressOrName = 'main', contractAddress) {
+        const params = [chainAddressOrName, contractAddress];
+        return (await this.JSONRPC('getContractByAddress', params));
+    }
+    //Returns info about an organization.
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default organization object.
+    async getOrganization(ID, extended = true) {
+        const params = [ID, extended];
+        return (await this.JSONRPC('getOrganization', params));
+    }
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default organization object.
+    async getOrganizationByName(name, extended = true) {
+        const params = [name, extended];
+        return (await this.JSONRPC('getOrganizationByName', params));
+    }
+    // Warning: current Carbon RPC endpoint is stubbed and returns an empty array.
+    async getOrganizations(extended = false) {
+        const params = [extended];
+        return (await this.JSONRPC('getOrganizations', params));
+    }
+    //Returns content of a Phantasma leaderboard.
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default leaderboard object.
+    async getLeaderboard(name) {
+        const params = [name];
+        return (await this.JSONRPC('getLeaderboard', params));
+    }
+    //Returns an array of tokens deployed in Phantasma.
+    async getTokens(ownerAddress, extended = true) {
+        const 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) {
+        const 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) {
+        const 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) {
+        const 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 = '') {
+        const params = [symbol, carbonTokenId.toString(), pageSize, cursor];
+        return (await this.JSONRPC('getTokenSeries', params));
+    }
+    // Returns one token series by Phantasma or Carbon identifiers.
+    async getTokenSeriesById(symbol, carbonTokenId, seriesId, carbonSeriesId) {
+        const params = [symbol, carbonTokenId.toString(), seriesId, carbonSeriesId];
+        return (await this.JSONRPC('getTokenSeriesById', params));
+    }
+    // Returns NFTs for a token (optionally restricted to a series) with cursor pagination.
+    async getTokenNFTs(carbonTokenId, carbonSeriesId = 0, pageSize = 10, cursor = '', extended = false) {
+        const 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) {
+        const 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) {
+        const 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) {
+        const 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) {
+        const params = [
+            account,
+            tokenSymbol,
+            carbonTokenId.toString(),
+            pageSize,
+            cursor,
+            checkAddressReservedByte,
+        ];
+        return (await this.JSONRPC('getAccountOwnedTokenSeries', params));
+    }
+    //Returns the number of active auctions.
+    async getAuctionsCount(chainAddressOrName, symbol) {
+        const params = [chainAddressOrName, symbol];
+        return (await this.JSONRPC('getAuctionsCount', params));
+    }
+    //Returns the auctions available in the market.
+    async getAuctions(chainAddressOrName, symbol, page, pageSize) {
+        const params = [chainAddressOrName, symbol, page, pageSize];
+        return (await this.JSONRPC('getAuctions', params));
+    }
+    //Returns the auction for a specific token.
+    async getAuction(chainAddressOrName, symbol, IDtext) {
+        const params = [chainAddressOrName, symbol, IDtext];
+        return (await this.JSONRPC('getAuction', params));
+    }
+    //Returns info about a specific archive.
+    // Warning: current Carbon RPC endpoint is stubbed and returns a default archive object.
+    async getArchive(hashText) {
+        const params = [hashText];
+        return (await this.JSONRPC('getArchive', params));
+    }
+    //Writes the contents of an incomplete archive.
+    // Warning: current Carbon RPC endpoint is stubbed and returns false without persisting data.
+    async writeArchive(hashText, blockIndex, blockContent) {
+        const params = [hashText, blockIndex, blockContent];
+        return (await this.JSONRPC('writeArchive', params));
+    }
+    //Returns info of a nft.
+    async getNFT(symbol, nftId, extended = true) {
+        const params = [symbol, nftId, extended];
+        return (await this.JSONRPC('getNFT', params));
+    }
+    async getNFTs(symbol, nftIDs, extended = true) {
+        const params = [symbol, nftIDs.join(','), extended];
+        return (await this.JSONRPC('getNFTs', params));
+    }
+    async getVersion() {
+        return (await this.JSONRPC('getVersion', []));
+    }
+    async getPhantasmaVmConfig(chainAddressOrName) {
+        const params = [chainAddressOrName];
+        return (await this.JSONRPC('getPhantasmaVmConfig', params));
+    }
+}
+exports.PhantasmaAPI = PhantasmaAPI;

package/dist/cjs/rpc/rpc-result.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRpcErrorResult = isRpcErrorResult;
+exports.getRpcErrorMessage = getRpcErrorMessage;
+exports.normalizeRpcError = normalizeRpcError;
+exports.unwrapRpcResult = unwrapRpcResult;
+function isRpcErrorResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'error' in value &&
+        typeof value.error === 'string' &&
+        value.error.length > 0);
+}
+function getRpcErrorMessage(value, fallback = 'RPC request failed') {
+    if (isRpcErrorResult(value)) {
+        return value.error;
+    }
+    if (value instanceof Error) {
+        return value.message;
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (typeof record.message === 'string' && record.message.length > 0) {
+            return record.message;
+        }
+        if (typeof record.error === 'string' && record.error.length > 0) {
+            return record.error;
+        }
+    }
+    return fallback;
+}
+function normalizeRpcError(error, fallback = 'RPC request failed') {
+    const result = {
+        error: getRpcErrorMessage(error, fallback),
+    };
+    if (typeof error === 'object' && error !== null) {
+        const record = error;
+        if (typeof record.code === 'number') {
+            result.code = record.code;
+        }
+        if ('data' in record) {
+            result.data = record.data;
+        }
+    }
+    return result;
+}
+function unwrapRpcResult(result) {
+    if (isRpcErrorResult(result)) {
+        throw new Error(result.error);
+    }
+    return result;
+}

package/dist/cjs/tx/contract-artifacts.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContractName = normalizeContractName;
+exports.coerceContractBytes = coerceContractBytes;
+exports.buildContractArtifactManifest = buildContractArtifactManifest;
+exports.buildContractArtifactBundle = buildContractArtifactBundle;
+const sha256_js_1 = __importDefault(require("crypto-js/sha256.js"));
+const enc_hex_js_1 = __importDefault(require("crypto-js/enc-hex.js"));
+const index_js_1 = require("../utils/index.js");
+function sha256Hex(bytes) {
+    return (0, sha256_js_1.default)(enc_hex_js_1.default.parse((0, index_js_1.bytesToHex)(bytes))).toString(enc_hex_js_1.default);
+}
+function buildFileEntry(path, bytes) {
+    const trimmedPath = path.trim();
+    if (!trimmedPath) {
+        throw new Error('artifact path cannot be empty');
+    }
+    return {
+        path: trimmedPath,
+        size: bytes.length,
+        sha256: sha256Hex(bytes),
+    };
+}
+function normalizeContractName(contractName) {
+    const trimmed = contractName.trim();
+    if (!trimmed) {
+        throw new Error('contractName cannot be empty');
+    }
+    return trimmed;
+}
+function coerceContractBytes(input, label) {
+    if (input instanceof Uint8Array) {
+        if (input.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        // Copy mutable buffers so callers can keep reusing their original arrays safely.
+        return new Uint8Array(input);
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        const bytes = (0, index_js_1.hexToBytes)(trimmed);
+        if (bytes.length === 0) {
+            throw new Error(`${label} cannot be empty`);
+        }
+        return bytes;
+    }
+    throw new Error(`${label} must be Uint8Array or hex string`);
+}
+function buildContractArtifactManifest(params) {
+    // The manifest is the stable handoff contract between compiler, CLI, frontend, and runbooks.
+    const contractName = normalizeContractName(params.contractName);
+    const compilerName = params.compilerName.trim();
+    const compilerVersion = params.compilerVersion.trim();
+    if (!compilerName) {
+        throw new Error('compilerName cannot be empty');
+    }
+    if (!compilerVersion) {
+        throw new Error('compilerVersion cannot be empty');
+    }
+    const scriptBytes = coerceContractBytes(params.script, 'script');
+    const abiBytes = coerceContractBytes(params.abi, 'abi');
+    let debugEntry;
+    if (params.debugPath !== undefined || params.debug !== undefined) {
+        if (!params.debugPath || params.debug === undefined) {
+            throw new Error('debugPath and debug must be provided together');
+        }
+        debugEntry = buildFileEntry(params.debugPath, coerceContractBytes(params.debug, 'debug'));
+    }
+    const manifest = {
+        format: 'pha.contract.artifacts/v1',
+        contractName,
+        createdAtUtc: (params.createdAtUtc ?? new Date().toISOString()).trim(),
+        compiler: {
+            name: compilerName,
+            version: compilerVersion,
+        },
+        files: {
+            script: buildFileEntry(params.scriptPath, scriptBytes),
+            abi: buildFileEntry(params.abiPath, abiBytes),
+            ...(debugEntry ? { debug: debugEntry } : {}),
+        },
+        ...(params.sourceFile ? { sourceFile: params.sourceFile } : {}),
+    };
+    if (!manifest.createdAtUtc) {
+        throw new Error('createdAtUtc cannot be empty');
+    }
+    return manifest;
+}
+function buildContractArtifactBundle(params) {
+    // Keep bundle materialization small and explicit so higher layers can choose their own IO/layout policy.
+    const bundle = {
+        contractName: normalizeContractName(params.contractName),
+        script: coerceContractBytes(params.script, 'script'),
+        abi: coerceContractBytes(params.abi, 'abi'),
+        ...(params.debug !== undefined ? { debug: coerceContractBytes(params.debug, 'debug') } : {}),
+        ...(params.manifest ? { manifest: params.manifest } : {}),
+    };
+    return bundle;
+}