phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/vm/script-builder.js

@@ -0,0 +1,713 @@
+import base58 from 'bs58';
+import { isSerializableLike, serializeSerializable, } from '../interfaces/index.js';
+import { bigIntToTwosComplementLE } from '../types/carbon-serialization.js';
+import { Address, PBinaryWriter, Serialization, Timestamp } from '../types/index.js';
+import { numberToByteArray, stringToUint8Array, bytesToHex } from '../utils/index.js';
+import { Opcode } from './opcode.js';
+import { VMObject } from './vm-object.js';
+import { VMType } from './vm-type.js';
+import { Contracts } from './contracts.js';
+const MaxRegisterCount = 32;
+export class ScriptBuilder {
+    static create() {
+        return new ScriptBuilder();
+    }
+    /** @deprecated Use `ScriptBuilder.create()` instead. This alias will be removed in v1.0. */
+    static ScriptBuilder() {
+        return ScriptBuilder.create();
+    }
+    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;
+    }
+    emitThrow(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;
+            let i = 0;
+            let 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);
+        const data = [];
+        for (let i = 0; i < value.length; i++) {
+            data.push(value.charCodeAt(i));
+        }
+        return data;
+    }
+    emitLoadBigInt(reg, value) {
+        const bytes = Array.from(bigIntToTwosComplementLE(value));
+        this.emitLoadBytes(reg, bytes, VMType.Number);
+        return this;
+    }
+    emitLoad(reg, obj) {
+        switch (typeof obj) {
+            case 'string': {
+                const bytes = this.rawString(obj);
+                this.emitLoadBytes(reg, bytes, VMType.String);
+                break;
+            }
+            case 'boolean': {
+                const bytes = [obj ? 1 : 0];
+                this.emitLoadBytes(reg, bytes, VMType.Bool);
+                break;
+            }
+            case 'bigint': {
+                this.emitLoadBigInt(reg, obj);
+                break;
+            }
+            case 'number': {
+                // obj is BigInteger
+                // var bytes = val.ToSignedByteArray();
+                // this.emitLoadBytes(reg, bytes, VMType.Number);
+                //let bytes = this.rawString(BigInt(obj).toString());
+                // this.emitLoadVarInt(reg, obj);
+                const bytes = this.rawString(obj.toString());
+                this.emitLoadBytes(reg, bytes, VMType.String);
+                break;
+            }
+            case 'object':
+                if (obj === null) {
+                    throw Error('Load type object not supported');
+                }
+                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 (isSerializableLike(obj)) {
+                    this.emitLoadSerializable(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++) {
+            const element = obj[i];
+            const temp_regVal = reg + 1;
+            const temp_regKey = reg + 2;
+            this.emitLoad(temp_regVal, element);
+            this.emitLoad(temp_regKey, BigInt(i));
+            this.emit(Opcode.PUT, [temp_regVal, reg, temp_regKey]);
+            //this.emitLoad(reg, element);
+            //this.emitPush(reg);
+            //reg++;
+        }
+        return this;
+    }
+    emitLoadSerializable(reg, obj) {
+        const writer = new PBinaryWriter();
+        serializeSerializable(obj, writer);
+        this.emitLoadBytes(reg, writer.toArray(), VMType.Bytes);
+        return this;
+    }
+    emitLoadVmObject(reg, obj) {
+        const writer = new PBinaryWriter();
+        const 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)) {
+                const resultData = obj.data;
+                this.emitVarInt(resultData.size);
+                for (const entry of resultData) {
+                    //console.log(entry[0]);
+                    const key = entry[0];
+                    const 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) {
+                const writerNew = new PBinaryWriter();
+                serializeSerializable(obj.data, writerNew);
+                const bytes = writerNew.toUint8Array();
+                this.emitVarInt(bytes.length);
+                this.appendBytes(Array.from(bytes));
+            }
+        }
+        else {
+            //console.log("reg", reg);
+            const 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);
+        const bytes = [0, 0, 0, 0];
+        for (let i = 0; i < bytes.length; i++) {
+            const byte = enumVal & 0xff;
+            bytes[i] = byte;
+            enumVal = (enumVal - byte) / 256;
+        }
+        this.emitLoadBytes(reg, bytes, VMType.Enum);
+        return this;
+    }
+    emitLoadAddress(reg, obj) {
+        const writer = new PBinaryWriter();
+        obj.serializeData(writer);
+        const byteArray = Array.from(writer.toUint8Array());
+        this.emitLoadBytes(reg, byteArray, VMType.Bytes);
+        return this;
+    }
+    emitLoadTimestamp(reg, obj) {
+        if (obj instanceof Timestamp) {
+            const bytes = Array.from(Serialization.serialize(obj));
+            this.emitLoadBytes(reg, bytes, VMType.Timestamp);
+        }
+        else if (obj instanceof Date) {
+            const num = (obj.getTime() / 1000) | 0;
+            const a = (num & 0xff000000) >> 24;
+            const b = (num & 0x00ff0000) >> 16;
+            const c = (num & 0x0000ff00) >> 8;
+            const d = num & 0x000000ff;
+            const bytes = [d, c, b, a];
+            this.emitLoadBytes(reg, bytes, VMType.Timestamp);
+        }
+        return this;
+    }
+    emitLoadVarInt(reg, val) {
+        const 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);
+        }
+        const 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');
+        }
+        let 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');
+        }
+        let ofs = this.str.length;
+        ofs += 2;
+        this.emit(opcode);
+        this.appendByte(src_reg);
+        this.appendUShort(0);
+        this._jumpLocations[ofs] = label;
+        return this;
+    }
+    insertMethodArgs(args) {
+        const temp_reg = 0;
+        for (let i = args.length - 1; i >= 0; i--) {
+            const arg = args[i];
+            this.emitLoad(temp_reg, arg);
+            this.emitPush(temp_reg);
+        }
+    }
+    callInterop(method, args) {
+        this.insertMethodArgs(args);
+        const dest_reg = 0;
+        this.emitLoad(dest_reg, method);
+        this.emit(Opcode.EXTCALL, [dest_reg]);
+        return this;
+    }
+    callContract(contractName, method, args) {
+        this.insertMethodArgs(args);
+        const temp_reg = 0;
+        this.emitLoad(temp_reg, method);
+        this.emitPush(temp_reg);
+        const src_reg = 0;
+        const 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]);
+    }
+    mintTokens(symbol, from, to, amount) {
+        return this.callInterop('Runtime.MintTokens', [from, to, symbol, amount]);
+    }
+    transferTokens(symbol, from, to, amount) {
+        return this.callInterop('Runtime.TransferTokens', [from, to, symbol, amount]);
+    }
+    transferBalance(symbol, from, to) {
+        return this.callInterop('Runtime.TransferBalance', [from, to, symbol]);
+    }
+    transferNft(symbol, from, to, tokenId) {
+        return this.callInterop('Runtime.TransferToken', [from, to, symbol, tokenId]);
+    }
+    crossTransferToken(destinationChain, symbol, from, to, amount) {
+        return this.callInterop('Runtime.SendTokens', [destinationChain, from, to, symbol, amount]);
+    }
+    crossTransferNft(destinationChain, symbol, from, to, tokenId) {
+        return this.callInterop('Runtime.SendToken', [destinationChain, from, to, symbol, tokenId]);
+    }
+    stake(address, amount) {
+        return this.callContract('stake', 'Stake', [address, amount]);
+    }
+    unstake(address, amount) {
+        return this.callContract('stake', 'Unstake', [address, amount]);
+    }
+    callNft(symbol, seriesId, method, args = []) {
+        return this.callContract(`${symbol}#${seriesId.toString()}`, method, args);
+    }
+    //#endregion
+    emitTimestamp(obj) {
+        const num = (obj.getTime() / 1000) | 0;
+        const a = (num & 0xff000000) >> 24;
+        const b = (num & 0x00ff0000) >> 16;
+        const c = (num & 0x0000ff00) >> 8;
+        const d = num & 0x000000ff;
+        const bytes = [d, c, b, a];
+        this.appendBytes(bytes);
+        return this;
+    }
+    emitByteArray(bytes) {
+        this.emitVarInt(bytes.length);
+        this.emitBytes(bytes);
+        return this;
+    }
+    emitVarString(text) {
+        const bytes = this.rawString(text);
+        this.emitVarInt(bytes.length);
+        this.emitBytes(bytes);
+        return this;
+    }
+    emitVarInt(value) {
+        if (value < 0)
+            throw new Error('negative value invalid');
+        if (value < 0xfd) {
+            this.appendByte(value);
+        }
+        else if (value <= 0xffff) {
+            const B = (value & 0x0000ff00) >> 8;
+            const A = value & 0x000000ff;
+            // VM variable integers append the least significant byte first.
+            this.appendByte(0xfd);
+            this.appendByte(A);
+            this.appendByte(B);
+        }
+        else if (value <= 0xffffffff) {
+            const C = (value & 0x00ff0000) >> 16;
+            const B = (value & 0x0000ff00) >> 8;
+            const A = value & 0x000000ff;
+            // VM variable integers append the least significant byte first.
+            this.appendByte(0xfe);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+        }
+        else {
+            const D = (value & 0xff000000) >> 24;
+            const C = (value & 0x00ff0000) >> 16;
+            const B = (value & 0x0000ff00) >> 8;
+            const A = value & 0x000000ff;
+            // VM variable integers append the least significant byte first.
+            this.appendByte(0xff);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+            this.appendByte(D);
+        }
+        return this;
+    }
+    emitUInt32(value) {
+        if (value < 0)
+            throw new Error('negative value invalid');
+        const D = (value & 0xff000000) >> 24;
+        const C = (value & 0x00ff0000) >> 16;
+        const B = (value & 0x0000ff00) >> 8;
+        const A = value & 0x000000ff;
+        // VM integers append the least significant byte first.
+        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) {
+        const 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;
+    }
+    /** @deprecated Use `beginScript` instead. This alias will be removed in v1.0. */
+    BeginScript() {
+        return this.beginScript();
+    }
+    /** @deprecated Use `getScript` instead. This alias will be removed in v1.0. */
+    GetScript() {
+        return this.getScript();
+    }
+    /** @deprecated Use `endScript` instead. This alias will be removed in v1.0. */
+    EndScript() {
+        return this.endScript();
+    }
+    /** @deprecated Use `emit` instead. This alias will be removed in v1.0. */
+    Emit(opcode, bytes) {
+        return this.emit(opcode, bytes);
+    }
+    /** @deprecated Use `emitThrow` instead. This typoed alias will be removed in v1.0. */
+    EmitThorw(reg) {
+        return this.emitThrow(reg);
+    }
+    /** @deprecated Use `emitPush` instead. This alias will be removed in v1.0. */
+    EmitPush(reg) {
+        return this.emitPush(reg);
+    }
+    /** @deprecated Use `emitPop` instead. This alias will be removed in v1.0. */
+    EmitPop(reg) {
+        return this.emitPop(reg);
+    }
+    /** @deprecated Use `emitExtCall` instead. This alias will be removed in v1.0. */
+    EmitExtCall(method, reg = 0) {
+        return this.emitExtCall(method, reg);
+    }
+    /** @deprecated Use `emitBigInteger` instead. This alias will be removed in v1.0. */
+    EmitBigInteger(value) {
+        return this.emitBigInteger(value);
+    }
+    /** @deprecated Use `emitAddress` instead. This alias will be removed in v1.0. */
+    EmitAddress(textAddress) {
+        return this.emitAddress(textAddress);
+    }
+    /** @deprecated Use `rawString` instead. This alias will be removed in v1.0. */
+    RawString(value) {
+        return this.rawString(value);
+    }
+    /** @deprecated Use `emitLoad` instead. This alias will be removed in v1.0. */
+    EmitLoad(reg, obj) {
+        return this.emitLoad(reg, obj);
+    }
+    /** @deprecated Use `emitLoadBytes` instead. This alias will be removed in v1.0. */
+    EmitLoadBytes(reg, bytes, type = VMType.Bytes) {
+        return this.emitLoadBytes(reg, bytes, type);
+    }
+    /** @deprecated Use `emitLoadArray` instead. This alias will be removed in v1.0. */
+    EmitLoadArray(reg, obj) {
+        return this.emitLoadArray(reg, obj);
+    }
+    /** @deprecated Use `emitLoadSerializable` instead. This alias will be removed in v1.0. */
+    EmitLoadISerializable(reg, obj) {
+        return this.emitLoadSerializable(reg, obj);
+    }
+    /** @deprecated Use `emitLoadVmObject` instead. This alias will be removed in v1.0. */
+    EmitLoadVMObject(reg, obj) {
+        return this.emitLoadVmObject(reg, obj);
+    }
+    /** @deprecated Use `emitLoadEnum` instead. This alias will be removed in v1.0. */
+    EmitLoadEnum(reg, enumVal) {
+        return this.emitLoadEnum(reg, enumVal);
+    }
+    /** @deprecated Use `emitLoadAddress` instead. This alias will be removed in v1.0. */
+    EmitLoadAddress(reg, obj) {
+        return this.emitLoadAddress(reg, obj);
+    }
+    /** @deprecated Use `emitLoadTimestamp` instead. This alias will be removed in v1.0. */
+    EmitLoadTimestamp(reg, obj) {
+        return this.emitLoadTimestamp(reg, obj);
+    }
+    /** @deprecated Use `emitLoadVarInt` instead. This alias will be removed in v1.0. */
+    EmitLoadVarInt(reg, val) {
+        return this.emitLoadVarInt(reg, val);
+    }
+    /** @deprecated Use `emitMove` instead. This alias will be removed in v1.0. */
+    EmitMove(src_reg, dst_reg) {
+        return this.emitMove(src_reg, dst_reg);
+    }
+    /** @deprecated Use `emitCopy` instead. This alias will be removed in v1.0. */
+    EmitCopy(src_reg, dst_reg) {
+        return this.emitCopy(src_reg, dst_reg);
+    }
+    /** @deprecated Use `emitLabel` instead. This alias will be removed in v1.0. */
+    EmitLabel(label) {
+        return this.emitLabel(label);
+    }
+    /** @deprecated Use `emitJump` instead. This alias will be removed in v1.0. */
+    EmitJump(opcode, label, reg = 0) {
+        return this.emitJump(opcode, label, reg);
+    }
+    /** @deprecated Use `emitCall` instead. This alias will be removed in v1.0. */
+    EmitCall(label, regCount) {
+        return this.emitCall(label, regCount);
+    }
+    /** @deprecated Use `emitConditionalJump` instead. This alias will be removed in v1.0. */
+    EmitConditionalJump(opcode, src_reg, label) {
+        return this.emitConditionalJump(opcode, src_reg, label);
+    }
+    /** @deprecated Use `insertMethodArgs` instead. This alias will be removed in v1.0. */
+    InsertMethodArgs(args) {
+        return this.insertMethodArgs(args);
+    }
+    /** @deprecated Use `callInterop` instead. This alias will be removed in v1.0. */
+    CallInterop(method, args) {
+        return this.callInterop(method, args);
+    }
+    /** @deprecated Use `callContract` instead. This alias will be removed in v1.0. */
+    CallContract(contractName, method, args) {
+        return this.callContract(contractName, method, args);
+    }
+    /** @deprecated Use `allowGas` instead. This alias will be removed in v1.0. */
+    AllowGas(from, to, gasPrice, gasLimit) {
+        return this.allowGas(from, to, gasPrice, gasLimit);
+    }
+    /** @deprecated Use `spendGas` instead. This alias will be removed in v1.0. */
+    SpendGas(address) {
+        return this.spendGas(address);
+    }
+    /** @deprecated Use `mintTokens` instead. This alias will be removed in v1.0. */
+    MintTokens(symbol, from, to, amount) {
+        return this.mintTokens(symbol, from, to, amount);
+    }
+    /** @deprecated Use `transferTokens` instead. This alias will be removed in v1.0. */
+    TransferTokens(symbol, from, to, amount) {
+        return this.transferTokens(symbol, from, to, amount);
+    }
+    /** @deprecated Use `transferBalance` instead. This alias will be removed in v1.0. */
+    TransferBalance(symbol, from, to) {
+        return this.transferBalance(symbol, from, to);
+    }
+    /** @deprecated Use `transferNft` instead. This alias will be removed in v1.0. */
+    TransferNFT(symbol, from, to, tokenId) {
+        return this.transferNft(symbol, from, to, tokenId);
+    }
+    /** @deprecated Use `crossTransferToken` instead. This alias will be removed in v1.0. */
+    CrossTransferToken(destinationChain, symbol, from, to, amount) {
+        return this.crossTransferToken(destinationChain, symbol, from, to, amount);
+    }
+    /** @deprecated Use `crossTransferNft` instead. This alias will be removed in v1.0. */
+    CrossTransferNFT(destinationChain, symbol, from, to, tokenId) {
+        return this.crossTransferNft(destinationChain, symbol, from, to, tokenId);
+    }
+    /** @deprecated Use `stake` instead. This alias will be removed in v1.0. */
+    Stake(address, amount) {
+        return this.stake(address, amount);
+    }
+    /** @deprecated Use `unstake` instead. This alias will be removed in v1.0. */
+    Unstake(address, amount) {
+        return this.unstake(address, amount);
+    }
+    /** @deprecated Use `callNft` instead. This alias will be removed in v1.0. */
+    CallNFT(symbol, seriesId, method, args = []) {
+        return this.callNft(symbol, seriesId, method, args);
+    }
+    /** @deprecated Use `emitTimestamp` instead. This alias will be removed in v1.0. */
+    EmitTimestamp(obj) {
+        return this.emitTimestamp(obj);
+    }
+    /** @deprecated Use `emitByteArray` instead. This alias will be removed in v1.0. */
+    EmitByteArray(bytes) {
+        return this.emitByteArray(bytes);
+    }
+    /** @deprecated Use `emitVarString` instead. This alias will be removed in v1.0. */
+    EmitVarString(text) {
+        return this.emitVarString(text);
+    }
+    /** @deprecated Use `emitVarInt` instead. This alias will be removed in v1.0. */
+    EmitVarInt(value) {
+        return this.emitVarInt(value);
+    }
+    /** @deprecated Use `emitUInt32` instead. This alias will be removed in v1.0. */
+    EmitUInt32(value) {
+        return this.emitUInt32(value);
+    }
+    /** @deprecated Use `emitBytes` instead. This alias will be removed in v1.0. */
+    EmitBytes(bytes) {
+        return this.emitBytes(bytes);
+    }
+    /** @deprecated Use `byteToHex` instead. This alias will be removed in v1.0. */
+    ByteToHex(byte) {
+        return this.byteToHex(byte);
+    }
+    /** @deprecated Use `appendByte` instead. This alias will be removed in v1.0. */
+    AppendByte(byte) {
+        return this.appendByte(byte);
+    }
+    /** @deprecated Use `appendBytes` instead. This alias will be removed in v1.0. */
+    AppendBytes(bytes) {
+        return this.appendBytes(bytes);
+    }
+    /** @deprecated Use `appendUShort` instead. This alias will be removed in v1.0. */
+    AppendUshort(ushort) {
+        return this.appendUShort(ushort);
+    }
+    /** @deprecated Use `appendHexEncoded` instead. This alias will be removed in v1.0. */
+    AppendHexEncoded(bytes) {
+        return this.appendHexEncoded(bytes);
+    }
+}