phantasma-sdk-ts 0.1.71

package/src/core/types/Consensus.ts

@@ -0,0 +1,181 @@
+import { Encoding } from "csharp-binary-stream";
+import { ISerializable } from "../interfaces";
+import {
+  byteArrayToHex,
+  stringToUint8Array,
+  uint8ArrayToBytes,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+} from "../utils";
+import { Base16, PBinaryReader, PBinaryWriter } from "./Extensions";
+import { Timestamp } from "./Timestamp";
+
+export enum ConsensusMode {
+  Unanimity,
+  Majority,
+  Popularity,
+  Ranking,
+}
+
+export enum PollState {
+  Inactive,
+  Active,
+  Consensus,
+  Failure,
+}
+
+export class PollChoice implements ISerializable {
+  public value: string; // Should be byte[]
+
+  public constructor(value: string | number[]) {
+    if (value instanceof Array)
+      this.value = Base16.decode(byteArrayToHex(value));
+    else this.value = value;
+  }
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeByteArray(stringToUint8Array(this.value));
+  }
+
+  UnserializeData(reader: PBinaryReader) {
+    this.value = Base16.decode(reader.readByteArray());
+  }
+
+  static Unserialize(reader: PBinaryReader): PollChoice {
+    let pollChoice = new PollChoice("");
+    pollChoice.UnserializeData(reader);
+    return pollChoice;
+  }
+}
+
+export class PollValue implements ISerializable {
+  public value: string; // Should be byte[]
+  public ranking: BigInt;
+  public votes: BigInt;
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeByteArray(stringToUint8Array(this.value));
+    writer.writeBigInteger(this.ranking);
+    writer.writeBigInteger(this.votes);
+  }
+
+  UnserializeData(reader: PBinaryReader) {
+    this.value = Base16.decode(reader.readByteArray());
+    this.ranking = reader.readBigInteger();
+    this.votes = reader.readBigInteger();
+  }
+
+  static Unserialize(reader: PBinaryReader): PollValue {
+    let pollValue = new PollValue();
+    pollValue.UnserializeData(reader);
+    return pollValue;
+  }
+}
+
+export class PollVote implements ISerializable {
+  public index: BigInt;
+  public percentage: BigInt;
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeBigInteger(this.index);
+    writer.writeBigInteger(this.percentage);
+  }
+  UnserializeData(reader: PBinaryReader) {
+    this.index = reader.readBigInteger();
+    this.percentage = reader.readBigInteger();
+  }
+
+  static Unserialize(reader: PBinaryReader): PollVote {
+    let pollVote = new PollVote();
+    pollVote.UnserializeData(reader);
+    return pollVote;
+  }
+}
+
+export class ConsensusPoll implements ISerializable {
+  public subject: string;
+  public organization: string;
+  public mode: ConsensusMode;
+  public state: PollState;
+  public entries: PollValue[];
+  public round: BigInt;
+  public startTime: Timestamp;
+  public endTime: Timestamp;
+  public choicesPerUser: BigInt;
+  public totalVotes: BigInt;
+
+  constructor() {
+    this.subject = "";
+    this.organization = "";
+    this.mode = ConsensusMode.Unanimity;
+    this.state = PollState.Inactive;
+    this.entries = [];
+    this.round = BigInt(0);
+    this.startTime = Timestamp.null;
+    this.endTime = Timestamp.null;
+    this.choicesPerUser = BigInt(0);
+    this.totalVotes = BigInt(0);
+  }
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeString(this.subject);
+    writer.writeString(this.organization);
+    writer.writeByte(this.mode);
+    writer.writeByte(this.state);
+    writer.writeByte(this.entries.length);
+
+    this.entries.forEach((entry) => {
+      entry.SerializeData(writer);
+    });
+
+    writer.writeBigInteger(this.round);
+    writer.writeTimestamp(this.startTime);
+    writer.writeTimestamp(this.endTime);
+    writer.writeBigInteger(this.choicesPerUser);
+    writer.writeBigInteger(this.totalVotes);
+  }
+  UnserializeData(reader: PBinaryReader) {
+    this.subject = reader.readString();
+    this.organization = reader.readString();
+    this.mode = reader.readByte() as ConsensusMode;
+    this.state = reader.readByte() as PollState;
+
+    this.entries = [];
+    const entriesLength = reader.readUnsignedInt();
+    for (let i = 0; i < entriesLength; i++) {
+      this.entries.push(PollValue.Unserialize(reader));
+    }
+
+    this.round = reader.readBigInteger();
+    this.startTime = reader.readTimestamp();
+    this.endTime = reader.readTimestamp();
+    this.choicesPerUser = reader.readBigInteger();
+    this.totalVotes = reader.readBigInteger();
+  }
+
+  static Unserialize(reader: PBinaryReader): ConsensusPoll {
+    let consensusPoll = new ConsensusPoll();
+    consensusPoll.UnserializeData(reader);
+    return consensusPoll;
+  }
+}
+
+export class PollPresence implements ISerializable {
+  public subject: string;
+  public round: BigInt;
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeString(this.subject);
+  }
+
+  UnserializeData(reader: PBinaryReader) {
+    this.subject = reader.readString();
+    this.round = reader.readBigInteger();
+  }
+
+  static Unserialize(reader: PBinaryReader): PollPresence {
+    let pollPresence = new PollPresence();
+    pollPresence.UnserializeData(reader);
+    return pollPresence;
+  }
+}

