phantasma-sdk-ts 0.1.71

package/core/types/PhantasmaKeys.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhantasmaKeys = void 0;
+var Address_1 = require("./Address");
+var bs58_1 = __importDefault(require("bs58"));
+var wif_1 = __importDefault(require("wif"));
+var utils_1 = require("../utils");
+var Ed25519Signature_1 = require("./Ed25519Signature");
+var elliptic_1 = __importDefault(require("elliptic"));
+var Entropy_1 = require("./Entropy");
+var tx_1 = require("../tx");
+var eddsa = elliptic_1.default.eddsa;
+var ed25519 = new eddsa("ed25519");
+var PhantasmaKeys = /** @class */ (function () {
+    function PhantasmaKeys(privateKey) {
+        if (privateKey.length == 64) {
+            privateKey = privateKey.slice(0, 32);
+        }
+        if (privateKey.length != PhantasmaKeys.PrivateKeyLength) {
+            throw new Error("privateKey should have length ".concat(PhantasmaKeys.PrivateKeyLength, " but has ").concat(privateKey.length));
+        }
+        this._privateKey = new Uint8Array(PhantasmaKeys.PrivateKeyLength);
+        this._privateKey.set(privateKey);
+        var wif = (0, tx_1.getWifFromPrivateKey)((0, utils_1.uint8ArrayToHex)(privateKey));
+        var privateKeyString = (0, utils_1.uint8ArrayToHex)(this._privateKey);
+        var privateKeyBuffer = Buffer.from(privateKeyString, "hex");
+        var publicKey = ed25519.keyFromSecret(privateKeyBuffer).getPublic();
+        this._publicKey = publicKey;
+        this.Address = Address_1.Address.FromKey(this);
+    }
+    Object.defineProperty(PhantasmaKeys.prototype, "PrivateKey", {
+        get: function () {
+            return this._privateKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PhantasmaKeys.prototype, "PublicKey", {
+        get: function () {
+            return this._publicKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PhantasmaKeys.prototype.toString = function () {
+        return this.Address.Text;
+    };
+    PhantasmaKeys.generate = function () {
+        var privateKey = Entropy_1.Entropy.GetRandomBytes(PhantasmaKeys.PrivateKeyLength);
+        var pair = new PhantasmaKeys(privateKey);
+        return pair;
+    };
+    PhantasmaKeys.fromWIF = function (wif) {
+        if (!wif) {
+            throw new Error("WIF required");
+        }
+        var data = bs58_1.default.decode(wif); // checkdecode
+        if (data.length == 38) {
+            data = data.slice(0, 34);
+        }
+        if (data.length != 34 || data[0] != 0x80 || data[33] != 0x01) {
+            throw new Error("Invalid WIF format");
+        }
+        var privateKey = data.slice(1, 33);
+        return new PhantasmaKeys(privateKey);
+    };
+    PhantasmaKeys.prototype.toWIF = function () {
+        var privateKeyString = (0, utils_1.uint8ArrayToHex)(this._privateKey);
+        var privatekeyBuffer = Buffer.from(privateKeyString, "hex");
+        var wif = wif_1.default.encode(128, privatekeyBuffer, true); //uint8ArrayToHex(data); // .base58CheckEncode();
+        return wif;
+    };
+    PhantasmaKeys.xor = function (x, y) {
+        if (x.length != y.length) {
+            throw new Error("x and y should have the same length");
+        }
+        var result = new Uint8Array(x.length);
+        for (var i = 0; i < x.length; i++) {
+            result[i] = x[i] ^ y[i];
+        }
+        return result;
+    };
+    PhantasmaKeys.prototype.Sign = function (msg, customSignFunction) {
+        return Ed25519Signature_1.Ed25519Signature.Generate(this, msg);
+    };
+    PhantasmaKeys.PrivateKeyLength = 32;
+    return PhantasmaKeys;
+}());
+exports.PhantasmaKeys = PhantasmaKeys;

package/core/types/Serialization.d.ts

@@ -0,0 +1,22 @@
+import { PBinaryReader, PBinaryWriter } from "./Extensions";
+export interface CustomReader {
+    (reader: PBinaryReader): any;
+}
+export interface CustomWriter {
+    (writer: PBinaryWriter, obj: any): void;
+}
+export declare class CustomSerializer {
+    readonly Read: CustomReader;
+    readonly Write: CustomWriter;
+    constructor(reader: CustomReader, writer: CustomWriter);
+}
+export declare class Serialization<T> {
+    private static _customSerializers;
+    static RegisterType<T>(type: T, reader: CustomReader, writer: CustomWriter): void;
+    static SerializeEnum(obj: any): Uint8Array;
+    static Serialize(obj: any): Uint8Array;
+    static SerializeObject(writer: PBinaryWriter, obj: any, type: any | null): void;
+    static Unserialize<T>(bytesOrBytes: Uint8Array | PBinaryReader, type?: any): T;
+    static UnserializeObject<T extends any>(reader: PBinaryReader, type: any): T;
+}
+//# sourceMappingURL=Serialization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Serialization.d.ts","sourceRoot":"","sources":["../../src/core/types/Serialization.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAKpE,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,aAAa,GAAG,GAAG,CAAC;CAC9B;AACD,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;CACzC;AAID,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBACjB,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY;CAIvD;AAED,qBAAa,aAAa,CAAC,CAAC;IAC1B,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAG7B;IAEJ,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY;IAO1E,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU;IAc1C,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU;IAgBtC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAmExE,MAAM,CAAC,WAAW,CAAC,CAAC,EAClB,YAAY,EAAE,UAAU,GAAG,aAAa,EACxC,IAAI,CAAC,EAAE,GAAG,GACT,CAAC;IAYJ,MAAM,CAAC,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC;CA6D7E"}

package/core/types/Serialization.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serialization = exports.CustomSerializer = void 0;
+var Extensions_1 = require("./Extensions");
+var Timestamp_1 = require("./Timestamp");
+var utils_1 = require("../utils");
+//function CustomWriter(writer: PBinaryWriter, obj: any): void;
+//function CustomReader(reader: PBinaryReader): any;
+var CustomSerializer = /** @class */ (function () {
+    function CustomSerializer(reader, writer) {
+        this.Read = reader;
+        this.Write = writer;
+    }
+    return CustomSerializer;
+}());
+exports.CustomSerializer = CustomSerializer;
+var Serialization = /** @class */ (function () {
+    function Serialization() {
+    }
+    Serialization.RegisterType = function (type, reader, writer) {
+        Serialization._customSerializers[typeof type] = new CustomSerializer(reader, writer);
+    };
+    Serialization.SerializeEnum = function (obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        var writer = new Extensions_1.PBinaryWriter();
+        writer.writeEnum(obj);
+        return writer.toUint8Array();
+    };
+    Serialization.Serialize = function (obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        //let jsonString = JSON.stringify(obj);
+        var writer = new Extensions_1.PBinaryWriter();
+        this.SerializeObject(writer, obj, typeof obj);
+        //let jsonAsUint8 = new TextEncoder().encode(jsonString);
+        return writer.toUint8Array();
+    };
+    Serialization.SerializeObject = function (writer, obj, type) {
+        var _this = this;
+        if (type == null || type == undefined) {
+            type = typeof obj;
+            this.SerializeObject(writer, obj, type);
+            return;
+        }
+        if (Serialization._customSerializers.has(typeof type)) {
+            var serializer = Serialization._customSerializers[typeof type];
+            serializer.Write(writer, obj);
+            return;
+        }
+        /*if (typeof obj == "void") {
+          return;
+        }*/
+        var structType = Object.getPrototypeOf(obj).constructor.name;
+        var result = Object.apply(structType);
+        var localType = Object.apply(typeof type);
+        //console.log(localType);
+        if (obj instanceof Boolean || typeof obj == "boolean") {
+            writer.writeByte(obj ? 1 : 0);
+            return;
+        }
+        else if (obj instanceof Number || typeof obj == "number") {
+            writer.writeByte((0, utils_1.stringToUint8Array)(obj.toString()).length);
+            writer.writeVarInt(obj);
+            return;
+        }
+        else if (obj instanceof BigInt || typeof obj == "bigint") {
+            writer.writeBigInteger(obj);
+        }
+        else if (obj instanceof String || typeof obj == "string") {
+            writer.writeString(obj);
+            return;
+        }
+        else if (obj instanceof Timestamp_1.Timestamp) {
+            writer.writeTimestamp(obj);
+            return;
+        }
+        else if (obj instanceof Date) {
+            writer.writeDateTime(obj);
+            return;
+        }
+        else if (typeof obj.UnserializeData === "function" &&
+            typeof obj.SerializeData === "function") {
+            obj.SerializeData(writer);
+            return;
+        }
+        else if (Array.isArray(obj)) {
+            writer.writeVarInt(obj.length);
+            obj.forEach(function (entry) {
+                _this.SerializeObject(writer, entry, typeof entry);
+            });
+            return;
+        }
+        else if (Object.getPrototypeOf(type) == "enum") {
+            writer.writeByte(obj);
+            return;
+        }
+        else if (obj instanceof Uint8Array) {
+            writer.writeByteArray(Array.from(obj));
+        }
+        else {
+            // TODO: Add support for other types
+            // Get the keys of the object
+            var fields = Object.keys(obj);
+            fields.forEach(function (field) {
+                var value = obj[field];
+                _this.SerializeObject(writer, value, typeof value);
+            });
+        }
+    };
+    Serialization.Unserialize = function (bytesOrBytes, type) {
+        if (bytesOrBytes instanceof Extensions_1.PBinaryReader) {
+            return Serialization.UnserializeObject(bytesOrBytes, type);
+        }
+        if (!bytesOrBytes || bytesOrBytes.length === 0) {
+            return null;
+        }
+        //let type = Object.prototype.propertyIsEnumerable(T);
+        var stream = new Extensions_1.PBinaryReader(bytesOrBytes);
+        return Serialization.UnserializeObject(stream, type);
+    };
+    Serialization.UnserializeObject = function (reader, type) {
+        if (Serialization._customSerializers.has(typeof type)) {
+            var serializer = Serialization._customSerializers[typeof type];
+            return serializer.Read(reader);
+        }
+        if (type == null || type == undefined) {
+            return null;
+        }
+        var localType; //: typeof type;
+        if (type.name != undefined) {
+            var className = type.name;
+            localType = Object.apply(className);
+        }
+        else {
+            localType = new type();
+        }
+        if (localType instanceof Boolean ||
+            typeof localType == "boolean" ||
+            type.name == "Boolean") {
+            return reader.readBoolean();
+        }
+        else if (localType instanceof Number || typeof localType == "number") {
+            return reader.readVarInt();
+        }
+        else if (localType instanceof BigInt || typeof localType == "bigint") {
+            return reader.readBigInteger();
+        }
+        else if (localType instanceof String || typeof localType == "string") {
+            return reader.readVarString();
+        }
+        else if (localType instanceof Timestamp_1.Timestamp) {
+            return new Timestamp_1.Timestamp(reader.readVarInt());
+        }
+        else if (typeof localType.UnserializeData === "function" &&
+            typeof localType.SerializeData === "function") {
+            var obj = localType;
+            obj.UnserializeData(reader);
+            return obj;
+        }
+        else if (Array.isArray(type)) {
+            var len = reader.readByte();
+            var arr = new Array(len);
+            for (var i = 0; i < len; i++) {
+                arr[i] = this.UnserializeObject(reader, type[i]);
+            }
+            return arr;
+        }
+        else if (Object.getPrototypeOf(type) == "enum") {
+            return reader.readByte();
+        }
+        else {
+            var fields = Object.keys(localType);
+            /*console.log(fields);
+            fields.forEach((field) => {
+              localType[field] = this.UnserializeObject(
+                reader,
+                typeof localType[field]
+              );
+            });
+            return localType as T;*/
+        }
+    };
+    Serialization._customSerializers = new Map(); //: { [key: string]: CustomSerializer };
+    return Serialization;
+}());
+exports.Serialization = Serialization;

package/core/types/Stack.d.ts

@@ -0,0 +1,16 @@
+import { IStack } from "../interfaces";
+export declare class Stack<T> implements IStack<T> {
+    private capacity;
+    private storage;
+    constructor(capacity?: number);
+    push(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    size(): number;
+    isEmpty(): boolean;
+    toArray(): T[];
+    clear(): void;
+    toString(): string;
+    isFull(): boolean;
+}
+//# sourceMappingURL=Stack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../src/core/types/Stack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,qBAAa,KAAK,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAG5B,OAAO,CAAC,QAAQ;IAF5B,OAAO,CAAC,OAAO,CAAW;gBAEN,QAAQ,GAAE,MAAiB;IAE/C,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAOnB,GAAG,IAAI,CAAC,GAAG,SAAS;IAIpB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,IAAI,MAAM;IAId,OAAO,IAAI,OAAO;IAIlB,OAAO,IAAI,CAAC,EAAE;IAId,KAAK,IAAI,IAAI;IAIb,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,OAAO;CAGlB"}

package/core/types/Stack.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+var Stack = /** @class */ (function () {
+    function Stack(capacity) {
+        if (capacity === void 0) { capacity = Infinity; }
+        this.capacity = capacity;
+        this.storage = [];
+    }
+    Stack.prototype.push = function (item) {
+        if (this.size() === this.capacity) {
+            throw Error("Stack has reached max capacity, you cannot add more items");
+        }
+        this.storage.push(item);
+    };
+    Stack.prototype.pop = function () {
+        return this.storage.pop();
+    };
+    Stack.prototype.peek = function () {
+        return this.storage[this.size() - 1];
+    };
+    Stack.prototype.size = function () {
+        return this.storage.length;
+    };
+    Stack.prototype.isEmpty = function () {
+        return this.size() === 0;
+    };
+    Stack.prototype.toArray = function () {
+        return this.storage;
+    };
+    Stack.prototype.clear = function () {
+        this.storage = [];
+    };
+    Stack.prototype.toString = function () {
+        return this.storage.toString();
+    };
+    Stack.prototype.isFull = function () {
+        return this.capacity === this.size();
+    };
+    return Stack;
+}());
+exports.Stack = Stack;

package/core/types/Timestamp.d.ts

@@ -0,0 +1,26 @@
+export declare class Timestamp {
+    value: number;
+    constructor(value: number);
+    toString(): string;
+    toStringFormat(format: string): string;
+    static now: number;
+    static null: Timestamp;
+    compareTo(other: Timestamp): 0 | 1 | -1;
+    equals(obj: any): boolean;
+    getHashCode(): number;
+    getSize(): number;
+    static equal(A: Timestamp, B: Timestamp): boolean;
+    static notEqual(A: Timestamp, B: Timestamp): boolean;
+    static lessThan(A: Timestamp, B: Timestamp): boolean;
+    static greaterThan(A: Timestamp, B: Timestamp): boolean;
+    static lessThanOrEqual(A: Timestamp, B: Timestamp): boolean;
+    static greaterThanOrEqual(A: Timestamp, B: Timestamp): boolean;
+    static subtract(A: Timestamp, B: Timestamp): number;
+    static fromNumber(ticks: number): Timestamp;
+    static fromDate(time: Date): Timestamp;
+    static addTimeSpan(A: Timestamp, B: number): number;
+    static subtractTimeSpan(A: Timestamp, B: number): number;
+    static Serialize(): void;
+    static Unserialize(): void;
+}
+//# sourceMappingURL=Timestamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["../../src/core/types/Timestamp.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS;IACb,KAAK,EAAE,MAAM,CAAC;gBAET,KAAK,EAAE,MAAM;IAIlB,QAAQ;IAIR,cAAc,CAAC,MAAM,EAAE,MAAM;IAIpC,OAAc,GAAG,SAAc;IAC/B,OAAc,IAAI,YAAoB;IAE/B,SAAS,CAAC,KAAK,EAAE,SAAS;IAY1B,MAAM,CAAC,GAAG,EAAE,GAAG;IAQf,WAAW;IAIX,OAAO;WAIA,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAIhC,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAItC,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAI1C,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAI7C,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,UAAU,CAAC,KAAK,EAAE,MAAM;WAIxB,QAAQ,CAAC,IAAI,EAAE,IAAI;WAInB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM;WAGnC,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM;WAIxC,SAAS;WAET,WAAW;CAC1B"}

package/core/types/Timestamp.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = void 0;
+var Timestamp = /** @class */ (function () {
+    function Timestamp(value) {
+        this.value = value;
+    }
+    Timestamp.prototype.toString = function () {
+        return new Date(this.value * 1000).toUTCString();
+    };
+    Timestamp.prototype.toStringFormat = function (format) {
+        return new Date(this.value * 1000).toUTCString();
+    };
+    Timestamp.prototype.compareTo = function (other) {
+        if (other.value === this.value) {
+            return 0;
+        }
+        if (this.value < other.value) {
+            return -1;
+        }
+        return 1;
+    };
+    Timestamp.prototype.equals = function (obj) {
+        if (!(obj instanceof Timestamp)) {
+            return false;
+        }
+        return this.value === obj.value;
+    };
+    Timestamp.prototype.getHashCode = function () {
+        return this.value;
+    };
+    Timestamp.prototype.getSize = function () {
+        return 4;
+    };
+    Timestamp.equal = function (A, B) {
+        return A.value === B.value;
+    };
+    Timestamp.notEqual = function (A, B) {
+        return !(A.value === B.value);
+    };
+    Timestamp.lessThan = function (A, B) {
+        return A.value < B.value;
+    };
+    Timestamp.greaterThan = function (A, B) {
+        return A.value > B.value;
+    };
+    Timestamp.lessThanOrEqual = function (A, B) {
+        return A.value <= B.value;
+    };
+    Timestamp.greaterThanOrEqual = function (A, B) {
+        return A.value >= B.value;
+    };
+    Timestamp.subtract = function (A, B) {
+        return A.value - B.value;
+    };
+    Timestamp.fromNumber = function (ticks) {
+        return new Timestamp(ticks);
+    };
+    Timestamp.fromDate = function (time) {
+        return new Timestamp(time.getTime() / 1000);
+    };
+    Timestamp.addTimeSpan = function (A, B) {
+        return A.value + B;
+    };
+    Timestamp.subtractTimeSpan = function (A, B) {
+        return A.value - B;
+    };
+    Timestamp.Serialize = function () { };
+    Timestamp.Unserialize = function () { };
+    Timestamp.now = Date.now();
+    Timestamp.null = new Timestamp(0);
+    return Timestamp;
+}());
+exports.Timestamp = Timestamp;

package/core/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./Consensus";
+export * from "./Timestamp";
+export * from "./Stack";
+export * from "./Address";
+export * from "./Contract";
+export * from "./Ed25519Signature";
+export * from "./PhantasmaKeys";
+export * from "./DomainSettings";
+export * from "./Entropy";
+export * from "./Extensions";
+export * from "./Serialization";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

package/core/types/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Consensus"), exports);
+__exportStar(require("./Timestamp"), exports);
+__exportStar(require("./Stack"), exports);
+__exportStar(require("./Address"), exports);
+__exportStar(require("./Contract"), exports);
+__exportStar(require("./Ed25519Signature"), exports);
+__exportStar(require("./PhantasmaKeys"), exports);
+__exportStar(require("./DomainSettings"), exports);
+__exportStar(require("./Entropy"), exports);
+__exportStar(require("./Extensions"), exports);
+__exportStar(require("./Serialization"), exports);

package/core/utils/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+export declare function hexToByteArray(hexBytes: string): number[];
+export declare function HexToBytes(hex: string): number[];
+export declare function hexToBuffer(hex: string): Uint8Array;
+export declare function bufferToHex(buffer: ArrayBuffer | ArrayLike<number> | Uint8Array): string;
+export declare function hexStringToBytes(hexString: string): any[];
+export declare function byteArrayToHex(arr: ArrayBuffer | ArrayLike<number> | Uint8Array): string;
+export declare function BytesToHex(bytes: Uint8Array | ArrayBuffer | ArrayLike<number>): string;
+export declare function reverseHex(hex: string): string;
+export declare function getDifficulty(transactionHash: string): number;
+export declare function decodeBase16(hex: string): string;
+export declare function encodeBase16(str: string): string;
+export declare function uint8ArrayToString(array: Uint8Array): string;
+export declare function uint8ArrayToStringDefault(array: Uint8Array): string;
+export declare function uint8ArrayToNumberArray(array: Uint8Array): number[];
+export declare function stringToUint8Array(str: string): Uint8Array;
+export declare function hexStringToUint8Array(str: string): Uint8Array;
+export declare function arrayNumberToUint8Array(arr: number[]): Uint8Array;
+export declare function uint8ArrayToBytes(array: Uint8Array): number[];
+export declare function uint8ArrayToHex(arr: Uint8Array): string;
+export declare function numberToByteArray(num: number, size?: number): Uint8Array;
+export declare function bigIntToByteArray(bigint: bigint): Uint8Array;
+export declare const hex2ascii: (hexx: any) => string;
+export declare const Int2Buffer: (i: number) => Buffer;
+//# sourceMappingURL=index.d.ts.map

package/core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/utils/index.ts"],"names":[],"mappings":";AAAA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,YAS9C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,YAErC;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,cAEtC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,UAAU,UAE/E;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,SAIjD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,UAAU,GAAG,MAAM,CAYxF;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,UAE7E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM9C;AAED,wBAAgB,aAAa,CAAC,eAAe,EAAE,MAAM,UAcpD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,UAMvC;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,UAMvC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAM5D;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAMnE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAMnE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAM1D;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAM7D;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,UAAU,CAMjE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAM7D;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAMvD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAwBxE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAQ5D;AAED,eAAO,MAAM,SAAS,uBAUrB,CAAC;AAEF,eAAO,MAAM,UAAU,MAAO,MAAM,KAAG,MAMtC,CAAC"}