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

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

@@ -0,0 +1,165 @@
+import { Bytes32 } from '../Bytes32';
+import { SmallString } from '../SmallString';
+import { TxTypes } from '../TxTypes';
+import { TxMsgCall } from './TxMsgCall';
+import { TxMsgCallMulti } from './TxMsgCallMulti';
+import { TxMsgMintFungible } from './TxMsgMintFungible';
+import { TxMsgMintNonFungible } from './TxMsgMintNonFungible';
+import { TxMsgTrade } from './TxMsgTrade';
+import { TxMsgTransferFungible } from './TxMsgTransferFungible';
+import { TxMsgTransferFungibleGasPayer } from './TxMsgTransferFungibleGasPayer';
+import { TxMsgTransferNonFungibleMulti } from './TxMsgTransferNonFungibleMulti';
+import { TxMsgTransferNonFungibleMultiGasPayer } from './TxMsgTransferNonFungibleMultiGasPayer';
+import { TxMsgTransferNonFungibleSingle } from './TxMsgTransferNonFungibleSingle';
+import { TxMsgTransferNonFungibleSingleGasPayer } from './TxMsgTransferNonFungibleSingleGasPayer';
+import { TxMsgBurnFungible } from './TxMsgBurnFungible';
+import { TxMsgBurnFungibleGasPayer } from './TxMsgBurnFungibleGasPayer';
+import { TxMsgBurnNonFungible } from './TxMsgBurnNonFungible';
+import { TxMsgBurnNonFungibleGasPayer } from './TxMsgBurnNonFungibleGasPayer';
+import { TxMsgPhantasma } from './TxMsgPhantasma';
+import { TxMsgPhantasmaRaw } from './TxMsgPhantasmaRaw';
+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/core/types/Carbon/Blockchain/TxMsgBurnFungible.js

