phantasma-sdk-ts 0.1.71

package/src/core/ledger/Transaction-Sign.ts

@@ -0,0 +1,126 @@
+import * as crypto from 'crypto';
+
+const PUBLIC_KEY_PREFIX = '302A300506032B6570032100';
+const DEBUG = false;
+
+export const PrivateToDer = (privateKeyHex: string): Buffer => {
+  if (DEBUG) {
+    console.log('privateToDer', 'privateKeyHex', privateKeyHex);
+  }
+  const derHex = `302e020100300506032b657004220420${privateKeyHex}`;
+  if (DEBUG) {
+    console.log('privateToDer', 'derHex', derHex);
+  }
+  return Buffer.from(derHex, 'hex');
+};
+
+export const PublicToDer = (publicKeyHex: string): Buffer => {
+  const publicKeyDerHex = `${PUBLIC_KEY_PREFIX}${publicKeyHex}`;
+  return Buffer.from(publicKeyDerHex, 'hex');
+};
+
+export const PublicToPem = (publicKeyHex: string): string => {
+  const publicKeyDer = PublicToDer(publicKeyHex);
+  const publicKeyDerBase64 = publicKeyDer.toString('base64');
+  return `-----BEGIN PUBLIC KEY-----\n${publicKeyDerBase64}\n-----END PUBLIC KEY-----`;
+};
+
+export const SignBytes = (hash: Buffer, privateKey: Buffer): string => {
+  if (DEBUG) {
+    console.log('signBytes.hash', hash);
+    console.log('signBytes.privateKey', privateKey);
+  }
+  const privateKeyDer = PrivateToDer(privateKey.toString('hex'));
+  if (DEBUG) {
+    console.log('signBytes.privateKeyDer', privateKeyDer);
+  }
+  const privateKeyObj = crypto.createPrivateKey({
+    key: privateKeyDer,
+    format: 'der',
+    type: 'pkcs8',
+  });
+  const signature = crypto.sign(undefined, hash, privateKeyObj);
+  const signatureHex = signature.toString('hex');
+  if (DEBUG) {
+    console.log('signatureHex', signatureHex);
+  }
+  return signatureHex;
+};
+
+export const GetHash = (encodedTx: string, debug?: boolean): Buffer => {
+  return Buffer.from(encodedTx, 'hex');
+};
+
+export const Sign = (encodedTx: string, privateKeyHex: string): string => {
+  if (DEBUG) {
+    console.log('sign', 'encodedTx', encodedTx);
+  }
+  const privateKey = Buffer.from(privateKeyHex, 'hex');
+  if (DEBUG) {
+    console.log('sign', 'privateKey', privateKey.toString('hex'));
+  }
+
+  const hash = GetHash(encodedTx);
+  if (DEBUG) {
+    console.log('sign', 'hash', hash.toString('hex'));
+  }
+  const signature = SignBytes(hash, privateKey);
+  if (DEBUG) {
+    console.log('sign', 'signature', signature);
+  }
+  return signature.toLowerCase();
+};
+
+export const Verify = (encodedTx: string, signatureHex: string, publicKeyHex: string): boolean => {
+  if (DEBUG) {
+    console.log('verify', 'encodedTx', encodedTx);
+    console.log('verify', 'signatureHex', signatureHex);
+    console.log('verify', 'publicKeyHex', publicKeyHex);
+  }
+  const publicKeyPem = PublicToPem(publicKeyHex);
+  if (DEBUG) {
+    console.log('verify', 'publicKeyPem', publicKeyPem);
+  }
+  const publicKeyObj = crypto.createPublicKey({
+    key: publicKeyPem,
+    format: 'pem',
+    type: 'spki',
+  });
+  const signature = Buffer.from(signatureHex, 'hex');
+  const hash = GetHash(encodedTx);
+  if (DEBUG) {
+    console.log('verify', 'hash', hash.toString('hex'));
+  }
+  return crypto.verify(undefined, hash, publicKeyObj, signature);
+};
+
+export const GetPublicFromPrivate = (privateKey: string): string => {
+  const privateKeyDer = PrivateToDer(privateKey);
+  const privateKeyObj = crypto.createPrivateKey({
+    key: privateKeyDer,
+    format: 'der',
+    type: 'pkcs8',
+  });
+  const privateKeyString = privateKeyObj.export({ format: 'der', type: 'pkcs8' });
+  /*const publicKeyObj = crypto.createPublicKey({
+    key: privateKeyObj,
+    format: 'pem',
+    type: 'sec1',
+  });*/
+  const publicKeyObj = crypto.createPublicKey({
+    key: privateKeyString,
+    format: 'pem',
+    type: 'spki',
+  });
+  const encodedHex = publicKeyObj
+    .export({ format: 'der', type: 'spki' })
+    .toString('hex')
+    .toUpperCase();
+  if (encodedHex.startsWith(PUBLIC_KEY_PREFIX)) {
+    return encodedHex.substring(PUBLIC_KEY_PREFIX.length);
+  } else {
+    throw new Error(
+      `unknown prefix, expecting '${PUBLIC_KEY_PREFIX}' cannot decode public key '${encodedHex}'`
+    );
+  }
+};

