phantasma-sdk-ts 0.2.0-rc.9 → 0.2.1

package/dist/cjs/core/link/phantasmaLink.js

@@ -0,0 +1,550 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhantasmaLink = void 0;
+const vm_1 = require("../vm");
+const ProofOfWork_1 = require("./interfaces/ProofOfWork");
+const CarbonBlob_1 = require("../types/Carbon/CarbonBlob");
+const Hex_1 = require("../utils/Hex");
+class PhantasmaLink {
+    //Construct The Link
+    constructor(dappID, logging = true) {
+        this.lastSocketErrorMessage = null;
+        this.requestID = 0;
+        //Message Logging
+        this.onMessage = (msg) => {
+            if (this.messageLogging == true) {
+                console.log(msg);
+            }
+        };
+        this.version = 4;
+        this.nexus = 'testnet';
+        this.chain = 'main';
+        this.platform = 'poltergeist';
+        //Turn On|Off Console Logging
+        if (logging == false) {
+            this.messageLogging = false;
+        }
+        else {
+            this.messageLogging = true;
+            console.log('%cPhantasmaLink created', 'color:green');
+        }
+        this.requestID = 0;
+        //Standard Sets
+        this.host = 'localhost:7090';
+        this.dapp = dappID;
+        this.onLogin = function (succ) { }; //Does Nothing for Now
+        this.onError = function (message) { }; //Does Nothing for Now
+    }
+    //Connect To Wallet
+    login(onLoginCallback, onErrorCallback, version = 4, platform = 'phantasma', providerHint = 'poltergeist') {
+        this.providerHint = providerHint;
+        this.onLogin = onLoginCallback;
+        this.onError = onErrorCallback;
+        this.version = version;
+        this.platform = platform;
+        this.providerHint = providerHint;
+        this.createSocket();
+    }
+    //Script Invoking With Wallet Connection
+    invokeScript(script, callback) {
+        this.onMessage('Relaying transaction to wallet...');
+        if (!this.socket) {
+            callback('not logged in');
+            return;
+        }
+        if (script.length >= 8192) {
+            callback('script too big, sorry :(');
+            return;
+        }
+        let requestStr = this.chain + '/' + script;
+        if (this.version >= 2) {
+            requestStr = requestStr;
+        }
+        else {
+            requestStr = this.nexus + '/' + requestStr;
+        }
+        let invokeScriptRequest = 'invokeScript/' + requestStr;
+        var that = this;
+        this.sendLinkRequest(invokeScriptRequest, function (result) {
+            if (result.success) {
+                that.onMessage('Invoke successful, hash: ' + result + '...');
+                if (callback) {
+                    callback(result);
+                }
+            }
+        });
+    }
+    //Wallet Transaction Signing + Sending
+    signTx(script, payload, callback, onErrorCallback, pow = ProofOfWork_1.ProofOfWork.None, signature = 'Ed25519') {
+        //Overload Protection
+        if (script.length >= 65536) {
+            this.onMessage('Error: script is too big!');
+            if (onErrorCallback) {
+                onErrorCallback();
+            }
+            return;
+        }
+        //Check Payload
+        if (payload == null) {
+            payload = '7068616e7461736d612d7473'; //Says 'Phantasma-ts' in hex
+        }
+        else if (typeof payload === 'string') {
+            //Turn String Payload -> Bytes -> Hex
+            let sb = new vm_1.ScriptBuilder();
+            let bytes = sb.RawString(payload);
+            sb.AppendBytes(bytes);
+            payload = sb.EndScript();
+        }
+        else {
+            this.onMessage('Error: Invalid Payload');
+            if (onErrorCallback) {
+                onErrorCallback();
+            }
+            return;
+        }
+        this.onError = onErrorCallback; //Sets Error Callback Function
+        let that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        let request = 'signTx/' +
+            this.chain +
+            '/' +
+            script +
+            '/' +
+            payload +
+            '/' +
+            signature +
+            '/' +
+            this.platform +
+            '/' +
+            pow;
+        if (this.version == 1) {
+            request = 'signTx/' + this.nexus + '/' + this.chain + '/' + script + '/' + payload;
+        }
+        //Sends Signiture Request To Connected Wallet For Script
+        this.sendLinkRequest(request, function (result) {
+            if (result.success) {
+                if (result.hash.error) {
+                    that.onMessage('Error: ' + result.hash.error);
+                    return;
+                }
+                that.onMessage('Transaction successful, hash: ' + result.hash.substr(0, 15) + '...');
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback();
+                }
+            }
+        });
+    }
+    // Wallet Transaction Signing
+    signCarbonTxAndBroadcast(txMsg, callback = () => { }, onErrorCallback = () => { }) {
+        if (!txMsg) {
+            const message = 'Error: Invalid Carbon transaction message';
+            this.onMessage(message);
+            onErrorCallback(message);
+            return;
+        }
+        if (this.version < 4) {
+            const message = 'Carbon transactions require a wallet that supports Phantasma Link v4 or higher. Please reconnect with version 4+.';
+            this.onMessage(message);
+            if (onErrorCallback) {
+                onErrorCallback(message);
+            }
+            return;
+        }
+        let txHex;
+        try {
+            txHex = this.serializeCarbonTx(txMsg);
+        }
+        catch (err) {
+            const message = 'Error: Unable to serialize Carbon transaction';
+            this.onMessage(message + (err?.message ? ` (${err.message})` : ''));
+            onErrorCallback(message);
+            return;
+        }
+        const txLengthLimit = 65536;
+        if (txHex.length >= txLengthLimit) {
+            const message = `Error: Carbon transaction message is too big (${txHex.length} > ${txLengthLimit})!`;
+            this.onMessage(message);
+            onErrorCallback(message);
+            return;
+        }
+        this.onError = onErrorCallback;
+        const request = 'signCarbonTxAndBroadcast/' + txHex;
+        this.sendLinkRequest(request, (result) => {
+            if (result.success) {
+                this.onMessage('Carbon transaction signed');
+                callback(result);
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback(result.error || 'Carbon transaction signing failed');
+                }
+            }
+        });
+    }
+    signTxSignature(tx, callback, onErrorCallback, signature = 'Ed25519') {
+        if (!this.socket) {
+            this.onMessage('not logged in');
+            return;
+        }
+        if (tx == null) {
+            this.onMessage('invalid data, sorry :(');
+            return;
+        }
+        if (tx.length >= 1024) {
+            this.onMessage('data too big, sorry :(');
+            if (onErrorCallback) {
+                onErrorCallback();
+            }
+            return;
+        }
+        let signDataStr = 'signTxSignature/' + tx + '/' + signature + '/' + this.platform;
+        var that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        this.sendLinkRequest(signDataStr, function (result) {
+            if (result.success) {
+                that.onMessage('Data successfully signed');
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback();
+                }
+            }
+        });
+    }
+    multiSig(subject, callback, onErrorCallback, signature = 'Ed25519') {
+        if (!this.socket) {
+            this.onMessage('not logged in');
+            return;
+        }
+        if (subject == null) {
+            this.onMessage('invalid data, sorry :(');
+            return;
+        }
+        if (subject.length >= 1024) {
+            this.onMessage('data too big, sorry :(');
+            if (onErrorCallback) {
+                onErrorCallback();
+            }
+            return;
+        }
+        let signDataStr = 'multiSig/' + subject + '/' + signature + '/' + this.platform;
+        var that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        this.sendLinkRequest(signDataStr, function (result) {
+            if (result.success) {
+                that.onMessage('Data successfully signed');
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback();
+                }
+            }
+        });
+    }
+    getPeer(callback, onErrorCallback) {
+        this.onError = onErrorCallback; //Sets Error Callback Function
+        let that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        //Sends Signiture Request To Connected Wallet For Script
+        this.sendLinkRequest('getPeer/', function (result) {
+            if (result.success) {
+                that.onMessage('Peer Query,: ' + result);
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback();
+                }
+            }
+        });
+    }
+    fetchWallet(callback, onErrorCallback) {
+        let that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        let getAccountRequest = 'getAccount/' + this.platform;
+        this.sendLinkRequest(getAccountRequest, function (result) {
+            if (result.success) {
+                that.account = result;
+                callback(result);
+            }
+            else {
+                onErrorCallback('Could not obtain account info... Make sure you have an account currently open in ' +
+                    that.wallet +
+                    '...');
+                //that.disconnect("Unable to optain Account Info");
+            }
+            //that.onLogin(result.success);
+            //that.onLogin = null;
+        });
+    }
+    getNexus(callback, onErrorCallback) {
+        this.onError = onErrorCallback; //Sets Error Callback Function
+        let that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        //Sends Signiture Request To Connected Wallet For Script
+        this.sendLinkRequest('getNexus/', function (result) {
+            if (result.success) {
+                that.onMessage('Nexus Query,: ' + result);
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback('Error: ' + result.error);
+                }
+            }
+        });
+    }
+    getWalletVersion(callback, onErrorCallback) {
+        this.onError = onErrorCallback; //Sets Error Callback Function
+        let that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        //Sends Signiture Request To Connected Wallet For Script
+        this.sendLinkRequest('getWalletVersion/', function (result) {
+            if (result.success) {
+                that.onMessage('Wallet Version Query,: ' + result);
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback('Error: ' + result.error);
+                }
+            }
+        });
+    }
+    //Uses Wallet To Sign Data With Signiture
+    // Data needs to be in Base16 encode.
+    signData(data, callback, onErrorCallback, signature = 'Ed25519') {
+        if (!this.socket) {
+            this.onMessage('not logged in');
+            return;
+        }
+        if (data == null) {
+            this.onMessage('invalid data, sorry :(');
+            return;
+        }
+        if (data.length >= 1024) {
+            this.onMessage('data too big, sorry :(');
+            if (onErrorCallback) {
+                onErrorCallback('data too big, sorry :(');
+            }
+            return;
+        }
+        let signDataStr = 'signData/' + data + '/' + signature + '/' + this.platform;
+        var that = this; //Allows the use of 'this' inside sendLinkRequest Object
+        this.sendLinkRequest(signDataStr, function (result) {
+            if (result.success) {
+                that.onMessage('Data successfully signed');
+                if (callback) {
+                    callback(result);
+                }
+            }
+            else {
+                if (onErrorCallback) {
+                    onErrorCallback(result);
+                }
+            }
+        });
+    }
+    //Wallet Socket Connection Creation
+    createSocket(isResume = false) {
+        let path = 'ws://' + this.host + '/phantasma';
+        this.onMessage('Phantasma Link connecting...');
+        if (this.socket) {
+            this.socket.close();
+        }
+        //@ts-ignore
+        this.socket = //@ts-ignore
+            window.PhantasmaLinkSocket && this.providerHint !== 'poltergeist'
+                ? // @ts-ignore
+                    new PhantasmaLinkSocket()
+                : new WebSocket(path);
+        this.requestCallback = null;
+        this.lastSocketErrorMessage = null;
+        this.token = null;
+        this.account = null;
+        this.requestID = 0;
+        let authorizeRequest = 'authorize/' + this.dapp + '/' + this.version;
+        let getAccountRequest = 'getAccount/' + this.platform;
+        let that = this;
+        //Once Socket Opened
+        this.socket.onopen = function (e) {
+            that.onMessage('Connection established, authorizing dapp in wallet...');
+            if (isResume) {
+                that.fetchWallet(undefined, undefined);
+            }
+            else {
+                that.sendLinkRequest(authorizeRequest, function (result) {
+                    //Set Global Variables With Successful Account Query
+                    if (result.success) {
+                        that.token = result.token;
+                        that.wallet = result.wallet;
+                        that.onMessage('Authorized, obtaining account info...');
+                        that.sendLinkRequest(getAccountRequest, function (result) {
+                            if (result.success) {
+                                that.account = result;
+                            }
+                            else {
+                                that.onError('Could not obtain account info... Make sure you have an account currently open in ' +
+                                    that.wallet +
+                                    '...');
+                                that.disconnect('Unable to optain Account Info');
+                            }
+                            that.onLogin(result.success);
+                            that.onLogin = null;
+                        });
+                    }
+                    else {
+                        that.onError('Authorization failed...');
+                        that.disconnect('Auth Failure');
+                    }
+                });
+            }
+        };
+        //Retrieves Message From Socket and Processes It
+        this.socket.onmessage = function (event) {
+            const obj = JSON.parse(event.data);
+            if (that.messageLogging == true) {
+                console.log('%c' + event.data, 'color:blue');
+            }
+            //Checks What To Do Based On Message
+            switch (obj.message) {
+                case 'Wallet is Closed':
+                    that.onError('Could not obtain account info... Make sure you have an account currently open in ' +
+                        that.wallet);
+                    that.disconnect(true);
+                    break;
+                case 'not logged in':
+                    that.onError('Could not obtain account info... Make sure you have an account currently logged in');
+                    that.disconnect(true);
+                    break;
+                case 'A previouus request is still pending' || 'A previous request is still pending':
+                    that.onError('You have a pending action in your wallet');
+                    break;
+                case 'user rejected':
+                    that.onError('Transaction cancelled by user in ' + that.wallet);
+                    break;
+                case 'user rejected':
+                    that.onError('Transaction cancelled by user in ' + that.wallet);
+                    break;
+                default:
+                    if (obj.message && obj.message.startsWith('nexus mismatch')) {
+                        that.onError(obj.message);
+                    }
+                    else {
+                        let temp = that.requestCallback;
+                        if (temp == null) {
+                            that.onError('Something bad happened');
+                            return;
+                        }
+                        that.requestCallback = null;
+                        temp(obj);
+                    }
+                    break;
+            }
+        };
+        //Cleanup After Socket Closes
+        this.socket.onclose = function (event) {
+            const reason = event.reason && event.reason.length > 0
+                ? event.reason
+                : that.lastSocketErrorMessage || (event.wasClean ? 'Wallet connection closed' : 'Connection terminated unexpectedly');
+            that.lastSocketErrorMessage = null;
+            if (that.requestCallback) {
+                that.handleSocketFailure(reason);
+            }
+            else if (!event.wasClean) {
+                that.handleSocketFailure(reason);
+            }
+        };
+        //Error Callback When Socket Has Error
+        this.socket.onerror = function (error) {
+            const errMsg = error && typeof error.message === 'string' && error.message.length > 0
+                ? error.message
+                : 'WebSocket error';
+            that.lastSocketErrorMessage = errMsg;
+            that.onMessage('Error: ' + errMsg);
+        };
+    }
+    //Message Logging Util
+    toggleMessageLogging() {
+        if (this.messageLogging == true) {
+            this.messageLogging = false;
+        }
+        else {
+            this.messageLogging = true;
+        }
+    }
+    resume(token) {
+        this.token = token;
+        this.retry();
+    }
+    //Retry Util
+    retry() {
+        this.createSocket();
+    }
+    //Get Dapp ID Name Util
+    set dappID(dapp) {
+        this.dapp = dapp;
+    }
+    get dappID() {
+        return this.dapp;
+    }
+    //Build Request and Send To Wallet Via Socket
+    sendLinkRequest(request, callback) {
+        this.onMessage('Sending Phantasma Link request: ' + request);
+        this.requestCallback = callback;
+        const socket = this.socket;
+        const openState = typeof WebSocket !== 'undefined' && typeof WebSocket.OPEN === 'number' ? WebSocket.OPEN : 1;
+        const isSocketOpen = socket && socket.readyState === openState;
+        if (!socket || !isSocketOpen) {
+            this.handleSocketFailure('Wallet connection is closed. Please reconnect to your wallet.');
+            return;
+        }
+        if (this.token != null) {
+            request = request + '/' + this.dapp + '/' + this.token;
+        }
+        this.requestID++; //Object Nonce Increase?
+        request = this.requestID + ',' + request;
+        try {
+            socket.send(request);
+        }
+        catch (err) {
+            const errMessage = err && typeof err.message === 'string' && err.message.length > 0
+                ? err.message
+                : 'Failed to send request to wallet';
+            this.handleSocketFailure(errMessage);
+        }
+    }
+    handleSocketFailure(message) {
+        const callback = this.requestCallback;
+        this.requestCallback = null;
+        const errorMessage = message || 'Connection lost with Phantasma Link wallet';
+        if (callback) {
+            callback({ success: false, error: errorMessage });
+            return;
+        }
+        if (this.onError) {
+            this.onError(errorMessage);
+        }
+    }
+    //Disconnect The Wallet Connection Socket
+    disconnect(triggered) {
+        this.onMessage('Disconnecting Phantasma Link: ' + triggered);
+        if (this.socket)
+            this.socket.close();
+    }
+    serializeCarbonTx(txMsg) {
+        const serialized = CarbonBlob_1.CarbonBlob.Serialize(txMsg);
+        return (0, Hex_1.bytesToHex)(serialized);
+    }
+}
+exports.PhantasmaLink = PhantasmaLink;

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

