phantasma-sdk-ts 0.1.71

package/src/core/vm/VMType.ts

@@ -0,0 +1,11 @@
+export enum VMType {
+  None,
+  Struct,
+  Bytes,
+  Number,
+  String,
+  Timestamp,
+  Bool,
+  Enum,
+  Object,
+}

package/src/core/vm/index.ts

@@ -0,0 +1,7 @@
+export * from "./ScriptBuilder";
+export * from "./Contracts";
+export * from "./Opcode";
+export * from "./VMType";
+export * from "./EventData";
+export * from "./Decoder";
+export * from "./VMObject";

package/src/core/vm/utils/DisasmMethodCall.ts

@@ -0,0 +1,22 @@
+import { VMObject } from "../VMObject";
+
+export class DisasmMethodCall {
+  public ContractName: string;
+  public MethodName: string;
+  public Arguments: VMObject[];
+
+  public toString(): string {
+    const sb = Array<string>();
+    sb.push(`${this.ContractName}.${this.MethodName}(`);
+    for (let i = 0; i < this.Arguments.length; i++) {
+      if (i > 0) {
+        sb.push(",");
+      }
+
+      const arg = this.Arguments[i];
+      sb.push(arg.toString());
+    }
+    sb.push(")");
+    return sb.join("");
+  }
+}

package/src/core/vm/utils/DisasmUtils.ts

@@ -0,0 +1,89 @@
+import { IContract, NativeContractKind } from "../../interfaces";
+import { Stack } from "../../types";
+import { VMObject } from "../VMObject";
+
+export class DisasmUtils {
+  private static PopArgs(
+    contract: string,
+    method: string,
+    stack: Stack<VMObject>,
+    methodArgumentCountTable: { [key: string]: number }
+  ): VMObject[] {
+    let key = method;
+    if (contract != null) {
+      key = `${contract}.${method}`;
+    }
+
+    if (methodArgumentCountTable.hasOwnProperty(key)) {
+      let argCount = methodArgumentCountTable[key];
+      let result: Array<VMObject> = new Array<VMObject>(argCount);
+      for (let i = 0; i < argCount; i++) {
+        if (stack.size() == 0) {
+          throw new Error(
+            `Cannot disassemble method => method ${key} expected ${argCount} args, ${i} were fetched`
+          );
+        }
+        //result[i] = stack.pop();
+      }
+      return result;
+    } else {
+      throw new Error(`Cannot disassemble method => unknown name: ${key}`);
+    }
+  }
+
+  //private static _defaultDisasmTable = DisasmUtils.GetDefaultDisasmTable();
+
+  /*public static GetDefaultDisasmTable(): { [key: string]: number } {
+        if (DisasmUtils._defaultDisasmTable != null) {
+            return DisasmUtils._defaultDisasmTable;
+        }
+        let table: { [key: string]: number } = {};
+
+        ExtCalls.IterateExtcalls((methodName: string, argCount: number, method: any) => {
+            table[methodName] = argCount;
+        });
+
+        let nativeContracts = Enum.GetValues(NativeContractKind);
+        for (const kind of nativeContracts) {
+            if (kind == NativeContractKind.Unknown) {
+                continue;
+            }
+            let contract = NativeContract.GetNativeContractByKind(kind);
+            table.AddContractToTable(contract);
+        }
+
+        return table;
+    }
+
+    public static AddContractToTable(table: { [key: string]: number }, contract: IContract) {
+        let abi = contract.ABI;
+
+        for (const method of abi.Methods) {
+            let key = `${contract.Name}.${method.name}`;
+            table[key] = method.parameters.length;
+        }
+    }
+
+    public static AddTokenToTable(table: { [key: string]: number }, token: IToken) {
+        let abi = token.ABI;
+
+        for (const method of abi.Methods) {
+            let key = `${token.Symbol}.${method.name}`;
+            table[key] = method.parameters.length;
+        }
+    }
+
+    public static ExtractContractNames(disassembler: Disassembler): string[] {
+        let instructions = disassembler.Instructions.toArray();
+        let result = new Array<string>();
+
+        let index = 0;
+        let regs = new Array<VMObject>(16);
+        while (index < instructions.length) {
+            let instruction = instructions[index];
+
+            switch (instruction.Opcode) {
+                case Opcode.LOAD: {
+                    let dst = instruction.Args[0] as number;
+                    let type = instruction.Args*/
+}

