phantasma-sdk-ts 0.2.0-rc.15 → 0.2.0-rc.16

package/dist/cjs/core/types/Carbon/Blockchain/Modules/TokenHelper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenHelper = void 0;
+const CarbonSerialization_1 = require("../../../CarbonSerialization");
+const Bytes32_1 = require("../../Bytes32");
+class TokenHelper {
+    static getNftAddress(carbonTokenId, instanceId) {
+        const w = new CarbonSerialization_1.CarbonBinaryWriter();
+        w.write(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) // Carbon NFT ID prefix
+        );
+        w.write8u(carbonTokenId);
+        w.write8u(instanceId);
+        return new Bytes32_1.Bytes32(w.toUint8Array());
+    }
+    static readUint64LE(bytes, offset) {
+        let result = 0n;
+        for (let i = 0; i < 8; i++) {
+            result |= BigInt(bytes[offset + i]) << (BigInt(i) * 8n);
+        }
+        return result;
+    }
+    /**
+     * Unpacks a Carbon NFT address (32 bytes) into its logical parts:
+     * - carbonTokenId: identifies the NFT token contract
+     * - instanceId: 64-bit composite id (series + mint)
+     * - seriesId / mintNumber: 32-bit halves of instanceId
+     */
+    static unpackNftAddress(address) {
+        const carbonTokenId = this.readUint64LE(address, 16);
+        const instanceId = this.readUint64LE(address, 24);
+        const seriesId = Number(instanceId & 0xffffffffn);
+        const mintNumber = Number((instanceId >> 32n) & 0xffffffffn);
+        return {
+            carbonTokenId,
+            instanceId,
+            seriesId,
+            mintNumber,
+        };
+    }
+}
+exports.TokenHelper = TokenHelper;

package/dist/esm/core/index.js

@@ -0,0 +1,9 @@
+export * from './rpc/phantasma';
+export * from './rpc';
+export * from './vm';
+export * from './tx';
+export * from './utils';
+export * from './types';
+export * from './interfaces';
+export * from './ledger';
+export * from './link';

package/dist/esm/core/interfaces/Carbon/ICarbonBlob.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/Carbon/index.js

@@ -0,0 +1 @@
+export * from "./ICarbonBlob";

package/dist/esm/core/interfaces/IContract.js

@@ -0,0 +1,22 @@
+export var NativeContractKind;
+(function (NativeContractKind) {
+    NativeContractKind[NativeContractKind["Gas"] = 0] = "Gas";
+    NativeContractKind[NativeContractKind["Block"] = 1] = "Block";
+    NativeContractKind[NativeContractKind["Stake"] = 2] = "Stake";
+    NativeContractKind[NativeContractKind["Swap"] = 3] = "Swap";
+    NativeContractKind[NativeContractKind["Account"] = 4] = "Account";
+    NativeContractKind[NativeContractKind["Consensus"] = 5] = "Consensus";
+    NativeContractKind[NativeContractKind["Governance"] = 6] = "Governance";
+    NativeContractKind[NativeContractKind["Storage"] = 7] = "Storage";
+    NativeContractKind[NativeContractKind["Validator"] = 8] = "Validator";
+    NativeContractKind[NativeContractKind["Interop"] = 9] = "Interop";
+    NativeContractKind[NativeContractKind["Exchange"] = 10] = "Exchange";
+    NativeContractKind[NativeContractKind["Privacy"] = 11] = "Privacy";
+    NativeContractKind[NativeContractKind["Relay"] = 12] = "Relay";
+    NativeContractKind[NativeContractKind["Ranking"] = 13] = "Ranking";
+    NativeContractKind[NativeContractKind["Market"] = 14] = "Market";
+    NativeContractKind[NativeContractKind["Friends"] = 15] = "Friends";
+    NativeContractKind[NativeContractKind["Mail"] = 16] = "Mail";
+    NativeContractKind[NativeContractKind["Sale"] = 17] = "Sale";
+    NativeContractKind[NativeContractKind["Unknown"] = 18] = "Unknown";
+})(NativeContractKind || (NativeContractKind = {}));

