phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/core/types/Contract.js

@@ -1,229 +1 @@
-import { arrayNumberToUint8Array, uint8ArrayToNumberArray } from '../utils/index.js';
-import { PBinaryReader, PBinaryWriter } from './Extensions/index.js';
-export class ContractParameter {
-    constructor(name, type) {
-        this.name = name;
-        this.type = type;
-    }
-}
-export class ContractInterface {
-    Events() {
-        return this._events;
-    }
-    EventCount() {
-        return this._events.length;
-    }
-    newEmpty() {
-        this._methods = new Map();
-        this._events = [];
-    }
-    constructor(methods, events) {
-        this._methods = new Map();
-        this.Methods = Array.from(this._methods.values());
-        this.MethodCount = this._methods.size;
-        for (const entry of methods) {
-            this._methods.set(entry.name, entry);
-        }
-        this._events = events;
-    }
-    get(name) {
-        return this.FindMethod(name);
-    }
-    HasMethod(name) {
-        return this._methods.has(name);
-    }
-    HasTokenTrigger(trigger) {
-        const strName = trigger.toString();
-        const name = strName[0].toLowerCase() + strName.slice(1);
-        return this._methods.has(name);
-    }
-    FindMethod(name) {
-        if (this._methods.has(name)) {
-            return this._methods.get(name);
-        }
-        return null;
-    }
-    FindEvent(value) {
-        for (const evt of this._events) {
-            if (evt.value === value) {
-                return evt;
-            }
-        }
-        return null;
-    }
-    ImplementsEvent(evt) {
-        for (const entry of this.Events()) {
-            if (entry.name === evt.name &&
-                entry.value === evt.value &&
-                entry.returnType === evt.returnType) {
-                return true;
-            }
-        }
-        return false;
-    }
-    ImplementsMethod(method) {
-        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;
-    }
-    ImplementsInterface(other) {
-        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;
-    }
-    UnserializeData(reader) {
-        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));
-        }
-    }
-    SerializeData(writer) {
-        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);
-        }
-    }
-}
-ContractInterface.Empty = new ContractInterface([], []);
-export class ContractMethod {
-    SerializeData(writer) {
-        this.Serialize(writer);
-    }
-    UnserializeData(reader) {
-        return ContractMethod.Unserialize(reader);
-    }
-    constructorOne(name, returnType, labels, parameters) {
-        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, returnType, offset, parameters) {
-        this.name = name;
-        this.offset = offset;
-        this.returnType = returnType;
-        this.parameters = parameters;
-    }
-    isProperty() {
-        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;
-    }
-    isTrigger() {
-        if (this.name.length >= 3 &&
-            this.name.startsWith('on') &&
-            this.name[2] === this.name[2].toUpperCase()) {
-            return true;
-        }
-        return false;
-    }
-    toString() {
-        return `${this.name} : ${this.returnType}`;
-    }
-    static fromBytes(bytes) {
-        const stream = new Uint8Array(bytes);
-        const reader = new PBinaryReader(stream);
-        return ContractMethod.Unserialize(reader);
-    }
-    static Unserialize(reader) {
-        const name = reader.readString();
-        const returnType = reader.readByte();
-        const offset = reader.readInt();
-        const len = reader.readByte();
-        const parameters = new Array(len);
-        for (let i = 0; i < len; i++) {
-            const pName = reader.readString();
-            const pVMType = reader.readByte();
-            parameters[i] = new ContractParameter(pName, pVMType);
-        }
-        return new ContractMethod(name, returnType, offset, parameters);
-    }
-    Serialize(writer) {
-        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);
-        });
-    }
-    toArray() {
-        const stream = new Uint8Array();
-        const writer = new PBinaryWriter(stream);
-        this.Serialize(writer);
-        return stream;
-    }
-}
-export class ContractEvent {
-    constructor(value, name, returnType, description) {
-        this.value = value;
-        this.name = name;
-        this.returnType = returnType;
-        this.description = description;
-    }
-    SerializeData(writer) {
-        this.Serialize(writer);
-    }
-    UnserializeData(reader) {
-        return ContractEvent.Unserialize(reader);
-    }
-    toString() {
-        return `${this.name} : ${this.returnType} => ${this.value}`;
-    }
-    static Unserialize(reader) {
-        const value = reader.readByte();
-        const name = reader.readString();
-        const returnType = reader.readByte();
-        const description = reader.readBytes(reader.readByte());
-        return new ContractEvent(value, name, returnType, arrayNumberToUint8Array(description));
-    }
-    Serialize(writer) {
-        writer.writeByte(this.value);
-        writer.writeString(this.name);
-        writer.writeByte(this.returnType);
-        writer.writeByte(this.description.length);
-        writer.writeBytes(uint8ArrayToNumberArray(this.description));
-    }
-}
+export * from '../../types/contract.js';

