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

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmDynamicVariable.js

@@ -0,0 +1,356 @@
+import { VmType } from './VmType';
+import { VmStructSchema } from './VmStructSchema';
+import { VmDynamicStruct } from './VmDynamicStruct';
+import { VmStructArray } from './VmStructArray';
+import { Bytes16 } from '../../Bytes16';
+import { Bytes32 } from '../../Bytes32';
+import { Bytes64 } from '../../Bytes64';
+export class VmDynamicVariable {
+    constructor() {
+        this.type = VmType.Dynamic;
+        this.data = null;
+    }
+    static fromType(t) {
+        const v = new VmDynamicVariable();
+        v.type = t;
+        switch (t) {
+            case VmType.Dynamic:
+                v.data = null;
+                break;
+            case VmType.Bytes:
+                v.data = new Uint8Array();
+                break;
+            case VmType.Struct:
+                v.data = new VmDynamicStruct();
+                break;
+            case VmType.Int8:
+                v.data = 0;
+                break;
+            case VmType.Int16:
+                v.data = 0;
+                break;
+            case VmType.Int32:
+                v.data = 0;
+                break;
+            case VmType.Int64:
+                v.data = 0n;
+                break;
+            case VmType.Int256:
+                v.data = 0n;
+                break;
+            case VmType.Bytes16:
+                v.data = new Bytes16();
+                break;
+            case VmType.Bytes32:
+                v.data = new Bytes32();
+                break;
+            case VmType.Bytes64:
+                v.data = new Bytes64();
+                break;
+            case VmType.String:
+                v.data = '';
+                break;
+            case VmType.Array | VmType.Dynamic:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Bytes:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Struct:
+                v.data = new VmStructArray();
+                break;
+            case VmType.Array | VmType.Int8:
+                v.data = new Uint8Array();
+                break;
+            case VmType.Array | VmType.Int16:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Int32:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Int64:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Int256:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Bytes16:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Bytes32:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.Bytes64:
+                v.data = [];
+                break;
+            case VmType.Array | VmType.String:
+                v.data = [];
+                break;
+            default:
+                throw new Error('Unknown VmDynamicVariable type');
+        }
+        return v;
+    }
+    write(w) {
+        w.write1(this.type & 0xff);
+        VmDynamicVariable.writeStatic(this.type, this, null, w);
+    }
+    writeWithSchema(schema, w) {
+        return VmDynamicVariable.writeStatic(schema.type, this, schema.structure, w);
+    }
+    read(r) {
+        this.type = r.read1();
+        VmDynamicVariable.readStatic(this.type, this, null, r);
+    }
+    readWithSchema(schema, r) {
+        this.type = schema.type;
+        VmDynamicVariable.readStatic(schema.type, this, null, r);
+    }
+    static readStatic(type, outVar, schema, r) {
+        switch (type) {
+            case VmType.Dynamic: {
+                const inner = new VmDynamicVariable();
+                inner.read(r);
+                outVar.type = VmType.Dynamic;
+                outVar.data = inner;
+                break;
+            }
+            case VmType.Bytes:
+                outVar.type = type;
+                outVar.data = r.readArray();
+                break;
+            case VmType.Struct: {
+                const s = new VmDynamicStruct();
+                if (schema)
+                    s.readWithSchema(schema, r);
+                else
+                    s.read(r);
+                outVar.type = type;
+                outVar.data = s;
+                break;
+            }
+            case VmType.Int8:
+                outVar.type = type;
+                outVar.data = r.read1();
+                break;
+            case VmType.Int16:
+                outVar.type = type;
+                outVar.data = r.read2();
+                break;
+            case VmType.Int32:
+                outVar.type = type;
+                outVar.data = r.read4();
+                break;
+            case VmType.Int64:
+                outVar.type = type;
+                outVar.data = r.read8u();
+                break;
+            case VmType.Int256:
+                outVar.type = type;
+                outVar.data = r.readBigInt();
+                break;
+            case VmType.Bytes16:
+                outVar.type = type;
+                outVar.data = Bytes16.read(r);
+                break;
+            case VmType.Bytes32:
+                outVar.type = type;
+                outVar.data = Bytes32.read(r);
+                break;
+            case VmType.Bytes64:
+                outVar.type = type;
+                outVar.data = Bytes64.read(r);
+                break;
+            case VmType.String:
+                outVar.type = type;
+                outVar.data = r.readSz();
+                break;
+            case VmType.Array | VmType.Dynamic:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(VmDynamicVariable);
+                break;
+            case VmType.Array | VmType.Bytes:
+                outVar.type = type;
+                outVar.data = r.readArrayOfArrays();
+                break;
+            case VmType.Array | VmType.Struct: {
+                const length = r.read4();
+                let usedSchema = schema ?? null;
+                const sa = new VmStructArray();
+                if (!usedSchema) {
+                    const readSchema = r.readBlob(VmStructSchema);
+                    sa.schema = readSchema;
+                    if (readSchema.fields.length > 0)
+                        usedSchema = readSchema;
+                }
+                else {
+                    sa.schema = usedSchema;
+                }
+                const arr = new Array(length);
+                for (let i = 0; i < length; i++) {
+                    const s = new VmDynamicStruct();
+                    if (usedSchema) {
+                        s.readWithSchema(usedSchema, r);
+                    }
+                    else {
+                        s.read(r);
+                    }
+                    arr[i] = s;
+                }
+                sa.structs = arr;
+                outVar.type = type;
+                outVar.data = sa;
+                break;
+            }
+            case VmType.Array | VmType.Int8:
+                outVar.type = type;
+                outVar.data = r.readArray8();
+                break;
+            case VmType.Array | VmType.Int16:
+                outVar.type = type;
+                outVar.data = r.readArray16();
+                break;
+            case VmType.Array | VmType.Int32:
+                outVar.type = type;
+                outVar.data = r.readArray32();
+                break;
+            case VmType.Array | VmType.Int64:
+                outVar.type = type;
+                outVar.data = r.readArray64();
+                break;
+            case VmType.Array | VmType.Int256:
+                outVar.type = type;
+                outVar.data = r.readArrayBigInt();
+                break;
+            case VmType.Array | VmType.Bytes16:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(Bytes16);
+                break;
+            case VmType.Array | VmType.Bytes32:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(Bytes32);
+                break;
+            case VmType.Array | VmType.Bytes64:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(Bytes64);
+                break;
+            case VmType.Array | VmType.String:
+                outVar.type = type;
+                outVar.data = r.readArraySz();
+                break;
+            default:
+                throw new Error('Unknown VmDynamicVariable type');
+        }
+    }
+    static writeStatic(type, v, schema, w) {
+        if (v.type !== type) {
+            const err = VmDynamicVariable.fromType(type);
+            return VmDynamicVariable.writeStatic(type, err, schema, w);
+        }
+        if (type === VmType.Dynamic) {
+            if (v.data == null) {
+                w.write1((VmType.Array | VmType.Dynamic) & 0xff);
+                w.write4u(0);
+                return true;
+            }
+            v.data.write(w);
+            return true;
+        }
+        if (v.data == null)
+            throw new Error('invalid object');
+        switch (type) {
+            case VmType.Bytes:
+                w.writeArray(v.data);
+                return true;
+            case VmType.Struct: {
+                const s = v.data;
+                if (schema)
+                    return s.writeWithSchema(schema, w);
+                else {
+                    s.write(w);
+                    return true;
+                }
+            }
+            case VmType.Int8:
+                w.write1(v.data);
+                return true;
+            case VmType.Int16:
+                w.write2(v.data);
+                return true;
+            case VmType.Int32:
+                w.write4(v.data);
+                return true;
+            case VmType.Int64:
+                w.write8u(v.data);
+                return true;
+            case VmType.Int256:
+                w.writeBigInt(v.data);
+                return true;
+            case VmType.Bytes16:
+                v.data.write(w);
+                return true;
+            case VmType.Bytes32:
+                v.data.write(w);
+                return true;
+            case VmType.Bytes64:
+                v.data.write(w);
+                return true;
+            case VmType.String:
+                w.writeSz(v.data);
+                return true;
+            case VmType.Array | VmType.Dynamic:
+                w.writeArrayBlob(v.data);
+                return true;
+            case VmType.Array | VmType.Bytes:
+                w.writeArrayOfArrays(v.data);
+                return true;
+            case VmType.Array | VmType.Struct: {
+                const sa = v.data;
+                w.write4u(sa.structs.length);
+                let used = schema;
+                if (!used) {
+                    sa.schema.write(w);
+                    if (sa.schema.fields.length > 0)
+                        used = sa.schema;
+                }
+                let ok = true;
+                for (const s of sa.structs) {
+                    if (used)
+                        ok = ok && s.writeWithSchema(used, w);
+                    else
+                        s.write(w);
+                }
+                return ok;
+            }
+            case VmType.Array | VmType.Int8:
+                w.writeArray(v.data);
+                return true;
+            case VmType.Array | VmType.Int16:
+                w.writeArray16(v.data);
+                return true;
+            case VmType.Array | VmType.Int32:
+                w.writeArray32(v.data);
+                return true;
+            case VmType.Array | VmType.Int64:
+                w.writeArray64(v.data);
+                return true;
+            case VmType.Array | VmType.Int256:
+                w.writeArrayBigInt(v.data);
+                return true;
+            case VmType.Array | VmType.Bytes16:
+                v.data.write(w);
+                return true;
+            case VmType.Array | VmType.Bytes32:
+                v.data.write(w);
+                return true;
+            case VmType.Array | VmType.Bytes64:
+                v.data.write(w);
+                return true;
+            case VmType.Array | VmType.String:
+                w.writeArraySz(v.data);
+                return true;
+            default:
+                throw new Error('invalid VmDynamicVariable');
+        }
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmNamedDynamicVariable.js

@@ -0,0 +1,32 @@
+import { hexToBytes } from '../../../../utils';
+import { SmallString } from '../../SmallString';
+import { VmDynamicVariable } from './VmDynamicVariable';
+import { VmType } from './VmType';
+export class VmNamedDynamicVariable {
+    static from(name, type, value) {
+        const nv = new VmNamedDynamicVariable();
+        nv.name = name instanceof SmallString ? name : new SmallString(name);
+        const dyn = VmDynamicVariable.fromType(type);
+        if (type === VmType.Bytes && typeof value === "string") {
+            dyn.data = hexToBytes(value);
+        }
+        else {
+            dyn.data = value;
+        }
+        nv.value = dyn;
+        return nv;
+    }
+    write(w) {
+        this.name.write(w);
+        this.value.write(w);
+    }
+    read(r) {
+        this.name = r.readBlob(SmallString);
+        this.value = r.readBlob(VmDynamicVariable);
+    }
+    static read(r) {
+        const v = new VmNamedDynamicVariable();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmNamedVariableSchema.js

@@ -0,0 +1,35 @@
+import { SmallString } from '../../SmallString';
+import { VmVariableSchema } from './VmVariableSchema';
+export class VmNamedVariableSchema {
+    constructor(name, schema) {
+        if (name) {
+            if (name instanceof SmallString) {
+                this.name = name;
+            }
+            else {
+                this.name = new SmallString(name);
+            }
+        }
+        if (schema) {
+            if (schema instanceof VmVariableSchema) {
+                this.schema = schema;
+            }
+            else {
+                this.schema = new VmVariableSchema(schema);
+            }
+        }
+    }
+    write(w) {
+        this.name.write(w);
+        this.schema.write(w);
+    }
+    read(r) {
+        this.name = r.readBlob(SmallString);
+        this.schema = r.readBlob(VmVariableSchema);
+    }
+    static read(r) {
+        const v = new VmNamedVariableSchema();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmStructArray.js

@@ -0,0 +1,7 @@
+import { VmStructSchema } from "./VmStructSchema";
+export class VmStructArray {
+    constructor() {
+        this.schema = new VmStructSchema();
+        this.structs = [];
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmStructFlags.js

@@ -0,0 +1,5 @@
+export var VmStructFlags;
+(function (VmStructFlags) {
+    VmStructFlags[VmStructFlags["None"] = 0] = "None";
+    VmStructFlags[VmStructFlags["DynamicExtras"] = 1] = "DynamicExtras";
+})(VmStructFlags || (VmStructFlags = {}));

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmStructSchema.js

@@ -0,0 +1,31 @@
+import { VmNamedVariableSchema } from './VmNamedVariableSchema';
+export class VmStructSchema {
+    constructor(fields, flags) {
+        this.fields = [];
+        this.flags = VmStructSchema.Flags.None;
+        if (fields) {
+            this.fields = fields;
+        }
+        if (flags) {
+            this.flags = flags;
+        }
+    }
+    write(w) {
+        w.writeArrayBlob(this.fields);
+        w.write1(this.flags & 0xff);
+    }
+    read(r) {
+        this.fields = r.readArrayBlob(VmNamedVariableSchema);
+        this.flags = r.read1();
+    }
+    static read(r) {
+        const v = new VmStructSchema();
+        v.read(r);
+        return v;
+    }
+}
+VmStructSchema.Flags = {
+    None: 0,
+    DynamicExtras: 1 << 0,
+    IsSorted: 1 << 1,
+};

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmType.js

@@ -0,0 +1,62 @@
+export var VmType;
+(function (VmType) {
+    VmType[VmType["Dynamic"] = 0] = "Dynamic";
+    VmType[VmType["Array"] = 1] = "Array";
+    VmType[VmType["Bytes"] = 2] = "Bytes";
+    VmType[VmType["Struct"] = 4] = "Struct";
+    VmType[VmType["Int8"] = 6] = "Int8";
+    VmType[VmType["Int16"] = 8] = "Int16";
+    VmType[VmType["Int32"] = 10] = "Int32";
+    VmType[VmType["Int64"] = 12] = "Int64";
+    VmType[VmType["Int256"] = 14] = "Int256";
+    VmType[VmType["Bytes16"] = 16] = "Bytes16";
+    VmType[VmType["Bytes32"] = 18] = "Bytes32";
+    VmType[VmType["Bytes64"] = 20] = "Bytes64";
+    VmType[VmType["String"] = 22] = "String";
+    VmType[VmType["Array_Dynamic"] = 1] = "Array_Dynamic";
+    VmType[VmType["Array_Bytes"] = 3] = "Array_Bytes";
+    VmType[VmType["Array_Struct"] = 5] = "Array_Struct";
+    VmType[VmType["Array_Int8"] = 7] = "Array_Int8";
+    VmType[VmType["Array_Int16"] = 9] = "Array_Int16";
+    VmType[VmType["Array_Int32"] = 11] = "Array_Int32";
+    VmType[VmType["Array_Int64"] = 13] = "Array_Int64";
+    VmType[VmType["Array_Int256"] = 15] = "Array_Int256";
+    VmType[VmType["Array_Bytes16"] = 17] = "Array_Bytes16";
+    VmType[VmType["Array_Bytes32"] = 19] = "Array_Bytes32";
+    VmType[VmType["Array_Bytes64"] = 21] = "Array_Bytes64";
+    VmType[VmType["Array_String"] = 23] = "Array_String";
+})(VmType || (VmType = {}));
+export function vmTypeFromString(type) {
+    const map = {
+        Dynamic: VmType.Dynamic,
+        Array: VmType.Array,
+        Bytes: VmType.Bytes,
+        Struct: VmType.Struct,
+        Int8: VmType.Int8,
+        Int16: VmType.Int16,
+        Int32: VmType.Int32,
+        Int64: VmType.Int64,
+        Int256: VmType.Int256,
+        Bytes16: VmType.Bytes16,
+        Bytes32: VmType.Bytes32,
+        Bytes64: VmType.Bytes64,
+        String: VmType.String,
+        Array_Dynamic: VmType.Array_Dynamic,
+        Array_Bytes: VmType.Array_Bytes,
+        Array_Struct: VmType.Array_Struct,
+        Array_Int8: VmType.Array_Int8,
+        Array_Int16: VmType.Array_Int16,
+        Array_Int32: VmType.Array_Int32,
+        Array_Int64: VmType.Array_Int64,
+        Array_Int256: VmType.Array_Int256,
+        Array_Bytes16: VmType.Array_Bytes16,
+        Array_Bytes32: VmType.Array_Bytes32,
+        Array_Bytes64: VmType.Array_Bytes64,
+        Array_String: VmType.Array_String,
+    };
+    const value = map[type.trim()];
+    if (value === undefined) {
+        throw new Error(`Unknown VmType: ${type}`);
+    }
+    return value;
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/VmVariableSchema.js

@@ -0,0 +1,27 @@
+import { VmType } from './VmType';
+import { VmStructSchema } from './VmStructSchema';
+export class VmVariableSchema {
+    constructor(type, structure) {
+        if (type)
+            this.type = type;
+        if (structure)
+            this.structure = structure;
+    }
+    write(w) {
+        w.write1(this.type & 0xff);
+        if (this.type === VmType.Struct || this.type === (VmType.Struct | VmType.Array)) {
+            this.structure.write(w);
+        }
+    }
+    read(r) {
+        this.type = r.read1();
+        if (this.type === VmType.Struct || this.type === (VmType.Struct | VmType.Array)) {
+            this.structure = r.readBlob(VmStructSchema);
+        }
+    }
+    static read(r) {
+        const v = new VmVariableSchema();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Vm/index.js

@@ -0,0 +1,9 @@
+export * from "./VmDynamicStruct";
+export * from "./VmDynamicVariable";
+export * from "./VmNamedDynamicVariable";
+export * from "./VmNamedVariableSchema";
+export * from "./VmStructArray";
+export * from "./VmStructFlags";
+export * from "./VmStructSchema";
+export * from "./VmType";
+export * from "./VmVariableSchema";

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

@@ -0,0 +1,25 @@
+export * from "./Extensions";
+export * from "./Modules";
+export * from "./TxHelpers";
+export * from "./Vm";
+export * from "./CarbonTokenFlags";
+export * from "./ModuleId";
+export * from "./SignedTxMsg";
+export * from "./TxMsg";
+export * from "./TxMsgCall";
+export * from "./TxMsgCallMulti";
+export * from "./TxMsgTrade";
+export * from "./TxMsgMintFungible";
+export * from "./TxMsgMintNonFungible";
+export * from "./TxMsgBurnFungible";
+export * from "./TxMsgBurnFungibleGasPayer";
+export * from "./TxMsgBurnNonFungible";
+export * from "./TxMsgBurnNonFungibleGasPayer";
+export * from "./TxMsgTransferFungible";
+export * from "./TxMsgTransferFungibleGasPayer";
+export * from "./TxMsgTransferNonFungibleSingle";
+export * from "./TxMsgTransferNonFungibleSingleGasPayer";
+export * from "./TxMsgTransferNonFungibleMulti";
+export * from "./TxMsgTransferNonFungibleMultiGasPayer";
+export * from "./TxMsgPhantasma";
+export * from "./TxMsgPhantasmaRaw";

package/dist/esm/core/types/Carbon/Bytes16.js

@@ -0,0 +1,38 @@
+import { bytesToHex } from '../../utils/Hex';
+export class Bytes16 {
+    constructor(bytes = new Uint8Array(16)) {
+        this.bytes = bytes;
+        if (bytes.length !== 16)
+            throw new Error('Bytes16 length must be 16');
+        this.bytes = new Uint8Array(bytes);
+    }
+    write(w) {
+        w.write16(this.bytes);
+    }
+    read(r) {
+        this.bytes = r.read16();
+    }
+    static read(r) {
+        const v = new Bytes16();
+        v.read(r);
+        return v;
+    }
+    equals(other) {
+        const a = this.bytes, b = other.bytes;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    ToHex() {
+        return bytesToHex(this.bytes);
+    }
+    // Used by console.log / util.inspect
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        // Return a pretty, concise representation
+        return `Bytes16(${this.ToHex()})`;
+    }
+}
+Bytes16.Empty = new Bytes16(new Uint8Array(16));

package/dist/esm/core/types/Carbon/Bytes32.js

@@ -0,0 +1,38 @@
+import { bytesToHex } from '../../utils/Hex';
+export class Bytes32 {
+    constructor(bytes = new Uint8Array(32)) {
+        this.bytes = bytes;
+        if (bytes.length !== 32)
+            throw new Error('Bytes32 length must be 32');
+        this.bytes = new Uint8Array(bytes);
+    }
+    write(w) {
+        w.write32(this.bytes);
+    }
+    read(r) {
+        this.bytes = r.read32();
+    }
+    static read(r) {
+        const v = new Bytes32();
+        v.read(r);
+        return v;
+    }
+    equals(other) {
+        const a = this.bytes, b = other.bytes;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    ToHex() {
+        return bytesToHex(this.bytes);
+    }
+    // Used by console.log / util.inspect
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        // Return a pretty, concise representation
+        return `Bytes32(${this.ToHex()})`;
+    }
+}
+Bytes32.Empty = new Bytes32(new Uint8Array(32));