package/dist/esm/core/interfaces/IKeyPair.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/ISerializable.js

@@ -0,0 +1,2 @@
+export class ISerializable {
+}

package/dist/esm/core/interfaces/IStack.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/IToken.js

@@ -0,0 +1,19 @@
+export var TokenFlags;
+(function (TokenFlags) {
+    TokenFlags[TokenFlags["None"] = 0] = "None";
+    TokenFlags[TokenFlags["Transferable"] = 1] = "Transferable";
+    TokenFlags[TokenFlags["Fungible"] = 2] = "Fungible";
+    TokenFlags[TokenFlags["Finite"] = 4] = "Finite";
+    TokenFlags[TokenFlags["Divisible"] = 8] = "Divisible";
+    TokenFlags[TokenFlags["Fuel"] = 16] = "Fuel";
+    TokenFlags[TokenFlags["Stakable"] = 32] = "Stakable";
+    TokenFlags[TokenFlags["Fiat"] = 64] = "Fiat";
+    TokenFlags[TokenFlags["Swappable"] = 128] = "Swappable";
+    TokenFlags[TokenFlags["Burnable"] = 256] = "Burnable";
+    TokenFlags[TokenFlags["Mintable"] = 512] = "Mintable";
+})(TokenFlags || (TokenFlags = {}));
+export var TokenSeriesMode;
+(function (TokenSeriesMode) {
+    TokenSeriesMode[TokenSeriesMode["Unique"] = 0] = "Unique";
+    TokenSeriesMode[TokenSeriesMode["Duplicated"] = 1] = "Duplicated";
+})(TokenSeriesMode || (TokenSeriesMode = {}));

package/dist/esm/core/interfaces/Signature.js

@@ -0,0 +1,20 @@
+import { PBinaryWriter } from "../types";
+export var SignatureKind;
+(function (SignatureKind) {
+    SignatureKind[SignatureKind["None"] = 0] = "None";
+    SignatureKind[SignatureKind["Ed25519"] = 1] = "Ed25519";
+    SignatureKind[SignatureKind["ECDSA"] = 2] = "ECDSA";
+})(SignatureKind || (SignatureKind = {}));
+export class ISignature {
+}
+export class Signature {
+    Verify(message, address) {
+        return this.VerifyMultiple(message, [address]);
+    }
+    ToByteArray() {
+        const stream = new Uint8Array(64);
+        const writer = new PBinaryWriter(stream);
+        this.SerializeData(writer);
+        return new Uint8Array(stream);
+    }
+}

package/dist/esm/core/interfaces/index.js

@@ -0,0 +1,7 @@
+export * from "./Carbon";
+export * from "./IStack";
+export * from "./IToken";
+export * from "./IContract";
+export * from "./IKeyPair";
+export * from "./ISerializable";
+export * from "./Signature";

package/dist/esm/core/ledger/Address-Transcode.js

@@ -0,0 +1,41 @@
+import * as bs58 from 'bs58';
+import { Address, Base16, PhantasmaKeys } from '../types';
+/**
+ * Gets the address from a private key.
+ * @param privateKey The private key as a string.
+ * @returns The address as a string.
+ */
+export const GetAddressFromPrivateKey = (privateKey) => {
+    const keys = PhantasmaKeys.fromWIF(privateKey);
+    const publicKey = keys.Address.Text;
+    return publicKey;
+};
+/**
+ * Gets the address from a public key.
+ * @param publicKey The public key as a string.
+ * @returns The address as a string.
+ */
+export const GetAddressFromPublicKey = (publicKey) => {
+    // Assuming Base16.decodeUint8Array is a function that decodes a base16 string to Uint8Array
+    let pubKeyBytes = Base16.decodeUint8Array(publicKey);
+    // Create a new array and set the first two elements
+    let addrArray = new Uint8Array(34);
+    addrArray[0] = 1;
+    // Copy 32 bytes from the 2nd position of pubKeyBytes to addrArray, starting from the 3rd position of addrArray
+    addrArray.set(pubKeyBytes.slice(0, 32), 2);
+    return 'P' + bs58.encode(addrArray);
+};
+/**
+ * Gets the address from a public key.
+ * @param publicKey Public key as a string.
+ * @returns Address
+ */
+export const GetAddressPublicKeyFromPublicKey = (publicKey) => {
+    let pubKeyBytes = Base16.decodeUint8Array(publicKey);
+    // Create a new array and set the first two elements
+    let addrArray = new Uint8Array(34);
+    addrArray[0] = 1;
+    // Copy 32 bytes from the 2nd position of pubKeyBytes to addrArray, starting from the 3rd position of addrArray
+    addrArray.set(pubKeyBytes.slice(0, 32), 2);
+    return Address.FromPublickKey(addrArray);
+};