package/dist/esm/core/types/DomainSettings.js

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

package/dist/esm/core/types/Ed25519.js

@@ -0,0 +1 @@
+export * from '../../types/ed25519.js';

package/dist/esm/core/types/Ed25519Signature.js

@@ -1,51 +1 @@
-import { SignatureKind } from '../interfaces/Signature.js';
-import pkg from 'elliptic';
-import { stringToUint8Array, bytesToHex } from '../utils/index.js';
-import { PBinaryWriter } from './Extensions/index.js';
-const { eddsa } = pkg;
-const ed25519 = new eddsa('ed25519');
-export class Ed25519Signature {
-    constructor(bytes) {
-        this.Kind = SignatureKind.Ed25519;
-        this.Bytes = bytes;
-    }
-    Verify(message, address) {
-        return this.VerifyMultiple(message, [address]);
-    }
-    VerifyMultiple(message, addresses) {
-        for (const address of addresses) {
-            if (!address.IsUser) {
-                continue;
-            }
-            const pubKey = address.ToByteArray().slice(2);
-            const msgBytes = Buffer.from(message);
-            const sigHex = bytesToHex(this.Bytes);
-            const pubKeyHex = bytesToHex(pubKey);
-            if (ed25519.verify(msgBytes, sigHex, pubKeyHex)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    SerializeData(writer) {
-        //writer.writeString(uint8ArrayToString(this.Bytes));
-        writer.writeByteArray(this.Bytes);
-    }
-    UnserializeData(reader) {
-        this.Bytes = stringToUint8Array(reader.readString());
-    }
-    ToByteArray() {
-        const stream = new Uint8Array(64);
-        const writer = new PBinaryWriter(stream);
-        this.SerializeData(writer);
-        return new Uint8Array(stream);
-    }
-    static Generate(keypair, message) {
-        const msgHashHex = Buffer.from(bytesToHex(message), 'hex');
-        //const msgHashHex = uint8ArrayToString(message);
-        const privateKeyBuffer = Buffer.from(bytesToHex(keypair.PrivateKey), 'hex');
-        //const privateKeyBuffer = uint8ArrayToString(keypair.PrivateKey);
-        const sign = ed25519.sign(msgHashHex, privateKeyBuffer);
-        return new Ed25519Signature(sign.toBytes());
-    }
-}
+export * from '../../types/ed25519-signature.js';

package/dist/esm/core/types/Entropy.js

@@ -1,14 +1 @@
-import crypto from "crypto";
-export class Entropy {
-    //private static rnd = crypto.randomBytes(24);
-    static GetRandomBytes(targetLength) {
-        let rnd = new Uint8Array(targetLength);
-        const privateKey = Buffer.alloc(rnd.byteLength);
-        crypto.getRandomValues(rnd);
-        for (let i = 0; i < 32; ++i) {
-            privateKey.writeUInt8(rnd[i], i);
-        }
-        //let pk = this.ToBuffer(rnd);
-        return privateKey;
-    }
-}
+export * from '../../types/entropy.js';

package/dist/esm/core/types/Extensions/Base16.js

@@ -1,30 +1 @@
-import { stringToUint8Array } from "../../utils/index.js";
-export class Base16 {
-    static encode(str) {
-        if (!str)
-            return "";
-        return str
-            .split("")
-            .map((c) => c.charCodeAt(0).toString(16).padStart(2, "0"))
-            .join("");
-    }
-    static encodeUint8Array(arr) {
-        return Array.from(arr)
-            .map((c) => c.toString(16).padStart(2, "0"))
-            .join("")
-            .toUpperCase();
-    }
-    static decode(str) {
-        if (!str || str.length % 2 !== 0)
-            return "";
-        return (str
-            .match(/.{1,2}/g)
-            ?.map((c) => String.fromCharCode(parseInt(c, 16)))
-            .join("") ?? "");
-    }
-    static decodeUint8Array(str) {
-        if (!str || str.length % 2 !== 0)
-            return new Uint8Array(0);
-        return new Uint8Array(stringToUint8Array(this.decode(str)));
-    }
-}
+export * from '../../../types/extensions/base16.js';

package/dist/esm/core/types/Extensions/Describer.js

@@ -1,17 +1 @@
-export class Describer {
-    static describe(val, parent = false) {
-        var result = [];
-        if (parent) {
-            var proto = Object.getPrototypeOf(val.prototype);
-            if (proto) {
-                result = result.concat(this.describe(proto.constructor, parent));
-            }
-        }
-        result = result.concat(val.toString().match(this.FRegEx) || []);
-        /*.filter((x) => {
-            x.replace("this.", "");
-          })*/
-        return result;
-    }
-}
-Describer.FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);
+export * from '../../../types/extensions/describer.js';

package/dist/esm/core/types/Extensions/PBinaryReader.js

@@ -1,228 +1 @@
-import BigInteger from 'big-integer';
-import { BinaryReader } from 'csharp-binary-stream';
-import { SignatureKind } from '../../interfaces/index.js';
-import { bytesToHex, stringToUint8Array } from '../../utils/index.js';
-import { VMType } from '../../vm/index.js';
-import { Ed25519Signature } from '../Ed25519Signature.js';
-import { Timestamp } from '../Timestamp.js';
-export class PBinaryReader {
-    get length() {
-        return this.reader.length;
-    }
-    get position() {
-        return this.reader.position;
-    }
-    set position(value) {
-        this.reader.position = value;
-    }
-    get isEndOfStream() {
-        return this.reader.isEndOfStream;
-    }
-    readBoolean() {
-        return this.reader.readBoolean();
-    }
-    readByte() {
-        return this.reader.readByte();
-    }
-    readBytes(bytesToRead) {
-        return this.reader.readBytes(bytesToRead);
-    }
-    readSignedByte() {
-        return this.reader.readSignedByte();
-    }
-    readShort() {
-        return this.reader.readShort();
-    }
-    readUnsignedShort() {
-        return this.reader.readUnsignedShort();
-    }
-    readInt() {
-        return this.reader.readInt();
-    }
-    readUnsignedInt() {
-        return this.reader.readUnsignedInt();
-    }
-    readLongString() {
-        return this.reader.readLongString();
-    }
-    readLong() {
-        return this.reader.readLong();
-    }
-    readUnsignedLongString() {
-        return this.reader.readUnsignedLongString();
-    }
-    readUnsignedLong() {
-        return this.reader.readUnsignedLong();
-    }
-    readFloat() {
-        return this.reader.readFloat();
-    }
-    readDouble() {
-        return this.reader.readDouble();
-    }
-    readChar(encoding) {
-        return this.reader.readChar(encoding);
-    }
-    readChars(charactersToRead, encoding) {
-        return this.reader.readChars(charactersToRead, encoding);
-    }
-    readCharBytes(bytesToRead, encoding) {
-        return this.reader.readCharBytes(bytesToRead, encoding);
-    }
-    constructor(arg1) {
-        this.reader = new BinaryReader(arg1);
-    }
-    read(numBytes) {
-        var res = bytesToHex(this.readBytes(numBytes)).substr(0, numBytes * 2);
-        //this.position += numBytes;
-        return res;
-    }
-    readString() {
-        var len = this.readVarInt();
-        return this.readStringBytes(len);
-    }
-    readStringBytes(numBytes) {
-        var res = '';
-        for (var i = 0; i < numBytes; ++i) {
-            res += String.fromCharCode(this.readByte());
-        }
-        return res;
-    }
-    readBigInteger() {
-        // TO DO: implement negative numbers
-        var len = this.readVarInt();
-        var res = 0;
-        var stringBytes = this.read(len);
-        [...stringBytes.match(/.{1,2}/g)]
-            .reverse()
-            .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-        let bigInt = BigInt(res);
-        return bigInt;
-    }
-    readBigIntAccurate() {
-        var len = this.readVarInt();
-        var res = BigInteger();
-        var stringBytes = this.read(len);
-        [...stringBytes.match(/.{1,2}/g)].reverse().forEach((c) => {
-            res = res.times(256).plus(parseInt(c, 16));
-        });
-        return res.toString();
-    }
-    readSignatureV2() {
-        let kind = this.readByte();
-        let curve;
-        let signature = new Ed25519Signature();
-        switch (kind) {
-            case SignatureKind.None:
-                return null;
-            case SignatureKind.Ed25519:
-                let len = this.readVarInt();
-                signature.Bytes = new Uint8Array(this.readBytes(len));
-                break;
-            case SignatureKind.ECDSA:
-                curve = this.readByte();
-                signature.Bytes = stringToUint8Array(this.readString());
-                break;
-            default:
-                throw 'read signature: ' + kind;
-        }
-        return signature;
-    }
-    readSignature() {
-        let kind = this.readByte();
-        let signature = new Ed25519Signature();
-        let curve;
-        signature.Kind = kind;
-        switch (kind) {
-            case SignatureKind.None:
-                return null;
-            case SignatureKind.Ed25519:
-                let len = this.readVarInt();
-                signature.Bytes = stringToUint8Array(this.read(len));
-                break;
-            case SignatureKind.ECDSA:
-                curve = this.readByte();
-                signature.Bytes = stringToUint8Array(this.readString());
-                break;
-            default:
-                throw 'read signature: ' + kind;
-        }
-        return signature;
-    }
-    readByteArray() {
-        var res;
-        var length = this.readVarInt();
-        if (length == 0)
-            return [];
-        res = this.read(length);
-        return res;
-    }
-    readTimestamp() {
-        //var len = this.readByte();
-        let result = 0;
-        let bytes = this.read(4);
-        //[...(bytes.match(/.{1,2}/g) as any)];
-        bytes
-            .match(/.{1,2}/g)
-            .reverse()
-            .forEach((c) => (result = result * 256 + parseInt(c, 16)));
-        let timestamp = new Timestamp(result);
-        return timestamp;
-    }
-    readVarInt() {
-        var len = this.readByte();
-        var res = 0;
-        if (len === 0xfd) {
-            [...this.read(2).match(/.{1,2}/g)]
-                .reverse()
-                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-            return res;
-        }
-        else if (len === 0xfe) {
-            [...this.read(4).match(/.{1,2}/g)]
-                .reverse()
-                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-            return res;
-        }
-        else if (len === 0xff) {
-            [...this.read(8).match(/.{1,2}/g)]
-                .reverse()
-                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-            return res;
-        }
-        return len;
-    }
-    readVarString() {
-        var len = this.readVarInt();
-        if (len == 0)
-            return '';
-        return this.readStringBytes(len);
-    }
-    readVmObject() {
-        const type = this.readByte();
-        switch (type) {
-            case VMType.String:
-                return this.readString();
-            case VMType.Number:
-                return this.readBigIntAccurate();
-            case VMType.Bool:
-                return this.readByte() != 0;
-            case VMType.Struct:
-                const numFields = this.readVarInt();
-                let res = {};
-                for (let i = 0; i < numFields; ++i) {
-                    const key = this.readVmObject();
-                    const value = this.readVmObject();
-                    res[key] = value;
-                }
-                return res;
-            case VMType.Enum:
-                return this.readVarInt();
-            case VMType.Object:
-                const numBytes = this.readVarInt();
-                return this.read(numBytes);
-            default:
-                return 'unsupported type ' + type;
-        }
-    }
-}
+export * from '../../../types/extensions/p-binary-reader.js';