package/src/core/ledger/Transaction-Transcode.ts

@@ -0,0 +1,56 @@
+'use strict';
+
+import { ScriptBuilder } from '../vm';
+import { Address } from '../types';
+import { Transaction } from '../tx/Transaction';
+
+/**
+ * Expiration Date is in UTC Seconds
+ * @param expirationDate
+ * @returns
+ */
+export const GetDateAsUTCSeconds = (expirationDate) => {
+  const expirationDateUTCms = Date.UTC(
+    expirationDate.getUTCFullYear(),
+    expirationDate.getUTCMonth(),
+    expirationDate.getUTCDate(),
+    expirationDate.getUTCHours(),
+    expirationDate.getUTCMinutes(),
+    expirationDate.getUTCSeconds()
+  );
+  return expirationDateUTCms / 1000;
+};
+
+/**
+ * Get Expiration Date
+ * @returns
+ */
+export const GetExpirationDate = () => {
+  // TODO: make expirationDate configurable.
+  const expirationMinutes = 5; // This is in minutes
+  const expirationDate = new Date(Date.now() + expirationMinutes * 60000);
+  return expirationDate;
+};
+
+/**
+ *
+ * @param transaction
+ * @returns
+ */
+export const EncodeSendTxWithSignature = (transaction) => {
+  // console.log('encodeSendTx', 'transaction', transaction);
+  const sendTx = transaction.toString(true);
+  // console.log('encodeSendTx', 'sendTx', sendTx);
+  return sendTx;
+};
+
+/**
+ *
+ * @param transaction
+ * @returns
+ */
+export const EncodeSendTxWithoutSignature = (transaction) => {
+  const sendTx = transaction.toString(false);
+  // console.log('encodeSendTx', 'sendTx', sendTx);
+  return sendTx;
+};

package/src/core/ledger/index.ts

@@ -0,0 +1,8 @@
+export * from './Mnemonic';
+export * from './Address-Transcode';
+export * from './interfaces/LedgerConfig';
+export * from './Ledger-Utils';
+export * from './Ledger-Commands';
+export * from './Transaction-Transcode';
+export * from './Transaction-Sign';
+export * from './interfaces/index';

package/src/core/ledger/interfaces/ApplicationNameResponse.ts

@@ -0,0 +1,5 @@
+export interface ApplicationNameResponse {
+  success: boolean;
+  message: string;
+  applicationName?: string;
+}

package/src/core/ledger/interfaces/Device.ts

@@ -0,0 +1,6 @@
+export interface Device {
+  enabled: boolean;
+  error?: boolean;
+  message?: string;
+  device?: any; // Define the type based on your device's type
+}

package/src/core/ledger/interfaces/DeviceResponse.ts

@@ -0,0 +1,6 @@
+export interface DeviceResponse {
+  enabled: boolean;
+  error: boolean;
+  message?: string;
+  device?: any; // Define the type based on your device's type
+}

package/src/core/ledger/interfaces/Ledger.ts

@@ -0,0 +1,10 @@
+import { Device } from './Device';
+
+interface ILedger {
+  device: Device;
+  publicKey: string;
+  address: string;
+  signature: string;
+  error?: boolean;
+  message?: string;
+}