package/dist/esm/core/ledger/Ledger-Commands.js

@@ -0,0 +1,392 @@
+import { GetPrivateKeyFromMnemonic, } from '..';
+import { Transaction } from '../tx';
+import { Address, Base16, Ed25519Signature } from '../types';
+import { GetAddressFromPublicKey, GetAddressPublicKeyFromPublicKey } from './Address-Transcode';
+import { GetPublicFromPrivate, Verify } from './Transaction-Sign';
+import { GetExpirationDate } from './Transaction-Transcode';
+import { GetVersion, GetApplicationName, GetPublicKey, SignLedger } from './Ledger-Utils';
+/**
+ *
+ * @param number
+ * @param length
+ * @returns
+ */
+export const LeftPad = (number, length) => {
+    let str = '' + number;
+    while (str.length < length) {
+        str = '0' + str;
+    }
+    return str;
+};
+/**
+ *
+ * @param balance
+ * @param decimals
+ * @returns
+ */
+export const ToWholeNumber = (balance, decimals) => {
+    if (balance === undefined) {
+        throw Error('balance is a required parameter.');
+    }
+    if (decimals === undefined) {
+        throw Error('decimals is a required parameter.');
+    }
+    // console.log('toWholeNumber', 'balance', balance);
+    const paddedBalance = LeftPad(balance, decimals + 1);
+    // console.log('toWholeNumber', 'paddedBalance', paddedBalance);
+    const prefixLength = paddedBalance.length - decimals;
+    // console.log('toWholeNumber', 'prefixLength', prefixLength);
+    const prefix = paddedBalance.slice(0, prefixLength);
+    // console.log('toWholeNumber', 'prefix', prefix);
+    const suffix = paddedBalance.slice(-decimals);
+    // console.log('toWholeNumber', 'suffix', suffix);
+    return `${prefix}.${suffix}`;
+};
+/**
+ * Get the device info from the ledger.
+ * @param config
+ * @returns
+ */
+export const GetLedgerDeviceInfo = async (config) => {
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    const version = await GetVersion(config.Transport);
+    const applicationName = await GetApplicationName(config.Transport);
+    return {
+        version: version,
+        applicationName: applicationName,
+    };
+};
+/**
+ * Get Ledger Account Signer
+ * @param config
+ * @param accountIx
+ * @returns
+ */
+export const GetLedgerAccountSigner = async (config, accountIx) => {
+    /* istanbul ignore if */
+    if (config === undefined) {
+        throw Error('config is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (accountIx === undefined) {
+        throw Error('accountIx is a required parameter.');
+    }
+    const paths = await config.Transport.list();
+    console.log('paths', paths);
+    if (paths.length == 0) {
+        alert('NUmber of devices found:' + paths.length);
+        return;
+    }
+    const accountData = await GetLedgerSignerData(config, {
+        verifyOnDevice: false,
+        debug: true,
+    });
+    let signer = {
+        GetPublicKey: () => {
+            return accountData.publicKey;
+        },
+        GetAccount: () => {
+            return accountData.address;
+        },
+    };
+    return signer;
+};
+/**
+ * GetLedgerSignerData
+ * @param config
+ * @param options
+ * @returns
+ */
+export async function GetLedgerSignerData(config, options) {
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    if (options == undefined) {
+        throw Error('options is a required parameter.');
+    }
+    const msg = await GetPublicKey(config.Transport, options);
+    let response = {
+        address: Address.Null,
+        publicKey: '',
+        success: false,
+        message: '',
+    };
+    response.success = false;
+    response.message = msg.message;
+    if (!msg.success) {
+        return response;
+    }
+    const publicKey = msg.publicKey;
+    const address = GetAddressPublicKeyFromPublicKey(publicKey);
+    response.success = true;
+    response.message = 'success';
+    response.address = address;
+    response.publicKey = publicKey;
+    return response;
+}
+/**
+ * GetBalanceFromLedger
+ * @param config
+ * @param options
+ * @returns
+ */
+export const GetBalanceFromLedger = async (config, options) => {
+    /* istanbul ignore if */
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (options == undefined) {
+        throw Error('options is a required parameter.');
+    }
+    const msg = await GetPublicKey(config.Transport, options);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('getBalanceFromLedger', 'msg', msg);
+    }
+    let response = {
+        address: Address.Null,
+        publicKey: '',
+        balances: new Map(),
+        success: false,
+        message: '',
+    };
+    response.message = msg.message;
+    if (!msg.success) {
+        return response;
+    }
+    const publicKey = msg.publicKey;
+    const address = GetAddressPublicKeyFromPublicKey(publicKey);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('address', address);
+        console.log('rpc', config.RPC);
+    }
+    console.log('rpcAwait', await config.RPC.getAccount(address.Text));
+    const rpcResponse = await config.RPC.getAccount(address.Text);
+    if (config.Debug) {
+        console.log('rpcResponse', rpcResponse);
+    }
+    response.balances = new Map();
+    if (rpcResponse.balances !== undefined) {
+        rpcResponse.balances.forEach((balanceElt) => {
+            response.balances[balanceElt.symbol] = ToWholeNumber(balanceElt.amount, balanceElt.decimals);
+        });
+    }
+    response.address = address;
+    response.publicKey = publicKey;
+    response.success = true;
+    return response;
+};
+/**
+ * Get Addres from Ledger
+ * @param config
+ * @param options
+ * @returns
+ */
+export const GetAddressFromLedeger = async (config, options) => {
+    /* istanbul ignore if */
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (options == undefined) {
+        throw Error('options is a required parameter.');
+    }
+    const msg = await GetPublicKey(config.Transport, options);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('getBalanceFromLedger', 'msg', msg);
+    }
+    if (msg.success) {
+        const publicKey = msg.publicKey;
+        const address = GetAddressFromPublicKey(publicKey);
+        return address;
+    }
+    else {
+        return msg;
+    }
+};
+/**
+ *
+ * @param encodedTx
+ * @param config
+ * @returns
+ */
+async function SignEncodedTx(encodedTx, config) {
+    const response = await SignLedger(config.Transport, encodedTx);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('sendAmountUsingLedger', 'signCallback', 'response', response);
+    }
+    if (response.success) {
+        return response.signature;
+    }
+    else {
+        throw Error(response.message);
+    }
+}
+/**
+ * SendTransactionLedger
+ * @param config
+ * @param script
+ * @returns
+ */
+export async function SendTransactionLedger(config, script) {
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    const options = { verifyOnDevice: false };
+    const msg_publicKey = await GetPublicKey(config.Transport, options);
+    if (!msg_publicKey.success) {
+        if (config.Debug) {
+            console.log('SendTransactionLedger', 'error ', msg_publicKey);
+        }
+        return msg_publicKey;
+    }
+    const addr = GetAddressPublicKeyFromPublicKey(msg_publicKey.publicKey);
+    const publicKey = msg_publicKey.publicKey;
+    const nexusName = config.NexusName;
+    const chainName = config.ChainName;
+    const gasPrice = config.GasPrice;
+    const gasLimit = config.GasLimit;
+    const expirationDate = GetExpirationDate();
+    // no payload, could be a message.
+    const payload = config.Payload;
+    const myTransaction = new Transaction(nexusName, // Nexus Name
+    chainName, // Chain
+    script, // In string format
+    expirationDate, // Expiration Date
+    payload); // Extra Info to attach to Transaction in Serialized Hex
+    const encodedTx = Base16.encodeUint8Array(myTransaction.ToByteAray(false));
+    try {
+        if (config.Debug) {
+            console.log('sendAmountUsingCallback', 'encodedTx', encodedTx);
+        }
+        const signature = await SignEncodedTx(encodedTx, config);
+        if (config.Debug) {
+            console.log('sendAmountUsingCallback', 'signature', signature);
+        }
+        if (config.VerifyResponse) {
+            const verifyResponse = Verify(encodedTx, signature, publicKey);
+            if (verifyResponse == false) {
+                throw Error(`invalidSignature encodedTx:'${encodedTx}', publicKey:'${publicKey}' signature:'${signature}'`);
+            }
+            if (config.Debug) {
+                console.log('verifyResponse', verifyResponse);
+            }
+        }
+        let signatureBytes = Base16.decodeUint8Array(signature);
+        let mySignature = new Ed25519Signature(signatureBytes);
+        let myNewSignaturesArray = [];
+        myNewSignaturesArray.push(mySignature);
+        myTransaction.signatures = myNewSignaturesArray;
+        if (config.Debug) {
+            console.log('signedTx', myTransaction);
+        }
+        const encodedSignedTx = Base16.encodeUint8Array(myTransaction.ToByteAray(true));
+        console.log('encoded signed tx: ', encodedSignedTx);
+        const txHash = await config.RPC.sendRawTransaction(encodedSignedTx);
+        if (config.Debug) {
+            console.log('sendAmountUsingCallback', 'txHash', txHash);
+        }
+        const response = {
+            success: true,
+            message: txHash,
+        };
+        /* istanbul ignore if */
+        if (config.Debug) {
+            console.log('response', response);
+        }
+        return response;
+    }
+    catch (error) {
+        if (config.Debug) {
+            console.log('error', error);
+        }
+        const errorResponse = {
+            success: false,
+            message: error.message,
+        };
+        return errorResponse;
+    }
+}
+/**
+ *
+ * @param config
+ * @param privateKey
+ * @returns
+ */
+export const GetBalanceFromPrivateKey = async (config, privateKey) => {
+    /* istanbul ignore if */
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (privateKey == undefined) {
+        throw Error('privateKey is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('privateKey', privateKey);
+    }
+    // https://github.com/phantasma-io/phantasma-ts/blob/7d04aaed839851ae5640f68ab223ca7d92c42016/core/tx/utils.js
+    const publicKey = GetPublicFromPrivate(privateKey);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('publicKey', publicKey);
+    }
+    const address = GetAddressFromPublicKey(publicKey);
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('address', address);
+    }
+    // const path = `/address/${address}`;
+    // const response = await httpRequestUtil.get(config, path);
+    const rpcResponse = await config.RPC.getAccount(address);
+    if (config.Debug) {
+        console.log('rpcResponse', rpcResponse);
+    }
+    let response;
+    response.balances = new Map();
+    if (rpcResponse.balances !== undefined) {
+        rpcResponse.balances.forEach((balanceElt) => {
+            response.balances[balanceElt.symbol] = ToWholeNumber(balanceElt.amount, balanceElt.decimals);
+        });
+    }
+    response.address = Address.FromText(address);
+    response.success = true;
+    // const lastRefPath = `/transaction/last-ref/${address}`;
+    // const lastRefResponse = await httpRequestUtil.get(config, lastRefPath);
+    // response.lastRef = lastRefResponse;
+    return response;
+};
+/**
+ *
+ * @param config
+ * @param mnemonic
+ * @param index
+ * @returns
+ */
+export const GetBalanceFromMnemonic = async (config, mnemonic, index) => {
+    /* istanbul ignore if */
+    if (config == undefined) {
+        throw Error('config is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (mnemonic == undefined) {
+        throw Error('mnemonic is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (index == undefined) {
+        throw Error('index is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (config.Debug) {
+        console.log('mnemonic', mnemonic);
+    }
+    const privateKey = GetPrivateKeyFromMnemonic(config, mnemonic, index);
+    return await GetBalanceFromPrivateKey(config, privateKey);
+};