package/src/core/vm/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./DisasmUtils";
+export * from "./DisasmMethodCall";

package/src/index.ts

@@ -0,0 +1,7 @@
+import TransportWebUSB from '@ledgerhq/hw-transport-webusb';
+
+export * from './core/index';
+export * as PhantasmaTS from './core/index';
+export { PhantasmaLink } from './core/link/phantasmaLink';
+export { EasyConnect } from './core/link/easyConnect';
+//const TransportWebUSB = require('@ledgerhq/hw-transport-webusb').default;

package/tests/VMObject.test.ts

@@ -0,0 +1,146 @@
+import { BinaryReader, BinaryWriter } from "csharp-binary-stream";
+import { Type } from "typescript";
+import {
+  Base16,
+  PBinaryWriter,
+  PollChoice,
+  Serialization,
+  Timestamp,
+  Transaction,
+  VMObject,
+  VMType,
+} from "../core";
+
+describe("VM index file", () => {
+  test("empty string should result in zero", () => {
+    let vm = new VMObject();
+
+    expect(vm).toBeInstanceOf(VMObject);
+    expect(vm.Type).toBe(VMType.None);
+  });
+
+  test("String VM", () => {
+    let vm = new VMObject();
+    let myNewVM = VMObject.FromObject("MyString");
+
+    expect(myNewVM).toBeInstanceOf(VMObject);
+    expect(myNewVM.Type).toBe(VMType.String);
+    let result = myNewVM.AsString();
+    expect(result).toBe("MyString");
+  });
+
+  test("Number VM", () => {
+    let vm = new VMObject();
+    let myNewVM = VMObject.FromObject(5);
+
+    expect(myNewVM).toBeInstanceOf(VMObject);
+    expect(myNewVM.Type).toBe(VMType.Number);
+    let result = myNewVM.AsString();
+    expect(result).toBe("5");
+    expect(myNewVM.AsNumber()).toBe(5);
+  });
+
+  /*test("Bool VM", () => {
+    let vm = new phantasmaJS.VMObject();
+    let myNewVM = VMObject.FromObject(true);
+
+    expect(myNewVM).toBeInstanceOf(phantasmaJS.VMObject);
+    expect(myNewVM.Type).toBe(phantasmaJS.VMType.Bool);
+    expect(myNewVM.AsString()).toBe("true");
+    expect(myNewVM.AsBool()).toBe(true);
+  });
+
+  test("Struct VM", () => {
+    let vm = new phantasmaJS.VMObject();
+    let choice = new phantasmaJS.PollChoice("myChoice");
+    let myNewVM = VMObject.FromStruct(choice);
+
+    expect(myNewVM).toBeInstanceOf(phantasmaJS.VMObject);
+    expect(myNewVM.Type).toBe(phantasmaJS.VMType.Struct);
+    let result = myNewVM.ToStruct(PollChoice) as PollChoice;
+    expect(result).toStrictEqual(choice);
+  });
+
+  test("TestTypes", () => {
+    let vm = new phantasmaJS.VMObject();
+    let choice = new phantasmaJS.PollChoice("myChoice");
+    let myNewVM = VMObject.FromStruct(choice);
+
+    expect(VMObject.isPrimitive(PollChoice)).toBe(false);
+    expect(VMObject.isValueType(PollChoice)).toBe(false);
+    expect(VMObject.isClass(PollChoice)).toBe(true);
+    expect(VMObject.isEnum(PollChoice)).toBe(false);
+    expect(VMObject.isSerializable(PollChoice)).toBe(true);
+    expect(VMObject.isInterface(PollChoice)).toBe(false);
+    expect(VMObject.isStructOrClass(PollChoice as unknown as Type)).toBe(true);
+    expect(myNewVM.Type).toBe(phantasmaJS.VMType.Struct);
+  });*/
+
+  test("PollChoices", () => {
+    let vm = new VMObject();
+    let choice = new PollChoice("myChoice");
+    let choice2 = new PollChoice("myChoice");
+    let choices: PollChoice[] = [choice, choice2];
+    let myNewVM = VMObject.FromArray(choices);
+
+    expect(myNewVM).toBeInstanceOf(VMObject);
+    expect(myNewVM.Type).toBe(VMType.Struct);
+    //let result = myNewVM.ToArray(PollChoice) as PollChoice[];
+    //expect(result).toStrictEqual(choices);
+  });
+
+  test("Serialization", () => {
+    let vm = new VMObject();
+    let choice = new PollChoice("myChoice");
+    let choice2 = new PollChoice("myChoice");
+    let time = new Timestamp(10000);
+    let choices: PollChoice[] = [choice, choice2];
+
+    class myTestClass {
+      name: string = "test";
+      choices: PollChoice[] = choices;
+      time: Timestamp = time;
+      constructor() {}
+    }
+
+    let testClass = new myTestClass();
+
+    let choice1Serialized = Serialization.Serialize(testClass);
+    let choice1Deserialized = Serialization.Unserialize<myTestClass>(
+      choice1Serialized,
+      myTestClass
+    );
+
+    let myVM = VMObject.FromObject(choice1Serialized);
+    let writer = new PBinaryWriter();
+    let result = myVM.SerializeData(writer);
+
+    /*let choicesSerialized: Uint8Array[] = [
+      Serialization.Serialize(choice),
+      Serialization.Serialize(choice2),
+    ];
+    let myNewVM = VMObject.FromArray(choices);
+
+    expect(myNewVM).toBeInstanceOf(phantasmaJS.VMObject);
+    expect(myNewVM.Type).toBe(phantasmaJS.VMType.Struct);
+    let writer = new PBinaryWriter();
+    let result = myNewVM.SerializeData(writer);
+    expect(writer.toArray()).toStrictEqual(choices);*/
+  });
+
+  test("Serialization2", () => {
+    let choice = new PollChoice("myChoice");
+    let choice2 = new PollChoice("myChoice");
+    let choices: PollChoice[] = [choice, choice2];
+    let choicesSerialized = Serialization.Serialize(choices);
+  });
+
+  test("DecodeBool", () => {
+    let vmCode = "0601";
+    let bytes = Base16.decodeUint8Array(vmCode);
+    let vm = VMObject.FromBytes(bytes);
+
+    expect(vm.Type).toBe(VMType.Bool);
+    expect(vm.AsBool()).toBe(true);
+  });
+});