package/src/core/ledger/interfaces/LedgerBalanceFromLedgerResponse.ts

@@ -0,0 +1,9 @@
+import { Address } from '../../types';
+
+export interface LedgerBalanceFromLedgerResponse {
+  success: boolean;
+  message: string;
+  publicKey?: string;
+  address?: Address;
+  balances?: Map<string, { amount: number; decimals: number }>;
+}

package/src/core/ledger/interfaces/LedgerConfig.ts

@@ -0,0 +1,17 @@
+import { PhantasmaAPI } from '../../rpc/phantasma';
+
+export interface LedgerConfig {
+  Debug: boolean;
+  Transport: any; // Replace 'any' with the actual type of transport
+  Bip39: any; // Replace 'any' with the actual type of bip39
+  Bip32Factory: any; // Replace 'any' with the actual type of bip32Factory
+  Curve: any; // Replace 'any' with the actual type of curve
+  NexusName: string;
+  ChainName: string;
+  Payload: string;
+  TokenNames: string[];
+  RPC: PhantasmaAPI;
+  GasPrice: number;
+  GasLimit: number;
+  VerifyResponse: boolean;
+}

package/src/core/ledger/interfaces/LedgerDeviceInfoResponse.ts

@@ -0,0 +1,7 @@
+import { VersionResponse } from './VersionResponse';
+import { ApplicationNameResponse } from './ApplicationNameResponse';
+
+export interface LedgerDeviceInfoResponse {
+  version: VersionResponse;
+  applicationName: ApplicationNameResponse;
+}

package/src/core/ledger/interfaces/LedgerSendTransactionResponse.ts

@@ -0,0 +1,4 @@
+export interface LedgerSendTransactionResponse {
+  success: boolean;
+  message: string;
+}

package/src/core/ledger/interfaces/LedgerSigner.ts

@@ -0,0 +1,6 @@
+import { Address } from '../../types';
+
+export interface LedgerSigner {
+  GetPublicKey: () => string;
+  GetAccount: () => Address;
+}

package/src/core/ledger/interfaces/LedgerSignerData.ts

@@ -0,0 +1,8 @@
+import { Address } from '../../types';
+
+export interface LedgerSignerData {
+  success: boolean;
+  message: string;
+  publicKey?: string;
+  address?: Address;
+}

package/src/core/ledger/interfaces/PublicKeyResponse.ts

@@ -0,0 +1,5 @@
+export interface PublicKeyResponse {
+  success: boolean;
+  message: string;
+  publicKey?: string;
+}

package/src/core/ledger/interfaces/SignResponse.ts

@@ -0,0 +1,5 @@
+export interface SignResponse {
+  success: boolean;
+  message: string;
+  signature?: string;
+}

package/src/core/ledger/interfaces/VersionResponse.ts

@@ -0,0 +1,5 @@
+export interface VersionResponse {
+  success: boolean;
+  message: string;
+  version?: string;
+}

package/src/core/ledger/interfaces/index.ts

@@ -0,0 +1,13 @@
+export * from './ApplicationNameResponse';
+export * from './Device';
+export * from './DeviceResponse';
+export * from './Ledger';
+export * from './LedgerConfig';
+export * from './LedgerDeviceInfoResponse';
+export * from './PublicKeyResponse';
+export * from './SignResponse';
+export * from './VersionResponse';
+export * from './LedgerBalanceFromLedgerResponse';
+export * from './LedgerSigner';
+export * from './LedgerSignerData';
+export * from './LedgerSendTransactionResponse';

package/src/core/link/easyConnect.ts