@@ -0,0 +1,17 @@
+"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("./vmSchemaHelpers"), exports);

package/dist/cjs/core/rpc/helpers/vmSchemaHelpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vmVariableSchemaFromRpcResult = exports.vmStructSchemaFromRpcResult = void 0;
+const types_1 = require("../../types");
+function vmStructSchemaFromRpcResult(r) {
+    const schema = new types_1.VmStructSchema();
+    schema.fields = [];
+    const fields = r?.fields ?? [];
+    for (const f of fields) {
+        const name = String(f?.name ?? '');
+        if (!name)
+            continue;
+        const t = f.schema?.type;
+        let vmType;
+        if (typeof t === 'number')
+            vmType = t;
+        else if (typeof t === 'string')
+            vmType = (0, types_1.vmTypeFromString)(t);
+        else
+            continue;
+        schema.fields.push(new types_1.VmNamedVariableSchema(name, vmType));
+    }
+    return schema;
+}
+exports.vmStructSchemaFromRpcResult = vmStructSchemaFromRpcResult;
+function vmVariableSchemaFromRpcResult(v) {
+    const typeVal = v?.type;
+    let vmType;
+    if (typeof typeVal === 'number')
+        vmType = typeVal;
+    else if (typeof typeVal === 'string')
+        vmType = (0, types_1.vmTypeFromString)(typeVal);
+    else
+        throw new Error('Invalid VmVariableSchemaResult.type');
+    const vs = new types_1.VmVariableSchema(vmType);
+    // If nested struct schema is present, convert recursively
+    if (v.schema) {
+        vs.structure = vmStructSchemaFromRpcResult(v.schema);
+    }
+    return vs;
+}
+exports.vmVariableSchemaFromRpcResult = vmVariableSchemaFromRpcResult;

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

@@ -0,0 +1,19 @@
+"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("./helpers"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./phantasma"), exports);

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });