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

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

@@ -0,0 +1,123 @@
+import { Decoder } from "./Decoder";
+export var EventKind;
+(function (EventKind) {
+    EventKind[EventKind["Unknown"] = 0] = "Unknown";
+    EventKind[EventKind["ChainCreate"] = 1] = "ChainCreate";
+    EventKind[EventKind["TokenCreate"] = 2] = "TokenCreate";
+    EventKind[EventKind["TokenSend"] = 3] = "TokenSend";
+    EventKind[EventKind["TokenReceive"] = 4] = "TokenReceive";
+    EventKind[EventKind["TokenMint"] = 5] = "TokenMint";
+    EventKind[EventKind["TokenBurn"] = 6] = "TokenBurn";
+    EventKind[EventKind["TokenStake"] = 7] = "TokenStake";
+    EventKind[EventKind["TokenClaim"] = 8] = "TokenClaim";
+    EventKind[EventKind["AddressRegister"] = 9] = "AddressRegister";
+    EventKind[EventKind["AddressLink"] = 10] = "AddressLink";
+    EventKind[EventKind["AddressUnlink"] = 11] = "AddressUnlink";
+    EventKind[EventKind["OrganizationCreate"] = 12] = "OrganizationCreate";
+    EventKind[EventKind["OrganizationAdd"] = 13] = "OrganizationAdd";
+    EventKind[EventKind["OrganizationRemove"] = 14] = "OrganizationRemove";
+    EventKind[EventKind["GasEscrow"] = 15] = "GasEscrow";
+    EventKind[EventKind["GasPayment"] = 16] = "GasPayment";
+    EventKind[EventKind["AddressUnregister"] = 17] = "AddressUnregister";
+    EventKind[EventKind["OrderCreated"] = 18] = "OrderCreated";
+    EventKind[EventKind["OrderCancelled"] = 19] = "OrderCancelled";
+    EventKind[EventKind["OrderFilled"] = 20] = "OrderFilled";
+    EventKind[EventKind["OrderClosed"] = 21] = "OrderClosed";
+    EventKind[EventKind["FeedCreate"] = 22] = "FeedCreate";
+    EventKind[EventKind["FeedUpdate"] = 23] = "FeedUpdate";
+    EventKind[EventKind["FileCreate"] = 24] = "FileCreate";
+    EventKind[EventKind["FileDelete"] = 25] = "FileDelete";
+    EventKind[EventKind["ValidatorPropose"] = 26] = "ValidatorPropose";
+    EventKind[EventKind["ValidatorElect"] = 27] = "ValidatorElect";
+    EventKind[EventKind["ValidatorRemove"] = 28] = "ValidatorRemove";
+    EventKind[EventKind["ValidatorSwitch"] = 29] = "ValidatorSwitch";
+    EventKind[EventKind["PackedNFT"] = 30] = "PackedNFT";
+    EventKind[EventKind["ValueCreate"] = 31] = "ValueCreate";
+    EventKind[EventKind["ValueUpdate"] = 32] = "ValueUpdate";
+    EventKind[EventKind["PollCreated"] = 33] = "PollCreated";
+    EventKind[EventKind["PollClosed"] = 34] = "PollClosed";
+    EventKind[EventKind["PollVote"] = 35] = "PollVote";
+    EventKind[EventKind["ChannelCreate"] = 36] = "ChannelCreate";
+    EventKind[EventKind["ChannelRefill"] = 37] = "ChannelRefill";
+    EventKind[EventKind["ChannelSettle"] = 38] = "ChannelSettle";
+    EventKind[EventKind["LeaderboardCreate"] = 39] = "LeaderboardCreate";
+    EventKind[EventKind["LeaderboardInsert"] = 40] = "LeaderboardInsert";
+    EventKind[EventKind["LeaderboardReset"] = 41] = "LeaderboardReset";
+    EventKind[EventKind["PlatformCreate"] = 42] = "PlatformCreate";
+    EventKind[EventKind["ChainSwap"] = 43] = "ChainSwap";
+    EventKind[EventKind["ContractRegister"] = 44] = "ContractRegister";
+    EventKind[EventKind["ContractDeploy"] = 45] = "ContractDeploy";
+    EventKind[EventKind["AddressMigration"] = 46] = "AddressMigration";
+    EventKind[EventKind["ContractUpgrade"] = 47] = "ContractUpgrade";
+    EventKind[EventKind["Log"] = 48] = "Log";
+    EventKind[EventKind["Inflation"] = 49] = "Inflation";
+    EventKind[EventKind["OrderBid"] = 59] = "OrderBid";
+    EventKind[EventKind["MasterClaim"] = 61] = "MasterClaim";
+    EventKind[EventKind["Custom"] = 64] = "Custom";
+})(EventKind || (EventKind = {}));
+export var TypeAuction;
+(function (TypeAuction) {
+    TypeAuction[TypeAuction["Fixed"] = 0] = "Fixed";
+    TypeAuction[TypeAuction["Classic"] = 1] = "Classic";
+    TypeAuction[TypeAuction["Reserve"] = 2] = "Reserve";
+    TypeAuction[TypeAuction["Dutch"] = 3] = "Dutch";
+})(TypeAuction || (TypeAuction = {}));
+export function decodeVMObject(str) {
+    var dec = new Decoder(str);
+    return dec.readVmObject();
+}
+export function getTokenEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        symbol: dec.readString(),
+        value: dec.readBigIntAccurate(),
+        chainName: dec.readString(),
+    };
+}
+export function getChainValueEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        name: dec.readString,
+        value: dec.readBigInt(),
+    };
+}
+export function getTransactionSettleEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        hash: dec.read(dec.readByte()),
+        platform: dec.readString(),
+        chain: dec.readString(),
+    };
+    // public readonly Hash Hash;
+}
+export function getGasEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        address: dec.read(dec.readByte()),
+        price: dec.readBigInt(),
+        amount: dec.readBigInt(),
+        endAmount: dec.isEnd() ? 0 : dec.readBigInt(),
+    };
+}
+export function getInfusionEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        baseSymbol: dec.readString(),
+        TokenID: dec.readBigIntAccurate(),
+        InfusedSymbol: dec.readString(),
+        InfusedValue: dec.readBigIntAccurate(),
+        ChainName: dec.readString(),
+    };
+}
+export function getMarketEventData(str) {
+    var dec = new Decoder(str);
+    return {
+        baseSymbol: dec.readString(),
+        quoteSymbol: dec.readString(),
+        id: dec.readBigIntAccurate(),
+        amount: dec.readBigInt(),
+    };
+}
+export function getString(str) {
+    return new Decoder(str).readString();
+}

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

@@ -0,0 +1,66 @@
+export var Opcode;
+(function (Opcode) {
+    Opcode[Opcode["NOP"] = 0] = "NOP";
+    // register
+    Opcode[Opcode["MOVE"] = 1] = "MOVE";
+    Opcode[Opcode["COPY"] = 2] = "COPY";
+    Opcode[Opcode["PUSH"] = 3] = "PUSH";
+    Opcode[Opcode["POP"] = 4] = "POP";
+    Opcode[Opcode["SWAP"] = 5] = "SWAP";
+    // flow
+    Opcode[Opcode["CALL"] = 6] = "CALL";
+    Opcode[Opcode["EXTCALL"] = 7] = "EXTCALL";
+    Opcode[Opcode["JMP"] = 8] = "JMP";
+    Opcode[Opcode["JMPIF"] = 9] = "JMPIF";
+    Opcode[Opcode["JMPNOT"] = 10] = "JMPNOT";
+    Opcode[Opcode["RET"] = 11] = "RET";
+    Opcode[Opcode["THROW"] = 12] = "THROW";
+    // data
+    Opcode[Opcode["LOAD"] = 13] = "LOAD";
+    Opcode[Opcode["CAST"] = 14] = "CAST";
+    Opcode[Opcode["CAT"] = 15] = "CAT";
+    Opcode[Opcode["RANGE"] = 16] = "RANGE";
+    Opcode[Opcode["LEFT"] = 17] = "LEFT";
+    Opcode[Opcode["RIGHT"] = 18] = "RIGHT";
+    Opcode[Opcode["SIZE"] = 19] = "SIZE";
+    Opcode[Opcode["COUNT"] = 20] = "COUNT";
+    // logical
+    Opcode[Opcode["NOT"] = 21] = "NOT";
+    Opcode[Opcode["AND"] = 22] = "AND";
+    Opcode[Opcode["OR"] = 23] = "OR";
+    Opcode[Opcode["XOR"] = 24] = "XOR";
+    Opcode[Opcode["EQUAL"] = 25] = "EQUAL";
+    Opcode[Opcode["LT"] = 26] = "LT";
+    Opcode[Opcode["GT"] = 27] = "GT";
+    Opcode[Opcode["LTE"] = 28] = "LTE";
+    Opcode[Opcode["GTE"] = 29] = "GTE";
+    // numeric
+    Opcode[Opcode["INC"] = 30] = "INC";
+    Opcode[Opcode["DEC"] = 31] = "DEC";
+    Opcode[Opcode["SIGN"] = 32] = "SIGN";
+    Opcode[Opcode["NEGATE"] = 33] = "NEGATE";
+    Opcode[Opcode["ABS"] = 34] = "ABS";
+    Opcode[Opcode["ADD"] = 35] = "ADD";
+    Opcode[Opcode["SUB"] = 36] = "SUB";
+    Opcode[Opcode["MUL"] = 37] = "MUL";
+    Opcode[Opcode["DIV"] = 38] = "DIV";
+    Opcode[Opcode["MOD"] = 39] = "MOD";
+    Opcode[Opcode["SHL"] = 40] = "SHL";
+    Opcode[Opcode["SHR"] = 41] = "SHR";
+    Opcode[Opcode["MIN"] = 42] = "MIN";
+    Opcode[Opcode["MAX"] = 43] = "MAX";
+    Opcode[Opcode["POW"] = 44] = "POW";
+    // context
+    Opcode[Opcode["CTX"] = 45] = "CTX";
+    Opcode[Opcode["SWITCH"] = 46] = "SWITCH";
+    // array
+    Opcode[Opcode["PUT"] = 47] = "PUT";
+    Opcode[Opcode["GET"] = 48] = "GET";
+    Opcode[Opcode["CLEAR"] = 49] = "CLEAR";
+    Opcode[Opcode["UNPACK"] = 50] = "UNPACK";
+    Opcode[Opcode["PACK"] = 51] = "PACK";
+    //  debugger
+    Opcode[Opcode["DEBUG"] = 52] = "DEBUG";
+    // add
+    Opcode[Opcode["SUBSTR"] = 53] = "SUBSTR";
+})(Opcode || (Opcode = {}));

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