package/tests/ledger/Address-Transacode.test.ts

@@ -0,0 +1,26 @@
+import {} from '../..';
+import crypto from 'crypto';
+import wif from 'wif';
+import {
+  Address,
+  ConsensusMode,
+  encodeBase16,
+  generateNewWif,
+  getAddressFromWif,
+  getPrivateKeyFromWif,
+  getWifFromPrivateKey,
+  PhantasmaKeys,
+  PollChoice,
+  Serialization,
+  Timestamp,
+  VMObject,
+} from '../../core';
+
+describe('Address Transcode', () => {
+  test('Get a new address', () => {
+    const privateKey = crypto.randomBytes(32).toString('hex').toUpperCase();
+    const walletWif = wif.encode(128, Buffer.from(privateKey, 'hex'), true);
+    //const expectedAddress = phantasmaJS.getAddressFromWif(walletWif);
+    //const actualAddress = addressTranscodeUtil.getAddressFromPrivateKey(privateKey);
+  });
+});

package/tests/tx/Transaction.test.ts

@@ -0,0 +1,274 @@
+import Buffer from 'buffer';
+import { PollChoice } from '../../';
+import crypto from 'crypto';
+import {
+  Address,
+  Base16,
+  Ed25519Signature,
+  encodeBase16,
+  getAddressFromWif,
+  getWifFromPrivateKey,
+  PBinaryReader,
+  PBinaryWriter,
+  PhantasmaKeys,
+  ScriptBuilder,
+  Serialization,
+  stringToUint8Array,
+  Timestamp,
+  Transaction,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+  uint8ArrayToStringDefault,
+  VMObject,
+  VMType,
+} from '../../core';
+
+describe('test phantasma_ts', function () {
+  test('test phantasma-ts.Transaction.SerializeData', function (done) {
+    let writer = new PBinaryWriter();
+    let keys = PhantasmaKeys.generate();
+
+    let nexusName = 'nexus';
+    let chainName = 'main';
+    let script = 'script';
+    let expiration = new Date(17898129498);
+    let payload = 'payload';
+    let signatures = [new Ed25519Signature()];
+    writer.writeString(nexusName);
+    let tx = new Transaction(nexusName, chainName, script, expiration, payload);
+    tx.signWithKeys(keys);
+    tx.SerializeData(writer);
+    /*expect(writer.toUint8Array()).toBe([
+      5, 110, 101, 120, 117, 115, 5, 110, 101, 120, 117, 115, 5, 109, 97, 105,
+      110,
+    ]);*/
+    done();
+  });
+
+  test('sginature', function (done) {
+    let writer = new PBinaryWriter();
+    let keys = PhantasmaKeys.generate();
+
+    let wifTest = 'L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx';
+    let keyFromWif = PhantasmaKeys.fromWIF(wifTest);
+
+    expect(keyFromWif.toWIF()).toBe(wifTest);
+
+    let nexusName = 'nexus';
+    let chainName = 'main';
+    let script = 'script';
+    let expiration = new Date(17898129498);
+    let payload = 'payload';
+    let tx = new Transaction(nexusName, chainName, script, expiration, payload);
+
+    let wif = keys.toWIF();
+    let pk = uint8ArrayToHex(keys.PrivateKey);
+
+    tx.sign(wif);
+
+    tx.signWithPrivateKey(pk);
+
+    /*let wif = getWifFromPrivateKey(
+      uint8ArrayToString(Array.from(keys.PrivateKey) as Uint8Array)
+    );
+    let pk = uint8ArrayToString(Array.from(keys.PrivateKey));
+
+    console.log(wif, getAddressFromWif(wif), pk);
+
+    tx.sign(pk);
+    tx.SerializeData(writer);*/
+    done();
+  });
+
+  test('Test signature ts and c#', function (done) {
+    let nexusName = 'testnet';
+    let chainName = 'main';
+    let wif = 'L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx';
+    let uintArray = Uint8Array.from([0x01, 0x02, 0x03]);
+    let script = uint8ArrayToHex(uintArray);
+    let time = new Timestamp(1234567890);
+    let date = new Date(time.toString());
+    let payload = 'payload';
+    let keys = PhantasmaKeys.fromWIF(wif);
+    let tx = new Transaction(nexusName, chainName, script, date, payload);
+
+    tx.signWithKeys(keys);
+
+    let fromCsharp =
+      '07746573746E6574046D61696E03010203D2029649077061796C6F61640101404C033859A20A4FC2E469B3741FB05ACEDFEC24BFE92E07633680488665D79F916773FF40D0E81C4468E1C1487E6E1E6EEFDA5C5D7C53C15C4FB349C2349A1802';
+    let fromCsharpBytes = Buffer.Buffer.from(fromCsharp, 'hex');
+    let bytes = stringToUint8Array(fromCsharp);
+    let fromCsharpTx = Transaction.Unserialize(fromCsharpBytes);
+
+    expect(fromCsharpTx.chainName).toBe(tx.chainName);
+    expect(fromCsharpTx.nexusName).toBe(tx.nexusName);
+    expect(fromCsharpTx.script).toBe(tx.script);
+    expect(fromCsharpTx.payload).toBe(Base16.encode(tx.payload));
+    expect(fromCsharpTx.expiration).toStrictEqual(tx.expiration);
+    expect(fromCsharpTx.signatures.length).toBe(tx.signatures.length);
+    expect(fromCsharpTx.signatures[0].Kind).toBe(tx.signatures[0].Kind);
+    expect(fromCsharpTx.signatures[0].ToByteArray()).toStrictEqual(tx.signatures[0].ToByteArray());
+
+    done();
+  });
+
+  test('Transaction Serialized to bytes', function (done) {
+    let nexusName = 'testnet';
+    let chainName = 'main';
+    let subject = 'system.nexus.protocol.version';
+    let wif = 'L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx';
+    let mode = 1;
+    let choice = new PollChoice('myChoice');
+    let choice2 = new PollChoice('myChoice');
+    let choices = [choice, choice2];
+    let choicesSerialized = Serialization.Serialize(choices);
+    let time = new Timestamp(1234567890);
+    let date = new Date(time.toString());
+    let startTime = time;
+    let endTime = new Timestamp(time.value + 86400);
+    let payload = Base16.encode('Consensus'); // hex string
+
+    let keys = PhantasmaKeys.fromWIF(wif);
+    let sb = new ScriptBuilder();
+
+    let gasLimit = 10000;
+    let gasPrice = 210000;
+
+    let script = sb
+      .AllowGas(keys.Address, Address.Null, gasLimit, gasPrice)
+      .CallContract('consensus', 'SingleVote', [keys.Address.Text, subject, 0])
+      .SpendGas(keys.Address)
+      .EndScript();
+
+    expect(script).toBe(
+      '0D00030350340303000D000302102703000D000223220000000000000000000000000000000000000000000000000000000000000000000003000D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D000408416C6C6F7747617303000D0004036761732D00012E010D0003010003000D00041D73797374656D2E6E657875732E70726F746F636F6C2E76657273696F6E03000D00042F50324B464579466576705166536157384734566A536D6857555A585234517247395951523148624D7054554370434C03000D00040A53696E676C65566F746503000D000409636F6E73656E7375732D00012E010D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D0004085370656E6447617303000D0004036761732D00012E010B'
+    );
+
+    let tx = new Transaction(nexusName, chainName, script, date, payload);
+
+    tx.signWithKeys(keys);
+
+    expect(uint8ArrayToHex(tx.ToByteAray(true)).toUpperCase()).toBe(
+      '07746573746E6574046D61696EFD42010D00030350340303000D000302102703000D000223220000000000000000000000000000000000000000000000000000000000000000000003000D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D000408416C6C6F7747617303000D0004036761732D00012E010D0003010003000D00041D73797374656D2E6E657875732E70726F746F636F6C2E76657273696F6E03000D00042F50324B464579466576705166536157384734566A536D6857555A585234517247395951523148624D7054554370434C03000D00040A53696E676C65566F746503000D000409636F6E73656E7375732D00012E010D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D0004085370656E6447617303000D0004036761732D00012E010BD202964909436F6E73656E737573010140F1C0410D49A5EDF0945B0EE9FAFDF6CA1FC315118D545E07824BEF1BA1F00881C29419648FD0B8200A356D21FAF45C60F4B77279D931CE4D732F5896E93BFE0D'
+    );
+    done();
+  });
+
+  test('New MultiSig Tests', function (done) {
+    let keys = PhantasmaKeys.fromWIF('L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx');
+    let nexusName = 'testnet';
+    let chainName = 'main';
+    let subject = 'teste';
+    let listOfUsers: Array<string> = [
+      keys.Address.Text,
+      'P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL',
+    ];
+
+    let time = new Timestamp(1234567890);
+    let date = new Date(time.toString());
+    let payload = Base16.encode(subject); // hex string
+    var transaction = new Transaction(nexusName, chainName, '', date, payload);
+
+    let gasLimit = 100000;
+    let gasPrice = 210000;
+    let txBytes = '';
+    let sb = new ScriptBuilder();
+
+    expect(Base16.encodeUint8Array(transaction.ToByteAray(false))).toBe(
+      '07746573746E6574046D61696E00D2029649057465737465'
+    );
+
+    let script = sb
+      //.AllowGas(keys.Address, Address.Null, gasLimit, gasPrice)
+      .CallContract('consensus', 'CreateTransaction', [1, listOfUsers])
+      //.SpendGas(keys.Address)
+      .EndScript();
+
+    expect(script).toBe(
+      '0E0000000D01042F50324B464579466576705166536157384734566A536D6857555A585234517247395951523148624D7054554370434C0D020301002F0100020D01042F50324B464579466576705166536157384734566A536D6857555A585234517247395951523148624D7054554370434C0D020301012F01000203000D0003010103000D0004114372656174655472616E73616374696F6E03000D000409636F6E73656E7375732D00012E010B'
+    );
+
+    done();
+  });
+
+  test('New MultiSig With addressTests', function (done) {
+    let keys = PhantasmaKeys.fromWIF('L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx');
+    let nexusName = 'testnet';
+    let chainName = 'main';
+    let subject = 'teste';
+    let listOfUsers: Array<string> = [
+      'P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL',
+      'P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL',
+    ];
+
+    const listUserAddr = listOfUsers.map((user) => Address.FromText(user));
+
+    let time = new Timestamp(1234567890);
+    let date = new Date(time.toString());
+    let payload = Base16.encode(subject); // hex string
+    var transaction = new Transaction(nexusName, chainName, '', date, payload);
+
+    let gasLimit = 100000;
+    let gasPrice = 210000;
+    //let txBytes = transaction.SerializeData();
+    let sb = new ScriptBuilder();
+
+    expect(Base16.encodeUint8Array(transaction.ToByteAray(false))).toBe(
+      '07746573746E6574046D61696E00D2029649057465737465'
+    );
+
+    expect(Base16.encodeUint8Array(Serialization.Serialize(transaction))).toBe(
+      '07746573746E6574046D61696E00D202964905746573746500'
+    );
+
+    let script = sb
+      .AllowGas(keys.Address, Address.Null, gasLimit, gasPrice)
+      .CallContract('consensus', 'CreateTransaction', [
+        keys.Address.Text,
+        subject,
+        Serialization.Serialize(transaction),
+        listUserAddr,
+      ])
+      .SpendGas(keys.Address)
+      .EndScript();
+
+    expect(script).toBe(
+      '0D00030350340303000D000303A0860103000D000223220000000000000000000000000000000000000000000000000000000000000000000003000D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D000408416C6C6F7747617303000D0004036761732D00012E010E0000000D010223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB48950D020301002F0100020D010223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB48950D020301012F01000203000D00021907746573746E6574046D61696E00D20296490574657374650003000D000405746573746503000D00042F50324B464579466576705166536157384734566A536D6857555A585234517247395951523148624D7054554370434C03000D0004114372656174655472616E73616374696F6E03000D000409636F6E73656E7375732D00012E010D000223220100AA53BE71FC41BC0889B694F4D6D03F7906A3D9A21705943CAF9632EEAFBB489503000D0004085370656E6447617303000D0004036761732D00012E010B'
+    );
+
+    done();
+  });
+  test('SimpleScript', function (done) {
+    let keys = PhantasmaKeys.fromWIF('L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx');
+
+    let sb = new ScriptBuilder();
+
+    let script = sb
+      .CallContract('stake', 'Stake', [keys.Address.Text, keys.Address.Text])
+      .EndScript();
+
+    done();
+  });
+
+  test('Test ScriptBuilder', function (done) {
+    let keys = PhantasmaKeys.fromWIF('L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx');
+
+    let sb = new ScriptBuilder();
+
+    let amount = 10000000;
+    let script = sb
+      .AllowGas(keys.Address.Text, Address.NullText, 10000, 21000)
+      .CallInterop('Runtime.TransferTokens', [
+        keys.Address.Text,
+        keys.Address.Text,
+        'SOUL',
+        String(amount),
+      ])
+      .SpendGas(keys.Address.Text)
+      .EndScript();
+
+    console.log('script', script);
+
+    done();
+  });
+});