@@ -0,0 +1,21 @@
+import { IntX } from '../IntX';
+export class TxMsgBurnFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.amount = IntX.fromI64(0);
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        this.amount.write(w);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.amount = IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgBurnFungible();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Bytes32 } from '../Bytes32';
+import { IntX } from '../IntX';
+export class TxMsgBurnFungibleGasPayer {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.from = new Bytes32();
+        this.amount = IntX.fromI64(0);
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        w.write32(this.from);
+        this.amount.write(w);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.from = Bytes32.read(r);
+        this.amount = IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgBurnFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,20 @@
+export class TxMsgBurnNonFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.instanceId = 0n;
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        w.write8u(this.instanceId);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgBurnNonFungible();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgBurnNonFungibleGasPayer {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.from = new Bytes32();
+        this.instanceId = 0n;
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        w.write32(this.from);
+        w.write8u(this.instanceId);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.from = Bytes32.read(r);
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgBurnNonFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,22 @@
+export class TxMsgCall {
+    constructor(moduleId = 0, methodId = 0, args = new Uint8Array()) {
+        this.moduleId = moduleId >>> 0;
+        this.methodId = methodId >>> 0;
+        this.args = args;
+    }
+    write(w) {
+        w.write4u(this.moduleId);
+        w.write4u(this.methodId);
+        w.writeArray(this.args);
+    }
+    read(r) {
+        this.moduleId = r.read4u();
+        this.methodId = r.read4u();
+        this.args = r.readArray();
+    }
+    static read(r) {
+        const v = new TxMsgCall();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { TxMsgCall } from './TxMsgCall';
+export class TxMsgCallMulti {
+    constructor(calls = []) {
+        this.calls = calls;
+    }
+    write(w) {
+        w.writeArrayBlob(this.calls);
+    }
+    read(r) {
+        this.calls = r.readArrayBlob(TxMsgCall);
+    }
+    static read(r) {
+        const v = new TxMsgCallMulti();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Bytes32 } from '../Bytes32';
+import { IntX } from '../IntX';
+export class TxMsgMintFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.to = new Bytes32();
+        this.amount = IntX.fromI64(0);
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        w.write32(this.to);
+        this.amount.write(w);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.to = Bytes32.read(r);
+        this.amount = IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgMintFungible();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgMintNonFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.to = new Bytes32();
+        this.seriesId = 0;
+        this.rom = new Uint8Array();
+        this.ram = new Uint8Array();
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write8u(this.tokenId);
+        w.write32(this.to);
+        w.write4u(this.seriesId);
+        w.writeArray(this.rom);
+        w.writeArray(this.ram);
+    }
+    read(r) {
+        this.tokenId = r.read8u();
+        this.to = Bytes32.read(r);
+        this.seriesId = r.read4u();
+        this.rom = r.readArray();
+        this.ram = r.readArray();
+    }
+    static read(r) {
+        const v = new TxMsgMintNonFungible();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { SmallString } from '../SmallString';
+export class TxMsgPhantasma {
+    constructor(init) {
+        this.nexus = new SmallString('');
+        this.chain = new SmallString('');
+        this.script = new Uint8Array();
+        Object.assign(this, init);
+    }
+    write(w) {
+        this.nexus.write(w);
+        this.chain.write(w);
+        w.writeArray(this.script);
+    }
+    read(r) {
+        this.nexus = SmallString.read(r);
+        this.chain = SmallString.read(r);
+        this.script = r.readArray();
+    }
+    static read(r) {
+        const v = new TxMsgPhantasma();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,16 @@
+export class TxMsgPhantasmaRaw {
+    constructor(transaction = new Uint8Array()) {
+        this.transaction = transaction;
+    }
+    write(w) {
+        w.writeArray(this.transaction);
+    }
+    read(r) {
+        this.transaction = r.readArray();
+    }
+    static read(r) {
+        const v = new TxMsgPhantasmaRaw();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,38 @@
+import { TxMsgBurnFungibleGasPayer } from './TxMsgBurnFungibleGasPayer';
+import { TxMsgBurnNonFungibleGasPayer } from './TxMsgBurnNonFungibleGasPayer';
+import { TxMsgMintFungible } from './TxMsgMintFungible';
+import { TxMsgMintNonFungible } from './TxMsgMintNonFungible';
+import { TxMsgTransferFungibleGasPayer } from './TxMsgTransferFungibleGasPayer';
+import { TxMsgTransferNonFungibleSingleGasPayer } from './TxMsgTransferNonFungibleSingleGasPayer';
+export class TxMsgTrade {
+    constructor(init) {
+        this.transferF = [];
+        this.transferN = [];
+        this.mintF = [];
+        this.burnF = [];
+        this.mintN = [];
+        this.burnN = [];
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.writeArrayBlob(this.transferF);
+        w.writeArrayBlob(this.transferN);
+        w.writeArrayBlob(this.mintF);
+        w.writeArrayBlob(this.burnF);
+        w.writeArrayBlob(this.mintN);
+        w.writeArrayBlob(this.burnN);
+    }
+    read(r) {
+        this.transferF = r.readArrayBlob(TxMsgTransferFungibleGasPayer);
+        this.transferN = r.readArrayBlob(TxMsgTransferNonFungibleSingleGasPayer);
+        this.mintF = r.readArrayBlob(TxMsgMintFungible);
+        this.burnF = r.readArrayBlob(TxMsgBurnFungibleGasPayer);
+        this.mintN = r.readArrayBlob(TxMsgMintNonFungible);
+        this.burnN = r.readArrayBlob(TxMsgBurnNonFungibleGasPayer);
+    }
+    static read(r) {
+        const v = new TxMsgTrade();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferFungible {
+    constructor(to, tokenId, amount) {
+        this.to = to;
+        this.tokenId = tokenId;
+        this.amount = amount;
+    }
+    write(w) {
+        this.to.write(w);
+        w.write8u(this.tokenId);
+        w.write8u(this.amount);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.amount = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferFungible();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferFungibleGasPayer {
+    constructor(init) {
+        this.to = new Bytes32();
+        this.from = new Bytes32();
+        this.tokenId = 0n;
+        this.amount = 0n;
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write32(this.to);
+        w.write32(this.from);
+        w.write8u(this.tokenId);
+        w.write8u(this.amount);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.from = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.amount = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferNonFungibleMulti {
+    constructor(init) {
+        this.to = new Bytes32();
+        this.tokenId = 0n;
+        this.instanceIds = [];
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write32(this.to);
+        w.write8u(this.tokenId);
+        w.writeArray64u(this.instanceIds);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceIds = r.readArray64u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleMulti();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferNonFungibleMultiGasPayer {
+    constructor(init) {
+        this.to = new Bytes32();
+        this.from = new Bytes32();
+        this.tokenId = 0n;
+        this.instanceIds = [];
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write32(this.to);
+        w.write32(this.from);
+        w.write8u(this.tokenId);
+        w.writeArray64u(this.instanceIds);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.from = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceIds = r.readArray64u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleMultiGasPayer();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferNonFungibleSingle {
+    constructor(init) {
+        this.to = new Bytes32();
+        this.tokenId = 0n;
+        this.instanceId = 0n;
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write32(this.to);
+        w.write8u(this.tokenId);
+        w.write8u(this.instanceId);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleSingle();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Bytes32 } from '../Bytes32';
+export class TxMsgTransferNonFungibleSingleGasPayer {
+    constructor(init) {
+        this.to = new Bytes32();
+        this.from = new Bytes32();
+        this.tokenId = 0n;
+        this.instanceId = 0n;
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write32(this.to);
+        w.write32(this.from);
+        w.write8u(this.tokenId);
+        w.write8u(this.instanceId);
+    }
+    read(r) {
+        this.to = Bytes32.read(r);
+        this.from = Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleSingleGasPayer();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,83 @@
+import { VmNamedDynamicVariable } from './VmNamedDynamicVariable';
+import { VmDynamicVariable } from './VmDynamicVariable';
+import { VmStructSchema } from './VmStructSchema';
+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 = new Array(schema.fields.length)
+                .fill(null)
+                .map(() => 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));
+    }
+}