package/src/core/types/Contract.ts

@@ -0,0 +1,324 @@
+import { ISerializable } from "../interfaces";
+import { VMType } from "../vm/VMType";
+import { BinaryReader, BinaryWriter, Encoding } from "csharp-binary-stream";
+import {
+  arrayNumberToUint8Array,
+  stringToUint8Array,
+  uint8ArrayToNumberArray,
+  uint8ArrayToString,
+} from "../utils";
+import { TokenTrigger } from "./DomainSettings";
+import { PBinaryReader, PBinaryWriter } from "./Extensions";
+
+export class ContractParameter {
+  name: string;
+  type: VMType;
+
+  constructor(name: string, type: VMType) {
+    this.name = name;
+    this.type = type;
+  }
+}
+
+export class ContractInterface implements ISerializable {
+  public static readonly Empty: ContractInterface = new ContractInterface(
+    [],
+    []
+  );
+  private _methods = new Map<string, ContractMethod>();
+  public Methods = Array.from(this._methods.values());
+  public MethodCount = this._methods.size;
+
+  private _events: ContractEvent[];
+  public Events(): ContractEvent[] {
+    return this._events;
+  }
+
+  public EventCount() {
+    return this._events.length;
+  }
+
+  public newEmpty() {
+    this._methods = new Map<string, ContractMethod>();
+    this._events = [];
+  }
+
+  public constructor(methods: ContractMethod[], events: ContractEvent[]) {
+    for (const entry of methods) {
+      this._methods.set(entry.name, entry);
+    }
+    this._events = events;
+  }
+
+  public get(name: string): ContractMethod | null {
+    return this.FindMethod(name);
+  }
+  public HasMethod(name: string): boolean {
+    return this._methods.has(name);
+  }
+
+  public HasTokenTrigger(trigger: TokenTrigger): boolean {
+    const strName = trigger.toString();
+    const name = strName[0].toLowerCase() + strName.slice(1);
+    return this._methods.has(name);
+  }
+
+  public FindMethod(name: string): ContractMethod | null {
+    if (this._methods.has(name)) {
+      return this._methods.get(name);
+    }
+    return null;
+  }
+
+  public FindEvent(value: number): ContractEvent | null {
+    for (const evt of this._events) {
+      if (evt.value === value) {
+        return evt;
+      }
+    }
+    return null;
+  }
+
+  public ImplementsEvent(evt: ContractEvent): boolean {
+    for (const entry of this.Events()) {
+      if (
+        entry.name === evt.name &&
+        entry.value === evt.value &&
+        entry.returnType === evt.returnType
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public ImplementsMethod(method: ContractMethod): boolean {
+    if (!this._methods.has(method.name)) {
+      return false;
+    }
+    const thisMethod = this._methods.get(method.name);
+    if (thisMethod.parameters.length !== method.parameters.length) {
+      return false;
+    }
+
+    for (let i = 0; i < method.parameters.length; i++) {
+      if (thisMethod.parameters[i].type !== method.parameters[i].type) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  public ImplementsInterface(other: ContractInterface): boolean {
+    for (const method of other.Methods) {
+      if (!this.ImplementsMethod(method)) {
+        return false;
+      }
+    }
+
+    for (const evt of other.Events()) {
+      if (!this.ImplementsEvent(evt)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  public UnserializeData(reader: PBinaryReader): void {
+    const len = reader.readByte();
+    this._methods.clear();
+    for (let i = 0; i < len; i++) {
+      const method = ContractMethod.Unserialize(reader);
+      this._methods.set(method.name, method);
+    }
+    const eventLen = reader.readByte();
+    this._events = [];
+    for (let i = 0; i < eventLen; i++) {
+      this._events.push(ContractEvent.Unserialize(reader));
+    }
+  }
+  public SerializeData(writer: PBinaryWriter): void {
+    writer.writeByte(this._methods.size);
+    for (const [_, value] of this._methods) {
+      value.Serialize(writer);
+    }
+    writer.writeByte(this._events.length);
+    for (const entry of this._events) {
+      entry.Serialize(writer);
+    }
+  }
+}
+
+export class ContractMethod implements ISerializable {
+  public name: string;
+  public returnType: VMType;
+  public parameters: ContractParameter[];
+  public offset: number;
+
+  SerializeData(writer: PBinaryWriter) {
+    this.Serialize(writer);
+  }
+  UnserializeData(reader: PBinaryReader) {
+    return ContractMethod.Unserialize(reader);
+  }
+
+  public constructorOne(
+    name: string,
+    returnType: VMType,
+    labels: Map<string, number>,
+    parameters: ContractParameter[]
+  ) {
+    if (!labels.has(name)) {
+      throw new Error(`Missing offset in label map for method ${name}`);
+    }
+
+    const offset = labels.get(name);
+
+    this.name = name;
+    this.offset = offset;
+    this.returnType = returnType;
+    this.parameters = parameters;
+  }
+
+  constructor(
+    name: string,
+    returnType: VMType,
+    offset: number,
+    parameters: ContractParameter[]
+  ) {
+    this.name = name;
+    this.offset = offset;
+    this.returnType = returnType;
+    this.parameters = parameters;
+  }
+
+  public isProperty(): boolean {
+    if (
+      this.name.length >= 4 &&
+      this.name.startsWith("get") &&
+      this.name[3] === this.name[3].toUpperCase()
+    ) {
+      return true;
+    }
+
+    if (
+      this.name.length >= 3 &&
+      this.name.startsWith("is") &&
+      this.name[2] === this.name[2].toUpperCase()
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public isTrigger(): boolean {
+    if (
+      this.name.length >= 3 &&
+      this.name.startsWith("on") &&
+      this.name[2] === this.name[2].toUpperCase()
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public toString(): string {
+    return `${this.name} : ${this.returnType}`;
+  }
+
+  public static fromBytes(bytes: Uint8Array): ContractMethod {
+    const stream = new Uint8Array(bytes);
+    const reader = new PBinaryReader(stream);
+    return ContractMethod.Unserialize(reader);
+  }
+
+  public static Unserialize(reader: PBinaryReader): ContractMethod {
+    const name = reader.readString();
+    const returnType = reader.readByte() as VMType;
+    const offset = reader.readInt();
+    const len = reader.readByte();
+    const parameters: ContractParameter[] = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const pName = reader.readString();
+      const pVMType = reader.readByte() as VMType;
+      parameters[i] = new ContractParameter(pName, pVMType);
+    }
+
+    return new ContractMethod(name, returnType, offset, parameters);
+  }
+
+  public Serialize(writer: PBinaryWriter): void {
+    writer.writeString(this.name);
+    writer.writeByte(this.returnType);
+    writer.writeInt(this.offset);
+    writer.writeByte(this.parameters.length);
+    this.parameters.forEach((entry) => {
+      writer.writeString(entry.name);
+      writer.writeByte(entry.type);
+    });
+  }
+
+  public toArray(): Uint8Array {
+    const stream = new Uint8Array();
+    const writer = new PBinaryWriter(stream);
+    this.Serialize(writer);
+    return stream;
+  }
+}
+
+export class ContractEvent implements ISerializable {
+  public readonly value: number;
+  public readonly name: string;
+  public readonly returnType: VMType;
+  public readonly description: Uint8Array;
+
+  constructor(
+    value: number,
+    name: string,
+    returnType: VMType,
+    description: Uint8Array
+  ) {
+    this.value = value;
+    this.name = name;
+    this.returnType = returnType;
+    this.description = description;
+  }
+
+  SerializeData(writer: PBinaryWriter) {
+    this.Serialize(writer);
+  }
+
+  UnserializeData(reader: PBinaryReader) {
+    return ContractEvent.Unserialize(reader);
+  }
+
+  public toString(): string {
+    return `${this.name} : ${this.returnType} => ${this.value}`;
+  }
+
+  public static Unserialize(reader: PBinaryReader): ContractEvent {
+    const value = reader.readByte();
+    const name = reader.readString();
+    const returnType = reader.readByte() as VMType;
+    const description = reader.readBytes(reader.readByte());
+
+    return new ContractEvent(
+      value,
+      name,
+      returnType,
+      arrayNumberToUint8Array(description)
+    );
+  }
+
+  public Serialize(writer: PBinaryWriter): void {
+    writer.writeByte(this.value);
+    writer.writeString(this.name);
+    writer.writeByte(this.returnType);
+    writer.writeByte(this.description.length);
+    writer.writeBytes(uint8ArrayToNumberArray(this.description));
+  }
+}

package/src/core/types/DomainSettings.ts

@@ -0,0 +1,128 @@
+import { Address } from './Address';
+import { Timestamp } from './Timestamp';
+
+export enum TriggerResult {
+  Failure,
+  Missing,
+  Success,
+}
+
+export enum AccountTrigger {
+  OnMint, // address, symbol, amount
+  OnBurn, // address, symbol, amount
+  OnSend, // address, symbol, amount
+  OnReceive, // address, symbol, amount
+  OnWitness, // address
+  OnUpgrade, // address
+  OnMigrate, // from, to
+  OnKill, // address
+}
+
+export enum TokenTrigger {
+  OnMint, // address, symbol, amount
+  OnBurn, // address, symbol, amount
+  OnSend, // address, symbol, amount
+  OnReceive, // address, symbol, amount
+  OnInfuse, // address, symbol, amount
+  OnUpgrade, // address
+  OnSeries, // address
+  OnWrite, // address, data
+  OnMigrate, // from, to
+  OnKill, // address
+}
+
+export enum OrganizationTrigger {
+  OnAdd, // address
+  OnRemove, // address
+  OnUpgrade, // address
+}
+
+export class StakeReward {
+  staker: Address;
+  date: Timestamp;
+
+  constructor(staker: Address, date: Timestamp) {
+    this.staker = staker;
+    this.date = date;
+  }
+}
+
+export class DomainSettings {
+  public static LatestKnownProtocol = 18;
+
+  public static Phantasma20Protocol = 7;
+  public static Phantasma30Protocol = 8;
+
+  public static MaxTxPerBlock = 1024;
+
+  public static MaxOracleEntriesPerBlock = 5120;
+
+  public static MaxEventsPerBlock = 2048;
+
+  public static MaxEventsPerTx = 8096;
+
+  public static MaxTriggerLoop = 5;
+
+  public static MAX_TOKEN_DECIMALS = 18;
+
+  public static DefaultMinimumGasFee = 100000;
+  public static InitialValidatorCount = 4;
+
+  public static FuelTokenSymbol = 'KCAL';
+  public static FuelTokenName = 'Phantasma Energy';
+  public static FuelTokenDecimals = 10;
+
+  public static NexusMainnet = 'mainnet';
+  public static NexusTestnet = 'testnet';
+
+  public static StakingTokenSymbol = 'SOUL';
+  public static StakingTokenName = 'Phantasma Stake';
+  public static StakingTokenDecimals = 8;
+
+  public static FiatTokenSymbol = 'USD';
+  public static FiatTokenName = 'Dollars';
+  public static FiatTokenDecimals = 8;
+
+  public static RewardTokenSymbol = 'CROWN';
+  public static RewardTokenName = 'Phantasma Crown';
+
+  public static LiquidityTokenSymbol = 'LP';
+  public static LiquidityTokenName = 'Phantasma Liquidity';
+  public static LiquidityTokenDecimals = 8;
+
+  public static FuelPerContractDeployTag = 'nexus.contract.cost';
+  public static FuelPerTokenDeployTag = 'nexus.token.cost';
+  public static FuelPerOrganizationDeployTag = 'nexus.organization.cost';
+
+  public static SystemTokens = [
+    DomainSettings.FuelTokenSymbol,
+    DomainSettings.StakingTokenSymbol,
+    DomainSettings.FiatTokenSymbol,
+    DomainSettings.RewardTokenSymbol,
+    DomainSettings.LiquidityTokenSymbol,
+  ];
+
+  public static RootChainName = 'main';
+
+  public static ValidatorsOrganizationName = 'validators';
+  public static MastersOrganizationName = 'masters';
+  public static StakersOrganizationName = 'stakers';
+
+  public static PhantomForceOrganizationName = 'phantom_force';
+
+  //public static PlatformSupply = UnitConversion.ToBigInteger(100000000, FuelTokenDecimals);
+  public static PlatformName = 'phantasma';
+
+  public static ArchiveMinSize = 64;
+  public static ArchiveMaxSize = 104857600;
+  //public static ArchiveBlockSize = MerkleTree.ChunkSize;
+
+  public static InfusionName = 'infusion';
+  //public static InfusionAddress = SmartContract.GetAddressFromContractName(InfusionName);
+
+  public static NameMaxLength = 255;
+  public static UrlMaxLength = 2048;
+  public static ArgsMax = 64;
+  public static AddressMaxSize = 34;
+  public static ScriptMaxSize = 32767;
+}

package/src/core/types/Ed25519Signature.ts

@@ -0,0 +1,78 @@
+import { IKeyPair } from "../interfaces/IKeyPair";
+import { Signature, SignatureKind } from "../interfaces/Signature";
+import { Address } from "./Address";
+import pkg from 'elliptic';
+
+import {
+  stringToUint8Array,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+} from "../utils";
+import { BinaryReader, BinaryWriter, Encoding } from "csharp-binary-stream";
+import { PBinaryWriter, PBinaryReader } from "./Extensions";
+const { eddsa } = pkg;
+const ed25519 = new eddsa("ed25519");
+
+export class Ed25519Signature implements Signature {
+  public Bytes: Uint8Array;
+  public Kind: SignatureKind = SignatureKind.Ed25519;
+
+  constructor(bytes?: Uint8Array) {
+    this.Bytes = bytes;
+  }
+
+  Verify(message: Uint8Array, address: Address): boolean {
+    return this.VerifyMultiple(message, [address]);
+  }
+
+  public VerifyMultiple(message: Uint8Array, addresses: Address[]): boolean {
+    for (const address of addresses) {
+      if (!address.IsUser) {
+        continue;
+      }
+      const pubKey = address.ToByteArray().slice(2);
+      if (
+        ed25519.verify(
+          uint8ArrayToString(this.Bytes),
+          uint8ArrayToString(message),
+          uint8ArrayToString(pubKey)
+        )
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public SerializeData(writer: PBinaryWriter) {
+    //writer.writeString(uint8ArrayToString(this.Bytes));
+    writer.writeByteArray(this.Bytes);
+  }
+
+  public UnserializeData(reader: PBinaryReader) {
+    this.Bytes = stringToUint8Array(reader.readString());
+  }
+
+  ToByteArray(): Uint8Array {
+    const stream = new Uint8Array(64);
+    const writer = new PBinaryWriter(stream);
+    this.SerializeData(writer);
+    return new Uint8Array(stream);
+  }
+
+  public static Generate(
+    keypair: IKeyPair,
+    message: Uint8Array
+  ): Ed25519Signature {
+    const msgHashHex = Buffer.from(uint8ArrayToHex(message), "hex");
+    //const msgHashHex = uint8ArrayToString(message);
+    const privateKeyBuffer = Buffer.from(
+      uint8ArrayToHex(keypair.PrivateKey),
+      "hex"
+    );
+    //const privateKeyBuffer = uint8ArrayToString(keypair.PrivateKey);
+
+    const sign = ed25519.sign(msgHashHex, privateKeyBuffer);
+    return new Ed25519Signature(sign.toBytes());
+  }
+}