phantasma-sdk-ts 0.2.0-rc.9 → 0.2.0

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

@@ -0,0 +1,185 @@
+import { PBinaryReader, PBinaryWriter } from "./Extensions";
+import { Timestamp } from "./Timestamp";
+import { stringToUint8Array } from "../utils";
+//function CustomWriter(writer: PBinaryWriter, obj: any): void;
+//function CustomReader(reader: PBinaryReader): any;
+export class CustomSerializer {
+    constructor(reader, writer) {
+        this.Read = reader;
+        this.Write = writer;
+    }
+}
+export class Serialization {
+    static RegisterType(type, reader, writer) {
+        Serialization._customSerializers[typeof type] = new CustomSerializer(reader, writer);
+    }
+    static SerializeEnum(obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        let writer = new PBinaryWriter();
+        writer.writeEnum(obj);
+        return writer.toUint8Array();
+    }
+    static Serialize(obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        //let jsonString = JSON.stringify(obj);
+        let writer = new PBinaryWriter();
+        this.SerializeObject(writer, obj, typeof obj);
+        //let jsonAsUint8 = new TextEncoder().encode(jsonString);
+        return writer.toUint8Array();
+    }
+    static SerializeObject(writer, obj, type) {
+        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;
+        }*/
+        const structType = Object.getPrototypeOf(obj).constructor.name;
+        const result = Object.apply(structType);
+        let 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(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) {
+            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((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
+            const fields = Object.keys(obj);
+            fields.forEach((field) => {
+                let value = obj[field];
+                this.SerializeObject(writer, value, typeof value);
+            });
+        }
+    }
+    static Unserialize(bytesOrBytes, type) {
+        if (bytesOrBytes instanceof PBinaryReader) {
+            return Serialization.UnserializeObject(bytesOrBytes, type);
+        }
+        if (!bytesOrBytes || bytesOrBytes.length === 0) {
+            return null;
+        }
+        //let type = Object.prototype.propertyIsEnumerable(T);
+        let stream = new PBinaryReader(bytesOrBytes);
+        return Serialization.UnserializeObject(stream, type);
+    }
+    static UnserializeObject(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;
+        }
+        let localType; //: typeof type;
+        if (type.name != undefined) {
+            let 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) {
+            return new Timestamp(reader.readVarInt());
+        }
+        else if (typeof localType.UnserializeData === "function" &&
+            typeof localType.SerializeData === "function") {
+            let obj = localType;
+            obj.UnserializeData(reader);
+            return obj;
+        }
+        else if (Array.isArray(type)) {
+            var len = reader.readByte();
+            var arr = new Array(len);
+            for (let i = 0; i < len; i++) {
+                arr[i] = this.UnserializeObject(reader, type[i]);
+            }
+            return arr;
+        }
+        else if (Object.getPrototypeOf(type) == "enum") {
+            return reader.readByte();
+        }
+        else {
+            const 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 };

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

@@ -0,0 +1,36 @@
+export class Stack {
+    constructor(capacity = Infinity) {
+        this.capacity = capacity;
+        this.storage = [];
+    }
+    push(item) {
+        if (this.size() === this.capacity) {
+            throw Error("Stack has reached max capacity, you cannot add more items");
+        }
+        this.storage.push(item);
+    }
+    pop() {
+        return this.storage.pop();
+    }
+    peek() {
+        return this.storage[this.size() - 1];
+    }
+    size() {
+        return this.storage.length;
+    }
+    isEmpty() {
+        return this.size() === 0;
+    }
+    toArray() {
+        return this.storage;
+    }
+    clear() {
+        this.storage = [];
+    }
+    toString() {
+        return this.storage.toString();
+    }
+    isFull() {
+        return this.capacity === this.size();
+    }
+}

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

@@ -0,0 +1,69 @@
+export class Timestamp {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return new Date(this.value * 1000).toUTCString();
+    }
+    toStringFormat(format) {
+        return new Date(this.value * 1000).toUTCString();
+    }
+    compareTo(other) {
+        if (other.value === this.value) {
+            return 0;
+        }
+        if (this.value < other.value) {
+            return -1;
+        }
+        return 1;
+    }
+    equals(obj) {
+        if (!(obj instanceof Timestamp)) {
+            return false;
+        }
+        return this.value === obj.value;
+    }
+    getHashCode() {
+        return this.value;
+    }
+    getSize() {
+        return 4;
+    }
+    static equal(A, B) {
+        return A.value === B.value;
+    }
+    static notEqual(A, B) {
+        return !(A.value === B.value);
+    }
+    static lessThan(A, B) {
+        return A.value < B.value;
+    }
+    static greaterThan(A, B) {
+        return A.value > B.value;
+    }
+    static lessThanOrEqual(A, B) {
+        return A.value <= B.value;
+    }
+    static greaterThanOrEqual(A, B) {
+        return A.value >= B.value;
+    }
+    static subtract(A, B) {
+        return A.value - B.value;
+    }
+    static fromNumber(ticks) {
+        return new Timestamp(ticks);
+    }
+    static fromDate(time) {
+        return new Timestamp(time.getTime() / 1000);
+    }
+    static addTimeSpan(A, B) {
+        return A.value + B;
+    }
+    static subtractTimeSpan(A, B) {
+        return A.value - B;
+    }
+    static Serialize() { }
+    static Unserialize() { }
+}
+Timestamp.now = Date.now();
+Timestamp.null = new Timestamp(0);

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

@@ -0,0 +1,13 @@
+export * from "./Carbon";
+export * from "./CarbonSerialization";
+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";

package/dist/esm/core/utils/Hex.js

@@ -0,0 +1,26 @@
+const HEX_LUT = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+export function bytesToHex(bytes) {
+    const len = bytes.length >>> 0;
+    let out = '';
+    for (let i = 0; i < len; i++) {
+        const v = Number(bytes[i]);
+        if (!Number.isInteger(v) || v < 0 || v > 255) {
+            throw new Error(`Invalid byte at index ${i}: ${v}`);
+        }
+        out += HEX_LUT[v];
+    }
+    return out;
+}
+export function hexToBytes(hex) {
+    if (hex.startsWith('0x')) {
+        hex = hex.slice(2);
+    }
+    if (hex.length % 2 !== 0) {
+        throw new Error(`Invalid hex string length ${hex.length} hex: ${hex}`);
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}

package/dist/esm/core/utils/index.js

@@ -0,0 +1,141 @@
+import { hexToBytes } from './Hex';
+export * from './Hex';
+export function reverseHex(hex) {
+    let out = '';
+    for (let i = hex.length - 2; i >= 0; i -= 2) {
+        out += hex.substr(i, 2);
+    }
+    return out;
+}
+export function getDifficulty(transactionHash) {
+    let bytes = hexToBytes(transactionHash).reverse();
+    let result = 0;
+    for (let i = 0; i < bytes.length; i++) {
+        var n = bytes[i];
+        for (let j = 0; j < 8; j++) {
+            if ((bytes[i] & (1 << j)) != 0) {
+                result = 1 + (i << 3) + j;
+            }
+        }
+    }
+    return 256 - result;
+}
+export function decodeBase16(hex) {
+    let str = '';
+    for (let i = 0; i < hex.length; i += 2) {
+        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+}
+export function encodeBase16(str) {
+    return str
+        .split('')
+        .map((c) => c.charCodeAt(0).toString(16).padStart(2, '0'))
+        .join('')
+        .toUpperCase();
+}
+export function uint8ArrayToString(array) {
+    let result = '';
+    for (let i = 0; i < array.length; i++) {
+        result += String.fromCharCode(array[i]);
+    }
+    return result;
+}
+export function uint8ArrayToStringDefault(array) {
+    let result = '';
+    for (let i = 0; i < array.length; i++) {
+        result += array[i].toString(16);
+    }
+    return result;
+}
+export function uint8ArrayToNumberArray(array) {
+    let result = [];
+    for (let i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+export function stringToUint8Array(str) {
+    let result = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i);
+    }
+    return result;
+}
+export function hexStringToUint8Array(str) {
+    let result = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i).toString(16).charCodeAt(0);
+    }
+    return result;
+}
+export function arrayNumberToUint8Array(arr) {
+    let result = new Uint8Array(arr.length);
+    for (let i = 0; i < arr.length; i++) {
+        result[i] = arr[i];
+    }
+    return result;
+}
+export function uint8ArrayToBytes(array) {
+    let result = [];
+    for (let i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+export function numberToByteArray(num, size) {
+    if (size === undefined) {
+        if (num < 0xfd) {
+            size = 1;
+        }
+        else if (num <= 0xfffd) {
+            size = 2;
+        }
+        else if (num <= 0xffffd) {
+            size = 3;
+        }
+        else if (num <= 0xfffffffd) {
+            size = 4;
+        }
+        else if (num <= 0xffffffff) {
+            size = 5;
+        }
+        else if (num <= 0xffffffffffffffff) {
+            size = 9;
+        }
+    }
+    var bytes = new Uint8Array(size);
+    var i = 0;
+    do {
+        bytes[i++] = num & 0xff;
+        num = num >> 8;
+    } while (num);
+    return bytes;
+}
+export function bigIntToByteArray(bigint) {
+    // Get a big-endian byte representation of the bigint
+    var bytes = bigint.toString(16).padStart(64, '0');
+    var byteArray = new Uint8Array(bytes.length / 2);
+    for (var i = 0; i < bytes.length; i += 2) {
+        byteArray[i / 2] = parseInt(bytes.substring(i, i + 2), 16);
+    }
+    return byteArray;
+}
+export const hex2ascii = (hexx) => {
+    const hex = hexx.toString();
+    let str = '';
+    for (let i = 0; i < hex.length; i += 2) {
+        const char = hex.substr(i, 2);
+        const charCode = String.fromCharCode(parseInt(char, 16));
+        // console.log('char', char, 'charCode', charCode);
+        str += charCode;
+    }
+    return str;
+};
+export const Int2Buffer = (i) => {
+    let hex = i.toString(16).toUpperCase();
+    if (hex.length % 2 === 1) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+};

package/dist/esm/core/vm/Contracts.js

@@ -0,0 +1,17 @@
+export var Contracts;
+(function (Contracts) {
+    Contracts["GasContractName"] = "gas";
+    Contracts["BlockContractName"] = "block";
+    Contracts["StakeContractName"] = "stake";
+    Contracts["SwapContractName"] = "swap";
+    Contracts["AccountContractName"] = "account";
+    Contracts["ConsensusContractName"] = "consensus";
+    Contracts["GovernanceContractName"] = "governance";
+    Contracts["StorageContractName"] = "storage";
+    Contracts["ValidatorContractName"] = "validator";
+    Contracts["InteropContractName"] = "interop";
+    Contracts["ExchangeContractName"] = "exchange";
+    Contracts["PrivacyContractName"] = "privacy";
+    Contracts["RelayContractName"] = "relay";
+    Contracts["RankingContractName"] = "ranking";
+})(Contracts || (Contracts = {}));

package/dist/esm/core/vm/Decoder.js

@@ -0,0 +1,146 @@
+import bigInt from "big-integer";
+import { ISignature, SignatureKind } from "../interfaces";
+import { VMType } from "./VMType";
+export class Decoder {
+    constructor(str) {
+        this.str = str;
+    }
+    isEnd() {
+        return this.str.length == 0;
+    }
+    readCharPair() {
+        var res = this.str.substr(0, 2);
+        this.str = this.str.slice(2);
+        return res;
+    }
+    readByte() {
+        return parseInt(this.readCharPair(), 16);
+    }
+    read(numBytes) {
+        var res = this.str.substr(0, numBytes * 2);
+        this.str = this.str.slice(numBytes * 2);
+        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;
+    }
+    readByteArray() {
+        var res;
+        var length = this.readVarInt();
+        if (length == 0)
+            return [];
+        res = this.read(length);
+        return res;
+    }
+    readSignature() {
+        let kind = this.readByte();
+        let signature = new ISignature();
+        let curve;
+        signature.kind = kind;
+        switch (kind) {
+            case SignatureKind.None:
+                return null;
+            case SignatureKind.Ed25519:
+                let len = this.readVarInt();
+                signature.signature = this.read(len);
+                break;
+            case SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.signature = this.readString();
+                break;
+            default:
+                throw "read signature: " + kind;
+        }
+        return signature;
+    }
+    readTimestamp() {
+        //var len = this.readByte();
+        let result = 0;
+        let bytes = this.read(4);
+        bytes
+            .match(/.{1,2}/g)
+            .reverse()
+            .forEach((c) => (result = result * 256 + parseInt(c, 16)));
+        return result;
+    }
+    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;
+    }
+    readBigInt() {
+        // 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)));
+        return res;
+    }
+    readBigIntAccurate() {
+        var len = this.readVarInt();
+        var res = bigInt();
+        var stringBytes = this.read(len);
+        [...stringBytes.match(/.{1,2}/g)].reverse().forEach((c) => {
+            res = res.times(256).plus(parseInt(c, 16));
+        });
+        return res.toString();
+    }
+    readVmObject() {
+        const type = this.readByte();
+        console.log("type", type);
+        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();
+                    console.log("  key", key);
+                    const value = this.readVmObject();
+                    console.log("  value", value);
+                    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;
+        }
+    }
+}

package/dist/esm/core/vm/Disassembler.js

@@ -0,0 +1,2 @@
+export class Dissassembler {
+}