phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/types/carbon/blockchain/tx-msg.js

@@ -0,0 +1,165 @@
+import { Bytes32 } from '../bytes32.js';
+import { SmallString } from '../small-string.js';
+import { TxTypes } from '../tx-types.js';
+import { TxMsgCall } from './tx-msg-call.js';
+import { TxMsgCallMulti } from './tx-msg-call-multi.js';
+import { TxMsgMintFungible } from './tx-msg-mint-fungible.js';
+import { TxMsgMintNonFungible } from './tx-msg-mint-non-fungible.js';
+import { TxMsgTrade } from './tx-msg-trade.js';
+import { TxMsgTransferFungible } from './tx-msg-transfer-fungible.js';
+import { TxMsgTransferFungibleGasPayer } from './tx-msg-transfer-fungible-gas-payer.js';
+import { TxMsgTransferNonFungibleMulti } from './tx-msg-transfer-non-fungible-multi.js';
+import { TxMsgTransferNonFungibleMultiGasPayer } from './tx-msg-transfer-non-fungible-multi-gas-payer.js';
+import { TxMsgTransferNonFungibleSingle } from './tx-msg-transfer-non-fungible-single.js';
+import { TxMsgTransferNonFungibleSingleGasPayer } from './tx-msg-transfer-non-fungible-single-gas-payer.js';
+import { TxMsgBurnFungible } from './tx-msg-burn-fungible.js';
+import { TxMsgBurnFungibleGasPayer } from './tx-msg-burn-fungible-gas-payer.js';
+import { TxMsgBurnNonFungible } from './tx-msg-burn-non-fungible.js';
+import { TxMsgBurnNonFungibleGasPayer } from './tx-msg-burn-non-fungible-gas-payer.js';
+import { TxMsgPhantasma } from './tx-msg-phantasma.js';
+import { TxMsgPhantasmaRaw } from './tx-msg-phantasma-raw.js';
+export class TxMsg {
+    constructor(type = TxTypes.Call, expiry = 0n, // int64
+    maxGas = 0n, // uint64
+    maxData = 0n, // uint64
+    gasFrom = new Bytes32(), payload = new SmallString(''), msg) {
+        this.type = type;
+        this.expiry = expiry;
+        this.maxGas = maxGas;
+        this.maxData = maxData;
+        this.gasFrom = gasFrom;
+        this.payload = payload;
+        this.msg = msg;
+    }
+    write(w) {
+        w.write1(this.type);
+        w.write8(this.expiry);
+        w.write8u(this.maxGas);
+        w.write8u(this.maxData);
+        this.gasFrom.write(w);
+        this.payload.write(w);
+        switch (this.type) {
+            case TxTypes.Call:
+                this.msg.write(w);
+                break;
+            case TxTypes.Call_Multi:
+                this.msg.write(w);
+                break;
+            case TxTypes.Trade:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferNonFungible_Single:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferNonFungible_Single_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferNonFungible_Multi:
+                this.msg.write(w);
+                break;
+            case TxTypes.TransferNonFungible_Multi_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes.MintFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes.BurnFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes.BurnFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes.MintNonFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes.BurnNonFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes.BurnNonFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes.Phantasma:
+                this.msg.write(w);
+                break;
+            case TxTypes.Phantasma_Raw:
+                this.msg.write(w);
+                break;
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    read(r) {
+        this.type = r.read1();
+        this.expiry = r.read8();
+        this.maxGas = r.read8u();
+        this.maxData = r.read8u();
+        this.gasFrom = Bytes32.read(r);
+        this.payload = SmallString.read(r);
+        switch (this.type) {
+            case TxTypes.Call:
+                this.msg = TxMsgCall.read(r);
+                break;
+            case TxTypes.Call_Multi:
+                this.msg = TxMsgCallMulti.read(r);
+                break;
+            case TxTypes.Trade:
+                this.msg = TxMsgTrade.read(r);
+                break;
+            case TxTypes.TransferFungible:
+                this.msg = TxMsgTransferFungible.read(r);
+                break;
+            case TxTypes.TransferFungible_GasPayer:
+                this.msg = TxMsgTransferFungibleGasPayer.read(r);
+                break;
+            case TxTypes.TransferNonFungible_Single:
+                this.msg = TxMsgTransferNonFungibleSingle.read(r);
+                break;
+            case TxTypes.TransferNonFungible_Single_GasPayer:
+                this.msg = TxMsgTransferNonFungibleSingleGasPayer.read(r);
+                break;
+            case TxTypes.TransferNonFungible_Multi:
+                this.msg = TxMsgTransferNonFungibleMulti.read(r);
+                break;
+            case TxTypes.TransferNonFungible_Multi_GasPayer:
+                this.msg = TxMsgTransferNonFungibleMultiGasPayer.read(r);
+                break;
+            case TxTypes.MintFungible:
+                this.msg = TxMsgMintFungible.read(r);
+                break;
+            case TxTypes.BurnFungible:
+                this.msg = TxMsgBurnFungible.read(r);
+                break;
+            case TxTypes.BurnFungible_GasPayer:
+                this.msg = TxMsgBurnFungibleGasPayer.read(r);
+                break;
+            case TxTypes.MintNonFungible:
+                this.msg = TxMsgMintNonFungible.read(r);
+                break;
+            case TxTypes.BurnNonFungible:
+                this.msg = TxMsgBurnNonFungible.read(r);
+                break;
+            case TxTypes.BurnNonFungible_GasPayer:
+                this.msg = TxMsgBurnNonFungibleGasPayer.read(r);
+                break;
+            case TxTypes.Phantasma:
+                this.msg = TxMsgPhantasma.read(r);
+                break;
+            case TxTypes.Phantasma_Raw:
+                this.msg = TxMsgPhantasmaRaw.read(r);
+                break;
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    static read(r) {
+        const v = new TxMsg();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/types/carbon/blockchain/vm/index.js

@@ -0,0 +1,9 @@
+export * from './vm-dynamic-struct.js';
+export * from './vm-dynamic-variable.js';
+export * from './vm-named-dynamic-variable.js';
+export * from './vm-named-variable-schema.js';
+export * from './vm-struct-array.js';
+export * from './vm-struct-flags.js';
+export * from './vm-struct-schema.js';
+export * from './vm-type.js';
+export * from './vm-variable-schema.js';

package/dist/esm/types/carbon/blockchain/vm/vm-dynamic-struct.js

@@ -0,0 +1,81 @@
+import { VmNamedDynamicVariable } from './vm-named-dynamic-variable.js';
+import { VmDynamicVariable } from './vm-dynamic-variable.js';
+import { VmStructSchema } from './vm-struct-schema.js';
+export class VmDynamicStruct {
+    constructor() {
+        // NOTE: fields must be sorted by name
+        this.fields = [];
+    }
+    getValue(key) {
+        const found = this.fields.find((x) => x.name.data === key.data);
+        return found ? found.value : undefined;
+    }
+    write(w) {
+        if (this.fields.length > 1) {
+            this.fields.sort((a, b) => a.name.compareTo(b.name));
+        }
+        w.writeArrayBlob(this.fields);
+    }
+    read(r) {
+        this.fields = r.readArrayBlob(VmNamedDynamicVariable);
+        this.fields.sort((a, b) => a.name.compareTo(b.name));
+    }
+    static read(r) {
+        const v = new VmDynamicStruct();
+        v.read(r);
+        return v;
+    }
+    writeWithSchema(schema, w) {
+        let ok = true;
+        let fieldsFound = 0;
+        for (const f of schema.fields) {
+            const inStruct = this.fields.find((x) => x.name.data === f.name.data);
+            if (inStruct) {
+                inStruct.value.writeWithSchema(f.schema, w);
+                fieldsFound++;
+            }
+            else {
+                const error = VmDynamicVariable.fromType(f.schema.type);
+                error.writeWithSchema(f.schema, w);
+                ok = false;
+            }
+        }
+        if ((schema.flags & VmStructSchema.Flags.DynamicExtras) === 0) {
+            return ok;
+        }
+        if (fieldsFound === schema.fields.length && schema.fields.length === this.fields.length) {
+            w.write4u(0);
+            return ok;
+        }
+        const extras = [];
+        for (const f of this.fields) {
+            const inSchema = schema.fields.find((x) => x.name.data === f.name.data);
+            if (!inSchema)
+                extras.push(f);
+        }
+        w.writeArrayBlob(extras);
+        return ok;
+    }
+    readWithSchema(schema, r) {
+        if (schema.fields.length === 0) {
+            this.fields = [];
+        }
+        else {
+            this.fields = Array.from({ length: schema.fields.length }, () => new VmNamedDynamicVariable());
+            for (let i = 0; i < schema.fields.length; i++) {
+                this.fields[i].name = schema.fields[i].name;
+                this.fields[i].value = new VmDynamicVariable();
+                this.fields[i].value.readWithSchema(schema.fields[i].schema, r);
+            }
+        }
+        if ((schema.flags & VmStructSchema.Flags.DynamicExtras) === 0) {
+            if ((schema.flags & VmStructSchema.Flags.IsSorted) === 0) {
+                this.fields.sort((a, b) => a.name.compareTo(b.name));
+            }
+            return;
+        }
+        const extras = r.readArrayBlob(VmNamedDynamicVariable);
+        this.fields = this.fields.concat(extras);
+        this.fields.sort((a, b) => a.name.compareTo(b.name));
+    }
+}

package/dist/esm/types/carbon/blockchain/vm/vm-dynamic-variable.js

@@ -0,0 +1,356 @@
+import { VmType } from './vm-type.js';
+import { VmStructSchema } from './vm-struct-schema.js';
+import { VmDynamicStruct } from './vm-dynamic-struct.js';
+import { VmStructArray } from './vm-struct-array.js';
+import { Bytes16 } from '../../bytes16.js';
+import { Bytes32 } from '../../bytes32.js';
+import { Bytes64 } from '../../bytes64.js';
+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/types/carbon/blockchain/vm/vm-named-dynamic-variable.js

@@ -0,0 +1,32 @@
+import { hexToBytes } from '../../../../utils/index.js';
+import { SmallString } from '../../small-string.js';
+import { VmDynamicVariable } from './vm-dynamic-variable.js';
+import { VmType } from './vm-type.js';
+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/types/carbon/blockchain/vm/vm-named-variable-schema.js

@@ -0,0 +1,35 @@
+import { SmallString } from '../../small-string.js';
+import { VmVariableSchema } from './vm-variable-schema.js';
+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/types/carbon/blockchain/vm/vm-struct-array.js

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

package/dist/esm/types/carbon/blockchain/vm/vm-struct-flags.js

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