@@ -0,0 +1,479 @@
+import base58 from 'bs58';
+import { ISerializable } from '../interfaces';
+import { Address, PBinaryWriter, Serialization, Timestamp } from '../types';
+import { numberToByteArray, stringToUint8Array, bytesToHex } from '../utils';
+import { Opcode } from './Opcode';
+import { VMObject } from './VMObject';
+import { VMType } from './VMType';
+import { Contracts } from './Contracts';
+const MaxRegisterCount = 32;
+export class ScriptBuilder {
+    static ScriptBuilder() {
+        return new ScriptBuilder();
+    }
+    constructor() {
+        this._labelLocations = {};
+        this._jumpLocations = {};
+        this.NullAddress = 'S1111111111111111111111111111111111';
+        this.str = '';
+        this.writer = new PBinaryWriter();
+    }
+    BeginScript() {
+        this.str = '';
+        this.writer = new PBinaryWriter();
+        return this;
+    }
+    GetScript() {
+        return bytesToHex(this.writer.toUint8Array());
+    }
+    EndScript() {
+        this.Emit(Opcode.RET);
+        return bytesToHex(this.writer.toUint8Array()).toUpperCase();
+    }
+    Emit(opcode, bytes) {
+        this.AppendByte(opcode);
+        if (bytes) {
+            this.EmitBytes(bytes);
+        }
+        return this;
+    }
+    EmitThorw(reg) {
+        this.Emit(Opcode.THROW);
+        this.AppendByte(reg);
+        return this;
+    }
+    EmitPush(reg) {
+        this.Emit(Opcode.PUSH);
+        this.AppendByte(reg);
+        return this;
+    }
+    EmitPop(reg) {
+        this.Emit(Opcode.POP);
+        this.AppendByte(reg);
+        return this;
+    }
+    EmitExtCall(method, reg = 0) {
+        this.EmitLoad(reg, method);
+        this.Emit(Opcode.EXTCALL);
+        this.AppendByte(reg);
+        return this;
+    }
+    EmitBigInteger(value) {
+        let bytes = [];
+        if (value == '0') {
+            bytes = [0];
+        }
+        else if (value.startsWith('-1')) {
+            throw new Error('Unsigned bigint serialization not suppoted');
+        }
+        else {
+            let hex = BigInt(value).toString(16);
+            if (hex.length % 2)
+                hex = '0' + hex;
+            const len = hex.length / 2;
+            var i = 0;
+            var j = 0;
+            while (i < len) {
+                bytes.unshift(parseInt(hex.slice(j, j + 2), 16)); // little endian
+                i += 1;
+                j += 2;
+            }
+            bytes.push(0); // add sign at the end
+        }
+        return this.EmitByteArray(bytes);
+    }
+    EmitAddress(textAddress) {
+        const bytes = [...base58.decode(textAddress.substring(1))];
+        return this.EmitByteArray(bytes);
+    }
+    RawString(value) {
+        //let bytes = stringToUint8Array(value);
+        //console.log(Array.from(bytes))
+        //return Array.from(bytes);
+        var data = [];
+        for (var i = 0; i < value.length; i++) {
+            data.push(value.charCodeAt(i));
+        }
+        return data;
+    }
+    EmitLoad(reg, obj) {
+        let structType = Object.getPrototypeOf(obj).constructor.name;
+        switch (typeof obj) {
+            case 'string': {
+                let bytes = this.RawString(obj);
+                this.EmitLoadBytes(reg, bytes, VMType.String);
+                break;
+            }
+            case 'boolean': {
+                let bytes = [obj ? 1 : 0];
+                this.EmitLoadBytes(reg, bytes, VMType.Bool);
+                break;
+            }
+            case 'number': {
+                // obj is BigInteger
+                // var bytes = val.ToSignedByteArray();
+                // this.emitLoadBytes(reg, bytes, VMType.Number);
+                //let bytes = this.RawString(BigInt(obj).toString());
+                if (Object.getPrototypeOf(structType).constructor.name == 'enum') {
+                    this.AppendByte(obj);
+                }
+                else {
+                    // this.EmitLoadVarInt(reg, obj);
+                    let bytes = this.RawString(obj.toString());
+                    this.EmitLoadBytes(reg, bytes, VMType.String);
+                }
+                break;
+            }
+            case 'object':
+                if (obj instanceof Uint8Array) {
+                    this.EmitLoadBytes(reg, Array.from(obj));
+                }
+                else if (obj instanceof VMObject) {
+                    this.EmitLoadVMObject(reg, obj);
+                }
+                else if (Array.isArray(obj)) {
+                    this.EmitLoadArray(reg, obj);
+                }
+                else if (obj instanceof Date || obj instanceof Timestamp) {
+                    this.EmitLoadTimestamp(reg, obj);
+                }
+                else if (obj instanceof Address) {
+                    this.EmitLoadAddress(reg, obj);
+                }
+                else if ((typeof obj.UnserializeData === 'function' && typeof obj.SerializeData === 'function') ||
+                    obj instanceof ISerializable) {
+                    this.EmitLoadISerializable(reg, obj);
+                }
+                else {
+                    if (Array.isArray(obj)) {
+                        this.EmitLoadArray(reg, obj);
+                    }
+                    else {
+                        throw Error('Load type ' + typeof obj + ' not supported');
+                    }
+                }
+                break;
+            default:
+                throw Error('Load type ' + typeof obj + ' not supported');
+        }
+        return this;
+    }
+    EmitLoadBytes(reg, bytes, type = VMType.Bytes) {
+        if (bytes.length > 0xffff)
+            throw new Error('tried to load too much data');
+        this.Emit(Opcode.LOAD);
+        this.AppendByte(reg);
+        this.AppendByte(type);
+        this.EmitVarInt(bytes.length);
+        this.EmitBytes(bytes);
+        return this;
+    }
+    EmitLoadArray(reg, obj) {
+        this.Emit(Opcode.CAST, [reg, reg, VMType.None]);
+        for (let i = 0; i < obj.length; i++) {
+            let element = obj[i];
+            let temp_regVal = reg + 1;
+            let temp_regKey = reg + 2;
+            this.EmitLoad(temp_regVal, element);
+            this.EmitLoad(temp_regKey, i);
+            this.Emit(Opcode.PUT, [temp_regVal, reg, temp_regKey]);
+            //this.EmitLoad(reg, element);
+            //this.EmitPush(reg);
+            //reg++;
+        }
+        return this;
+    }
+    EmitLoadISerializable(reg, obj) {
+        let writer = new PBinaryWriter();
+        obj.SerializeData(writer);
+        this.EmitLoadBytes(reg, writer.toArray(), VMType.Bytes);
+        return this;
+    }
+    EmitLoadVMObject(reg, obj) {
+        let writer = new PBinaryWriter();
+        let result = obj.SerializeObjectCall(writer);
+        this.Emit(Opcode.LOAD);
+        this.AppendByte(reg);
+        this.AppendByte(obj.Type);
+        if (result == undefined) {
+            //console.log("enter");
+            if (obj.Data instanceof Map || (obj.Data instanceof Map && obj.Data instanceof VMObject)) {
+                let resultData = obj.Data;
+                this.EmitVarInt(resultData.size);
+                for (let entry of resultData) {
+                    //console.log(entry[0]);
+                    let key = entry[0];
+                    let value = entry[1];
+                    this.EmitLoadVMObject(reg + 1, key);
+                    this.EmitLoadVMObject(reg + 2, value);
+                    this.Emit(Opcode.PUT, [reg + 1, reg, reg + 2]);
+                }
+            }
+            else if (obj.Data instanceof VMObject) {
+                let writerNew = new PBinaryWriter();
+                let bytes = obj.Data.SerializeData(writerNew);
+                //console.log(bytes.length);
+                this.EmitVarInt(bytes.length);
+                this.AppendBytes(Array.from(bytes));
+            }
+        }
+        else {
+            //console.log("reg", reg);
+            var bytes = Array.from(result);
+            //console.log(bytes.length);
+            this.EmitVarInt(bytes.length);
+            this.AppendBytes(bytes);
+        }
+        //this.EmitLoadBytes(reg, Array.from(result), obj.Type);
+        return this;
+    }
+    EmitLoadEnum(reg, enumVal) {
+        // var temp = Convert.ToUInt32(enumVal);
+        // var bytes = BitConverter.GetBytes(temp);
+        let bytes = [0, 0, 0, 0];
+        for (let i = 0; i < bytes.length; i++) {
+            var byte = enumVal & 0xff;
+            bytes[i] = byte;
+            enumVal = (enumVal - byte) / 256;
+        }
+        this.EmitLoadBytes(reg, bytes, VMType.Enum);
+        return this;
+    }
+    EmitLoadAddress(reg, obj) {
+        let writer = new PBinaryWriter();
+        obj.SerializeData(writer);
+        let byteArray = Array.from(writer.toUint8Array());
+        this.EmitLoadBytes(reg, byteArray, VMType.Bytes);
+        return this;
+    }
+    EmitLoadTimestamp(reg, obj) {
+        if (obj instanceof Timestamp) {
+            let bytes = Array.from(Serialization.Serialize(obj));
+            this.EmitLoadBytes(reg, bytes, VMType.Timestamp);
+        }
+        else if (obj instanceof Date) {
+            let num = (obj.getTime() / 1000) | 0;
+            let a = (num & 0xff000000) >> 24;
+            let b = (num & 0x00ff0000) >> 16;
+            let c = (num & 0x0000ff00) >> 8;
+            let d = num & 0x000000ff;
+            let bytes = [d, c, b, a];
+            this.EmitLoadBytes(reg, bytes, VMType.Timestamp);
+        }
+        return this;
+    }
+    EmitLoadVarInt(reg, val) {
+        let bytes = numberToByteArray(val);
+        this.Emit(Opcode.LOAD);
+        this.AppendByte(reg);
+        this.AppendByte(VMType.Number);
+        this.AppendByte(bytes.length);
+        this.EmitBytes(Array.from(bytes));
+        return this;
+    }
+    EmitMove(src_reg, dst_reg) {
+        this.Emit(Opcode.MOVE);
+        this.AppendByte(src_reg);
+        this.AppendByte(dst_reg);
+        return this;
+    }
+    EmitCopy(src_reg, dst_reg) {
+        this.Emit(Opcode.COPY);
+        this.AppendByte(src_reg);
+        this.AppendByte(dst_reg);
+        return this;
+    }
+    EmitLabel(label) {
+        this.Emit(Opcode.NOP);
+        this._labelLocations[label] = this.str.length;
+        return this;
+    }
+    EmitJump(opcode, label, reg = 0) {
+        switch (opcode) {
+            case Opcode.JMP:
+            case Opcode.JMPIF:
+            case Opcode.JMPNOT:
+                this.Emit(opcode);
+                break;
+            default:
+                throw new Error('Invalid jump opcode: ' + opcode);
+        }
+        if (opcode != Opcode.JMP) {
+            this.AppendByte(reg);
+        }
+        var ofs = this.str.length;
+        this.AppendUshort(0);
+        this._jumpLocations[ofs] = label;
+        return this;
+    }
+    EmitCall(label, regCount) {
+        if (regCount < 1 || regCount > MaxRegisterCount) {
+            throw new Error('Invalid number of registers');
+        }
+        var ofs = this.str.length; //(int)stream.Position;
+        ofs += 2;
+        this.Emit(Opcode.CALL);
+        this.AppendByte(regCount);
+        this.AppendUshort(0);
+        this._jumpLocations[ofs] = label;
+        return this;
+    }
+    EmitConditionalJump(opcode, src_reg, label) {
+        if (opcode != Opcode.JMPIF && opcode != Opcode.JMPNOT) {
+            throw new Error('Opcode is not a conditional jump');
+        }
+        var ofs = this.str.length;
+        ofs += 2;
+        this.Emit(opcode);
+        this.AppendByte(src_reg);
+        this.AppendUshort(0);
+        this._jumpLocations[ofs] = label;
+        return this;
+    }
+    InsertMethodArgs(args) {
+        let temp_reg = 0;
+        for (let i = args.length - 1; i >= 0; i--) {
+            let arg = args[i];
+            this.EmitLoad(temp_reg, arg);
+            this.EmitPush(temp_reg);
+        }
+    }
+    CallInterop(method, args) {
+        this.InsertMethodArgs(args);
+        let dest_reg = 0;
+        this.EmitLoad(dest_reg, method);
+        this.Emit(Opcode.EXTCALL, [dest_reg]);
+        return this;
+    }
+    CallContract(contractName, method, args) {
+        this.InsertMethodArgs(args);
+        let temp_reg = 0;
+        this.EmitLoad(temp_reg, method);
+        this.EmitPush(temp_reg);
+        let src_reg = 0;
+        let dest_reg = 1;
+        this.EmitLoad(src_reg, contractName);
+        this.Emit(Opcode.CTX, [src_reg, dest_reg]);
+        this.Emit(Opcode.SWITCH, [dest_reg]);
+        return this;
+    }
+    //#region ScriptBuilderExtensions
+    AllowGas(from, to, gasPrice, gasLimit) {
+        return this.CallContract(Contracts.GasContractName, 'AllowGas', [from, to, gasPrice, gasLimit]);
+    }
+    SpendGas(address) {
+        return this.CallContract(Contracts.GasContractName, 'SpendGas', [address]);
+    }
+    async CallRPC(methodName, params) {
+        return 'bla';
+    }
+    async GetAddressTransactionCount(address, chainInput) {
+        let params = [address, chainInput];
+        return await this.CallRPC('getAddressTransactionCount', params);
+    }
+    //#endregion
+    EmitTimestamp(obj) {
+        let num = (obj.getTime() / 1000) | 0;
+        let a = (num & 0xff000000) >> 24;
+        let b = (num & 0x00ff0000) >> 16;
+        let c = (num & 0x0000ff00) >> 8;
+        let d = num & 0x000000ff;
+        let bytes = [d, c, b, a];
+        this.AppendBytes(bytes);
+        return this;
+    }
+    EmitByteArray(bytes) {
+        this.EmitVarInt(bytes.length);
+        this.EmitBytes(bytes);
+        return this;
+    }
+    EmitVarString(text) {
+        let bytes = this.RawString(text);
+        this.EmitVarInt(bytes.length);
+        this.EmitBytes(bytes);
+        return this;
+    }
+    EmitVarInt(value) {
+        if (value < 0)
+            throw 'negative value invalid';
+        if (value < 0xfd) {
+            this.AppendByte(value);
+        }
+        else if (value <= 0xffff) {
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.AppendByte(0xfd);
+            this.AppendByte(A);
+            this.AppendByte(B);
+        }
+        else if (value <= 0xffffffff) {
+            let C = (value & 0x00ff0000) >> 16;
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.AppendByte(0xfe);
+            this.AppendByte(A);
+            this.AppendByte(B);
+            this.AppendByte(C);
+        }
+        else {
+            let D = (value & 0xff000000) >> 24;
+            let C = (value & 0x00ff0000) >> 16;
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.AppendByte(0xff);
+            this.AppendByte(A);
+            this.AppendByte(B);
+            this.AppendByte(C);
+            this.AppendByte(D);
+        }
+        return this;
+    }
+    EmitUInt32(value) {
+        if (value < 0)
+            throw 'negative value invalid';
+        let D = (value & 0xff000000) >> 24;
+        let C = (value & 0x00ff0000) >> 16;
+        let B = (value & 0x0000ff00) >> 8;
+        let A = value & 0x000000ff;
+        // TODO check if the endianess is correct, might have to reverse order of appends
+        this.AppendByte(0xff);
+        this.AppendByte(A);
+        this.AppendByte(B);
+        this.AppendByte(C);
+        this.AppendByte(D);
+        return this;
+    }
+    EmitBytes(bytes) {
+        for (let i = 0; i < bytes.length; i++)
+            this.AppendByte(bytes[i]);
+        // writer.Write(bytes);
+        return this;
+    }
+    //Custom Modified
+    ByteToHex(byte) {
+        let result = ('0' + (byte & 0xff).toString(16)).slice(-2);
+        return result;
+    }
+    AppendByte(byte) {
+        this.str += this.ByteToHex(byte);
+        this.writer.writeByte(byte);
+    }
+    //Custom Modified
+    AppendBytes(bytes) {
+        for (let i = 0; i < bytes.length; i++) {
+            this.AppendByte(bytes[i]);
+        }
+    }
+    AppendUshort(ushort) {
+        this.str += this.ByteToHex(ushort & 0xff) + this.ByteToHex((ushort >> 8) & 0xff);
+        this.writer.writeUnsignedShort(ushort);
+    }
+    AppendHexEncoded(bytes) {
+        this.str += bytes;
+        this.writer.writeBytes(Array.from(stringToUint8Array(bytes)));
+        return this;
+    }
+}