@@ -0,0 +1,214 @@
+import { PhantasmaLink } from './phantasmaLink';
+import { ProofOfWork } from './interfaces/ProofOfWork';
+import { EasyScript, Nexus } from './easyScript';
+
+export class EasyConnect {
+  requiredVersion: number;
+  platform: string;
+  providerHint: string;
+  link: PhantasmaLink;
+  connected: boolean;
+  script: EasyScript;
+  nexus: Nexus;
+
+  constructor(_options: Array<string> = null) {
+    this.platform = 'phantasma';
+    this.providerHint = 'poltergeist';
+    this.script = new EasyScript();
+    this.link = new PhantasmaLink('easyConnect', false);
+    this.connected = false;
+    this.requiredVersion = 2;
+
+    //Make This Auto In Future
+    this.nexus = Nexus.Mainnet;
+
+    if (_options == null) {
+      this.setConfig('auto');
+    } else {
+      try {
+        this.requiredVersion = Number(_options[0]);
+        this.platform = _options[1];
+        this.providerHint = _options[2];
+      } catch (error) {
+        console.log(error);
+      }
+    }
+    this.script = new EasyScript();
+  }
+
+  setConfig(_provider: string) {
+    this.requiredVersion = 2;
+    this.platform = 'phantasma';
+
+    switch (_provider) {
+      case 'auto':
+        // @ts-ignore
+        if (!!window.PhantasmaLinkSocket == true) {
+          this.setConfig('ecto');
+        } else {
+          this.providerHint = '';
+        }
+        break;
+
+      case 'ecto':
+        this.providerHint = 'ecto';
+        break;
+
+      case 'poltergeist':
+        this.providerHint = 'poltergeist';
+        break;
+    }
+  }
+
+  connect(
+    onSuccess: any = (data) => {},
+    onFail: any = (data) => {
+      console.log('%cError: ' + data, 'color:red');
+    }
+  ) {
+    let that = this;
+
+    this.link.login(
+      function (data) {
+        //Console Logging for Debugging Purposes
+        if (data) {
+          that.connected = true;
+          onSuccess(data);
+          console.log('%c[EasyConnect Connected]', 'color:green');
+          console.log(
+            "Wallet Address '" + that.link.account.address + "' connected via " + that.link.wallet
+          );
+        } else {
+          onFail();
+          console.log('EasyConnect could not connect to wallet');
+        }
+      },
+      onFail,
+      this.requiredVersion,
+      this.platform,
+      this.providerHint
+    );
+  }
+
+  disconnect(_message: string = 'Graceful Disconect') {
+    this.link.disconnect(_message);
+    this.connected = false;
+  }
+
+  async query(
+    _type: string = null,
+    _arguments: Array<string> = null,
+    _callback: any = (data) => {
+      console.log(data);
+    }
+  ) {
+    if (this.connected == true) {
+      switch (_type) {
+        case 'account':
+          let account = this.link.account;
+          _callback(account);
+          return account;
+          break;
+
+        case 'name':
+          let name = this.link.account.name;
+          _callback(name);
+          return name;
+          break;
+
+        case 'balances':
+          let balances = this.link.account.balances;
+          _callback(balances);
+          return balances;
+          break;
+
+        case 'walletAddress':
+          let walletAddress = this.link.account.address;
+          _callback(walletAddress);
+          return walletAddress;
+          break;
+
+        case 'avatar':
+          let avatar = this.link.account.avatar;
+          _callback(avatar);
+          return avatar;
+          break;
+
+        case 'tokenBalance':
+          //let token = _arguments[0];
+          //return this.link.accounts[]
+          break;
+      }
+    } else {
+      console.log('%cWallet is not connected', 'color:red');
+    }
+  }
+
+  async action(
+    _type: string = null,
+    _arguments: Array<any> = null,
+    onSuccess: any = (data) => {},
+    onFail: any = (data) => {
+      console.log('%cError: ' + data, 'color:red');
+    }
+  ) {
+    if (this.connected == true) {
+      switch (_type) {
+        case 'sendFT':
+          let sendFTScript = await this.script.buildScript('interop', [
+            'Runtime.SendTokens',
+            [_arguments[0], _arguments[1], _arguments[2], _arguments[3]],
+          ]);
+          this.signTransaction(sendFTScript, null, onSuccess, onFail);
+          break;
+
+        case 'sendNFT':
+          let sendNFTScript = await this.script.buildScript('interop', [
+            'Runtime.SendTokens',
+            [_arguments[0], _arguments[1], _arguments[2], _arguments[3]],
+          ]);
+          this.signTransaction(sendNFTScript, null, onSuccess, onFail);
+          break;
+      }
+    } else {
+      console.log('%cWallet is not connected', 'color:red');
+    }
+  }
+
+  signTransaction(
+    script: string,
+    payload = null,
+    onSuccess: any = (data) => {},
+    onFail: any = (data) => {
+      console.log('%cError: ' + data, 'color:red');
+    }
+  ) {
+    this.link.signTx(script, payload, onSuccess, onFail);
+  }
+
+  signData(
+    data: any,
+    onSuccess: any = (data) => {},
+    onFail: any = (data) => {
+      console.log('%cError: ' + data, 'color:red');
+    }
+  ) {
+    this.link.signData(data, onSuccess, onFail);
+  }
+
+  invokeScript(script: string, _callback: any) {
+    this.link.invokeScript(script, _callback);
+  }
+
+  deployContract(
+    script: string,
+    payload = null,
+    proofOfWork: ProofOfWork = ProofOfWork.Minimal,
+    onSuccess: any = (data) => {},
+    onFail: any = (data) => {
+      console.log('%cError: ' + data, 'color:red');
+    }
+  ) {
+    this.link.signTx(script, payload, onSuccess, onFail, proofOfWork);
+  }
+}

