phantasma-sdk-ts 0.1.71

package/core/types/Address.js

@@ -0,0 +1,276 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Address = exports.AddressKind = void 0;
+var bs58_1 = __importDefault(require("bs58"));
+var utils_1 = require("../utils");
+var sha256_1 = __importDefault(require("crypto-js/sha256"));
+var enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
+var tx_1 = require("../tx");
+var elliptic_1 = __importDefault(require("elliptic"));
+var eddsa = elliptic_1.default.eddsa;
+var curve = new eddsa('ed25519');
+var AddressKind;
+(function (AddressKind) {
+    AddressKind[AddressKind["Invalid"] = 0] = "Invalid";
+    AddressKind[AddressKind["User"] = 1] = "User";
+    AddressKind[AddressKind["System"] = 2] = "System";
+    AddressKind[AddressKind["Interop"] = 3] = "Interop";
+})(AddressKind = exports.AddressKind || (exports.AddressKind = {}));
+var Address = /** @class */ (function () {
+    function Address(publicKey) {
+        var pkFromArray = Array.from(publicKey);
+        if (publicKey.length != Address.LengthInBytes) {
+            throw new Error("publicKey length must be ".concat(Address.LengthInBytes, ", it was ").concat(publicKey.length, "}"));
+        }
+        this._bytes = new Uint8Array(Address.LengthInBytes);
+        this._bytes.set(publicKey);
+        this._text = null;
+    }
+    Object.defineProperty(Address.prototype, "Kind", {
+        /*public get Kind(): AddressKind {
+              return this.IsNull ? AddressKind.System : (this._bytes[0] >= 3) ? AddressKind.Interop
+                  : (AddressKind)this._bytes[0];
+          }*/
+        get: function () {
+            if (this.IsNull) {
+                return AddressKind.System;
+            }
+            else if (this._bytes[0] >= 3) {
+                return AddressKind.Interop;
+            }
+            else {
+                return this._bytes[0];
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Address.prototype, "IsSystem", {
+        get: function () {
+            return this.Kind == AddressKind.System;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Address.prototype, "IsInterop", {
+        get: function () {
+            return this.Kind == AddressKind.Interop;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Address.prototype, "IsUser", {
+        get: function () {
+            return this.Kind == AddressKind.User;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Address.prototype, "IsNull", {
+        /*public get TendermintAddress(): string {
+              return encodeBase16(this._bytes.slice(2).SHA256().slice(0, 20));
+          }
+          public get TendermintAddress() {
+              return SHA256(this._bytes.slice(2)).slice(0, 20).toString('hex');
+          }
+          */
+        get: function () {
+            if (this._bytes == null || this._bytes.length == 0) {
+                return true;
+            }
+            for (var i = 1; i < this._bytes.length; i++) {
+                if (this._bytes[i] != 0) {
+                    return false;
+                }
+            }
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Address.prototype, "Text", {
+        get: function () {
+            if (this.IsNull) {
+                return Address.NullText;
+            }
+            if (!this._text) {
+                if (Address._keyToTextCache.has(this._bytes)) {
+                    this._text = Address._keyToTextCache.get(this._bytes);
+                }
+                if (!this._text) {
+                    var prefix = void 0;
+                    switch (this.Kind) {
+                        case AddressKind.User:
+                            prefix = 'P';
+                            break;
+                        case AddressKind.Interop:
+                            prefix = 'X';
+                            break;
+                        default:
+                            prefix = 'S';
+                            break;
+                    }
+                    this._text = prefix + bs58_1.default.encode(this._bytes);
+                    Address._keyToTextCache.set(this._bytes, this._text);
+                }
+            }
+            return this._text;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Address.FromPublickKey = function (publicKey) {
+        publicKey = publicKey.slice(0, 34);
+        return new Address(publicKey);
+    };
+    Address.FromText = function (text) {
+        return Address.Parse(text);
+    };
+    Address.Parse = function (text) {
+        if (text == null) {
+            return Address.Null;
+        }
+        if (text == Address.NullText) {
+            return Address.Null;
+        }
+        var addr;
+        var originalText = text;
+        var prefix = text[0];
+        text = text.slice(1);
+        var bytes = bs58_1.default.decode(text);
+        addr = new Address(bytes);
+        switch (prefix) {
+            case 'P':
+                if (addr.Kind != AddressKind.User) {
+                    throw new Error("Invalid address prefix. Expected 'P', got '".concat(prefix, "'"));
+                }
+                break;
+            case 'S':
+                if (addr.Kind != AddressKind.System) {
+                    throw new Error("Invalid address prefix. Expected 'S', got '".concat(prefix, "'"));
+                }
+                break;
+            case 'X':
+                if (addr.Kind < AddressKind.Interop) {
+                    throw new Error("Invalid address prefix. Expected 'X', got '".concat(prefix, "'"));
+                }
+                break;
+            default:
+                throw new Error("Invalid address prefix. Expected 'P', 'S' or 'X', got '".concat(prefix, "'"));
+        }
+        /*this._keyToTextCache.values().forEach((value) => {
+          if (value == text) {
+            return Address.FromHash(this._keyToTextCache(value));
+          }*/
+        return addr;
+    };
+    Address.IsValidAddress = function (text) {
+        try {
+            Address.FromText(text);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    Address.FromBytes = function (bytes) {
+        return new Address(bytes);
+    };
+    Address.FromKey = function (key) {
+        var bytes = new Uint8Array(Address.LengthInBytes);
+        bytes[0] = AddressKind.User;
+        if (key.PublicKey.length == 32) {
+            bytes.set(key.PublicKey, 2);
+        }
+        else if (key.PublicKey.length == 33) {
+            bytes.set(key.PublicKey, 1);
+        }
+        else if (key.PublicKey.length == 64) {
+            bytes.set(key.PublicKey.slice(0, 32), 1);
+        }
+        else {
+            throw new Error('Invalid public key length: ' + key.PublicKey.length);
+        }
+        return new Address(bytes);
+    };
+    Address.FromHash = function (input) {
+        var bytes;
+        if (typeof input === 'string') {
+            bytes = new TextEncoder().encode(input);
+        }
+        else {
+            bytes = input;
+        }
+        var hash = (0, sha256_1.default)(enc_hex_1.default.parse((0, utils_1.uint8ArrayToString)(bytes)));
+        bytes = new Uint8Array(Address.LengthInBytes);
+        bytes[0] = AddressKind.User;
+        bytes.set(hash.words.slice(0, 32), 2);
+        return new Address(bytes);
+    };
+    Address.FromWif = function (wif) {
+        var privateKey = (0, tx_1.getPrivateKeyFromWif)(wif);
+        var publicKey = (0, tx_1.getPublicKeyFromPrivateKey)(privateKey);
+        var addressHex = Buffer.from('0100' + publicKey, 'hex');
+        return this.FromBytes(addressHex);
+    };
+    Address.prototype.compareTo = function (other) {
+        for (var i = 0; i < Address.LengthInBytes; i++) {
+            if (this._bytes[i] < other._bytes[i]) {
+                return -1;
+            }
+            else if (this._bytes[i] > other._bytes[i]) {
+                return 1;
+            }
+        }
+        return 0;
+    };
+    Address.prototype.equals = function (other) {
+        if (!(other instanceof Address)) {
+            return false;
+        }
+        var address = other;
+        return this._bytes.toString() === address._bytes.toString();
+    };
+    Address.prototype.toString = function () {
+        if (this.IsNull) {
+            return Address.NullText;
+        }
+        if (!this._text) {
+            var prefix = void 0;
+            switch (this.Kind) {
+                case AddressKind.User:
+                    prefix = 'P';
+                    break;
+                case AddressKind.Interop:
+                    prefix = 'X';
+                    break;
+                default:
+                    prefix = 'S';
+                    break;
+            }
+            this._text = prefix + bs58_1.default.encode(this._bytes);
+        }
+        return this._text;
+    };
+    Address.prototype.ToByteArray = function () {
+        return this._bytes;
+    };
+    Address.prototype.SerializeData = function (writer) {
+        writer.writeByteArray(this._bytes);
+    };
+    Address.prototype.UnserializeData = function (reader) {
+        this._bytes = reader.readByteArray();
+        this._text = null;
+    };
+    Address.NullText = 'NULL';
+    Address.LengthInBytes = 34;
+    Address.MaxPlatformNameLength = 10;
+    Address.NullPublicKey = new Uint8Array(Address.LengthInBytes);
+    Address.Null = new Address(Address.NullPublicKey);
+    Address._keyToTextCache = new Map();
+    return Address;
+}());
+exports.Address = Address;

package/core/types/Consensus.d.ts

@@ -0,0 +1,61 @@
+import { ISerializable } from "../interfaces";
+import { PBinaryReader, PBinaryWriter } from "./Extensions";
+import { Timestamp } from "./Timestamp";
+export declare enum ConsensusMode {
+    Unanimity = 0,
+    Majority = 1,
+    Popularity = 2,
+    Ranking = 3
+}
+export declare enum PollState {
+    Inactive = 0,
+    Active = 1,
+    Consensus = 2,
+    Failure = 3
+}
+export declare class PollChoice implements ISerializable {
+    value: string;
+    constructor(value: string | number[]);
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): void;
+    static Unserialize(reader: PBinaryReader): PollChoice;
+}
+export declare class PollValue implements ISerializable {
+    value: string;
+    ranking: BigInt;
+    votes: BigInt;
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): void;
+    static Unserialize(reader: PBinaryReader): PollValue;
+}
+export declare class PollVote implements ISerializable {
+    index: BigInt;
+    percentage: BigInt;
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): void;
+    static Unserialize(reader: PBinaryReader): PollVote;
+}
+export declare class ConsensusPoll implements ISerializable {
+    subject: string;
+    organization: string;
+    mode: ConsensusMode;
+    state: PollState;
+    entries: PollValue[];
+    round: BigInt;
+    startTime: Timestamp;
+    endTime: Timestamp;
+    choicesPerUser: BigInt;
+    totalVotes: BigInt;
+    constructor();
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): void;
+    static Unserialize(reader: PBinaryReader): ConsensusPoll;
+}
+export declare class PollPresence implements ISerializable {
+    subject: string;
+    round: BigInt;
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): void;
+    static Unserialize(reader: PBinaryReader): PollPresence;
+}
+//# sourceMappingURL=Consensus.d.ts.map

package/core/types/Consensus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Consensus.d.ts","sourceRoot":"","sources":["../../src/core/types/Consensus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAQ9C,OAAO,EAAU,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,aAAa;IACvB,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,UAAU,IAAA;IACV,OAAO,IAAA;CACR;AAED,oBAAY,SAAS;IACnB,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,SAAS,IAAA;IACT,OAAO,IAAA;CACR;AAED,qBAAa,UAAW,YAAW,aAAa;IACvC,KAAK,EAAE,MAAM,CAAC;gBAEF,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAM3C,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAIrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU;CAKtD;AAED,qBAAa,SAAU,YAAW,aAAa;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IAErB,aAAa,CAAC,MAAM,EAAE,aAAa;IAMnC,eAAe,CAAC,MAAM,EAAE,aAAa;IAMrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS;CAKrD;AAED,qBAAa,QAAS,YAAW,aAAa;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IAE1B,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAKrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ;CAKpD;AAED,qBAAa,aAAc,YAAW,aAAa;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,SAAS,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;;IAe1B,aAAa,CAAC,MAAM,EAAE,aAAa;IAiBnC,eAAe,CAAC,MAAM,EAAE,aAAa;IAmBrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa;CAKzD;AAED,qBAAa,YAAa,YAAW,aAAa;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IAErB,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAKrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY;CAKxD"}

package/core/types/Consensus.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollPresence = exports.ConsensusPoll = exports.PollVote = exports.PollValue = exports.PollChoice = exports.PollState = exports.ConsensusMode = void 0;
+var utils_1 = require("../utils");
+var Extensions_1 = require("./Extensions");
+var Timestamp_1 = require("./Timestamp");
+var ConsensusMode;
+(function (ConsensusMode) {
+    ConsensusMode[ConsensusMode["Unanimity"] = 0] = "Unanimity";
+    ConsensusMode[ConsensusMode["Majority"] = 1] = "Majority";
+    ConsensusMode[ConsensusMode["Popularity"] = 2] = "Popularity";
+    ConsensusMode[ConsensusMode["Ranking"] = 3] = "Ranking";
+})(ConsensusMode = exports.ConsensusMode || (exports.ConsensusMode = {}));
+var PollState;
+(function (PollState) {
+    PollState[PollState["Inactive"] = 0] = "Inactive";
+    PollState[PollState["Active"] = 1] = "Active";
+    PollState[PollState["Consensus"] = 2] = "Consensus";
+    PollState[PollState["Failure"] = 3] = "Failure";
+})(PollState = exports.PollState || (exports.PollState = {}));
+var PollChoice = /** @class */ (function () {
+    function PollChoice(value) {
+        if (value instanceof Array)
+            this.value = Extensions_1.Base16.decode((0, utils_1.byteArrayToHex)(value));
+        else
+            this.value = value;
+    }
+    PollChoice.prototype.SerializeData = function (writer) {
+        writer.writeByteArray((0, utils_1.stringToUint8Array)(this.value));
+    };
+    PollChoice.prototype.UnserializeData = function (reader) {
+        this.value = Extensions_1.Base16.decode(reader.readByteArray());
+    };
+    PollChoice.Unserialize = function (reader) {
+        var pollChoice = new PollChoice("");
+        pollChoice.UnserializeData(reader);
+        return pollChoice;
+    };
+    return PollChoice;
+}());
+exports.PollChoice = PollChoice;
+var PollValue = /** @class */ (function () {
+    function PollValue() {
+    }
+    PollValue.prototype.SerializeData = function (writer) {
+        writer.writeByteArray((0, utils_1.stringToUint8Array)(this.value));
+        writer.writeBigInteger(this.ranking);
+        writer.writeBigInteger(this.votes);
+    };
+    PollValue.prototype.UnserializeData = function (reader) {
+        this.value = Extensions_1.Base16.decode(reader.readByteArray());
+        this.ranking = reader.readBigInteger();
+        this.votes = reader.readBigInteger();
+    };
+    PollValue.Unserialize = function (reader) {
+        var pollValue = new PollValue();
+        pollValue.UnserializeData(reader);
+        return pollValue;
+    };
+    return PollValue;
+}());
+exports.PollValue = PollValue;
+var PollVote = /** @class */ (function () {
+    function PollVote() {
+    }
+    PollVote.prototype.SerializeData = function (writer) {
+        writer.writeBigInteger(this.index);
+        writer.writeBigInteger(this.percentage);
+    };
+    PollVote.prototype.UnserializeData = function (reader) {
+        this.index = reader.readBigInteger();
+        this.percentage = reader.readBigInteger();
+    };
+    PollVote.Unserialize = function (reader) {
+        var pollVote = new PollVote();
+        pollVote.UnserializeData(reader);
+        return pollVote;
+    };
+    return PollVote;
+}());
+exports.PollVote = PollVote;
+var ConsensusPoll = /** @class */ (function () {
+    function ConsensusPoll() {
+        this.subject = "";
+        this.organization = "";
+        this.mode = ConsensusMode.Unanimity;
+        this.state = PollState.Inactive;
+        this.entries = [];
+        this.round = BigInt(0);
+        this.startTime = Timestamp_1.Timestamp.null;
+        this.endTime = Timestamp_1.Timestamp.null;
+        this.choicesPerUser = BigInt(0);
+        this.totalVotes = BigInt(0);
+    }
+    ConsensusPoll.prototype.SerializeData = function (writer) {
+        writer.writeString(this.subject);
+        writer.writeString(this.organization);
+        writer.writeByte(this.mode);
+        writer.writeByte(this.state);
+        writer.writeByte(this.entries.length);
+        this.entries.forEach(function (entry) {
+            entry.SerializeData(writer);
+        });
+        writer.writeBigInteger(this.round);
+        writer.writeTimestamp(this.startTime);
+        writer.writeTimestamp(this.endTime);
+        writer.writeBigInteger(this.choicesPerUser);
+        writer.writeBigInteger(this.totalVotes);
+    };
+    ConsensusPoll.prototype.UnserializeData = function (reader) {
+        this.subject = reader.readString();
+        this.organization = reader.readString();
+        this.mode = reader.readByte();
+        this.state = reader.readByte();
+        this.entries = [];
+        var entriesLength = reader.readUnsignedInt();
+        for (var 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();
+    };
+    ConsensusPoll.Unserialize = function (reader) {
+        var consensusPoll = new ConsensusPoll();
+        consensusPoll.UnserializeData(reader);
+        return consensusPoll;
+    };
+    return ConsensusPoll;
+}());
+exports.ConsensusPoll = ConsensusPoll;
+var PollPresence = /** @class */ (function () {
+    function PollPresence() {
+    }
+    PollPresence.prototype.SerializeData = function (writer) {
+        writer.writeString(this.subject);
+    };
+    PollPresence.prototype.UnserializeData = function (reader) {
+        this.subject = reader.readString();
+        this.round = reader.readBigInteger();
+    };
+    PollPresence.Unserialize = function (reader) {
+        var pollPresence = new PollPresence();
+        pollPresence.UnserializeData(reader);
+        return pollPresence;
+    };
+    return PollPresence;
+}());
+exports.PollPresence = PollPresence;

package/core/types/Contract.d.ts

@@ -0,0 +1,60 @@
+import { ISerializable } from "../interfaces";
+import { VMType } from "../vm/VMType";
+import { TokenTrigger } from "./DomainSettings";
+import { PBinaryReader, PBinaryWriter } from "./Extensions";
+export declare class ContractParameter {
+    name: string;
+    type: VMType;
+    constructor(name: string, type: VMType);
+}
+export declare class ContractInterface implements ISerializable {
+    static readonly Empty: ContractInterface;
+    private _methods;
+    Methods: ContractMethod[];
+    MethodCount: number;
+    private _events;
+    Events(): ContractEvent[];
+    EventCount(): number;
+    newEmpty(): void;
+    constructor(methods: ContractMethod[], events: ContractEvent[]);
+    get(name: string): ContractMethod | null;
+    HasMethod(name: string): boolean;
+    HasTokenTrigger(trigger: TokenTrigger): boolean;
+    FindMethod(name: string): ContractMethod | null;
+    FindEvent(value: number): ContractEvent | null;
+    ImplementsEvent(evt: ContractEvent): boolean;
+    ImplementsMethod(method: ContractMethod): boolean;
+    ImplementsInterface(other: ContractInterface): boolean;
+    UnserializeData(reader: PBinaryReader): void;
+    SerializeData(writer: PBinaryWriter): void;
+}
+export declare class ContractMethod implements ISerializable {
+    name: string;
+    returnType: VMType;
+    parameters: ContractParameter[];
+    offset: number;
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): ContractMethod;
+    constructorOne(name: string, returnType: VMType, labels: Map<string, number>, parameters: ContractParameter[]): void;
+    constructor(name: string, returnType: VMType, offset: number, parameters: ContractParameter[]);
+    isProperty(): boolean;
+    isTrigger(): boolean;
+    toString(): string;
+    static fromBytes(bytes: Uint8Array): ContractMethod;
+    static Unserialize(reader: PBinaryReader): ContractMethod;
+    Serialize(writer: PBinaryWriter): void;
+    toArray(): Uint8Array;
+}
+export declare class ContractEvent implements ISerializable {
+    readonly value: number;
+    readonly name: string;
+    readonly returnType: VMType;
+    readonly description: Uint8Array;
+    constructor(value: number, name: string, returnType: VMType, description: Uint8Array);
+    SerializeData(writer: PBinaryWriter): void;
+    UnserializeData(reader: PBinaryReader): ContractEvent;
+    toString(): string;
+    static Unserialize(reader: PBinaryReader): ContractEvent;
+    Serialize(writer: PBinaryWriter): void;
+}
+//# sourceMappingURL=Contract.d.ts.map

package/core/types/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","sourceRoot":"","sources":["../../src/core/types/Contract.ts"],"names":[],"mappings":"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"}