phantasma-sdk-ts 0.1.76 → 0.2.0-rc.1

package/src/core/types/Consensus.ts

@@ -1,181 +0,0 @@
-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

@@ -1,324 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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());
-  }
-}