package/src/core/link/easyScript.ts

@@ -0,0 +1,67 @@
+import { ScriptBuilder } from "../vm";
+
+export enum Nexus {
+  Mainnet = "mainnet",
+  Simnet = "simnet",
+  Testnet = "testnet",
+}
+
+export class EasyScript {
+  nexus: Nexus;
+  sb: ScriptBuilder;
+
+  constructor(nexus: Nexus = Nexus.Mainnet) {
+    this.sb = new ScriptBuilder();
+    this.nexus = nexus;
+  }
+
+  buildScript(_type: string, _options: Array<any> = [null]) {
+    this.sb = new ScriptBuilder();
+
+    switch (_type) {
+      case "interact":
+        let contractNameInteract: string = _options[0];
+        let methodNameInteract: string = _options[1];
+        let inputArgumentsInteract: Array<any> = _options[2];
+
+        return this.sb
+          .CallContract("gas", "AllowGas", [])
+          .CallContract(
+            contractNameInteract,
+            methodNameInteract,
+            inputArgumentsInteract
+          ) //The Meat of the Script
+          .CallContract("gas", "SpendGas", [])
+          .EndScript();
+
+        break;
+
+      case "invoke":
+        let contractNameInvoke: string = _options[0];
+        let methodNameInvoke: string = _options[1];
+        let inputArgumentsInvoke: Array<any> = _options[2];
+
+        return this.sb
+          .CallContract(
+            contractNameInvoke,
+            methodNameInvoke,
+            inputArgumentsInvoke
+          ) //The Meat of the Script
+          .EndScript();
+
+        break;
+
+      case "interop":
+        let interopNameInterop: string = _options[0];
+        let inputArgumentsInterop: Array<any> = _options[1];
+
+        return this.sb
+          .CallContract("gas", "AllowGas", [])
+          .CallInterop(interopNameInterop, inputArgumentsInterop)
+          .CallContract("gas", "SpendGas", [])
+          .EndScript();
+
+        break;
+    }
+  }
+}

package/src/core/link/index.ts

@@ -0,0 +1 @@
+export * from './interfaces';

package/src/core/link/interfaces/IAccount.ts

@@ -0,0 +1,13 @@
+import { Balance } from '../../rpc/interfaces/Balance';
+import { IFile } from './IFile';
+
+export interface IAccount {
+  alias: string;
+  name: string;
+  address: string;
+  avatar: string;
+  platform: string;
+  external: string;
+  balances: Balance[];
+  files: IFile[];
+}

package/src/core/link/interfaces/IFile.ts

@@ -0,0 +1,6 @@
+export interface IFile {
+  name: string;
+  hash: string;
+  size: number;
+  date: string;
+}

package/src/core/link/interfaces/ProofOfWork.ts

@@ -0,0 +1,8 @@
+export enum ProofOfWork {
+  None = 0,
+  Minimal = 5,
+  Moderate = 15,
+  Hard = 19,
+  Heavy = 24,
+  Extreme = 30,
+}

package/src/core/link/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './IFile';
+export * from './IAccount';
+export * from './ProofOfWork';