package/tests/types/Address.test.ts

@@ -0,0 +1,26 @@
+import { Address, PhantasmaKeys } from "../../core";
+
+describe("test Addresses", function () {
+  test("test address", function (done) {
+    let wif = "L5UEVHBjujaR1721aZM5Zm5ayjDyamMZS9W35RE9Y9giRkdf3dVx";
+    let keys = PhantasmaKeys.fromWIF(wif);
+    let address = keys.Address;
+
+    expect(address.Text).toBe(
+      "P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL"
+    );
+
+    done();
+  });
+
+  test("test address from text", function (done) {
+    let addr = Address.FromText(
+      "P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL"
+    );
+    let address = addr.Text;
+
+    expect(address).toBe("P2KFEyFevpQfSaW8G4VjSmhWUZXR4QrG9YQR1HbMpTUCpCL");
+
+    done();
+  });
+});

package/tests/types/Consensus.test.ts

@@ -0,0 +1,67 @@
+import {
+  Base16,
+  ConsensusPoll,
+  hexStringToUint8Array,
+  PBinaryReader,
+  PollValue,
+  Serialization,
+  stringToUint8Array,
+  uint8ArrayToString,
+  uint8ArrayToStringDefault,
+  VMObject,
+} from "../../core";
+
+describe("Consensus Tests", () => {
+  test("Consensus Array Unserialize", function (done) {
+    const SerializeData =
+      "010203010008B401020301000850166E657875732E70726F746F636F6C2E76657273696F6E0A76616C696461746F7273010102000000013903FFFFFF03F4010002313003FFFFFF010002010027E1CF638B3FD16302010002050080C613000302010008571D73797374656D2E6E657875732E70726F746F636F6C2E76657273696F6E0A76616C696461746F7273010102000000013903FFFFFF03F4010002313003FFFFFF01000201005550D163D5A1D26302010002050080C613000302010008B401020301000850166E657875732E70726F746F636F6C2E76657273696F6E0A76616C696461746F7273010102000000013903FFFFFF03F4010002313003FFFFFF010002010027E1CF638B3FD16302010002050080C613000302010008571D73797374656D2E6E657875732E70726F746F636F6C2E76657273696F6E0A76616C696461746F7273010102000000013903FFFFFF03F4010002313003FFFFFF01000201005550D163D5A1D26302010002050080C61300";
+
+    /*const arrayBytes = Base16.decodeUint8Array(SerializeData);
+    const readerVM = new PBinaryReader(arrayBytes);
+    const vm = new VMObject();
+    vm.UnserializeData(readerVM);
+    for (let map of vm.GetChildren()![1]) {
+      console.log(map[0], " - ", map[1]);
+      let lBytes = Base16.decodeUint8Array(
+        uint8ArrayToStringDefault(map[1].AsByteArray())
+      );
+    }*/
+
+    //const consensus = Serialization.Unserialize(reader, Array<ConsensusPoll>);
+    //console.log(arrayBytes);
+    done();
+  });
+
+  test("Consensus Single Unserialize", function (done) {
+    const SerializeData =
+      "010B04077375626A656374041D73797374656D2E6E657875732E70726F746F636F6C2E76657273696F6E040C6F7267616E697A6174696F6E040A76616C696461746F727304046D6F646507010405737461746507010407656E74726965730102030100080A013903FFFFFF03F4010003020100080902313003FFFFFF01000405726F756E64030201000409737461727454696D65055550D1630407656E6454696D6505D5A1D263040E63686F696365735065725573657203020100040A746F74616C566F74657303020500040D636F6E73656E73757354696D650580C61300";
+
+    const arrayBytes = Base16.decodeUint8Array(SerializeData);
+    const vm = new VMObject();
+    const readerVM = new PBinaryReader(arrayBytes);
+    vm.UnserializeData(readerVM);
+    let con = vm.ToStruct<ConsensusPoll>(ConsensusPoll);
+    con.entries.forEach((entry) => {
+      //console.log(entry);
+      let entryValue = entry as unknown as string;
+      let pollValueBytes = Base16.decodeUint8Array(entryValue);
+      let pollValue = new PollValue();
+      let reader = new PBinaryReader(pollValueBytes);
+      pollValue.UnserializeData(reader);
+      //console.log(pollValue);
+
+      //pollValue.UnserializeData(reader);
+
+      //console.log(reader.read());
+    });
+    expect(con.subject).toBe("system.nexus.protocol.version");
+    expect(con.organization).toBe("validators");
+    expect(con.mode).toBe(1);
+    expect(con.state).toBe(1);
+    expect(con.startTime.value).toBe(1674661973);
+    expect(con.endTime.value).toBe(1674748373);
+    expect(con.choicesPerUser).toBe(1);
+    expect(con.totalVotes).toBe(5);
+    done();
+  });
+});