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

package/dist/cjs/core/types/Carbon/Blockchain/Modules/Builders/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IdHelper"), exports);
+__exportStar(require("./NftRomBuilder"), exports);
+__exportStar(require("./SeriesInfoBuilder"), exports);
+__exportStar(require("./TokenInfoBuilder"), exports);
+__exportStar(require("./TokenMetadataBuilder"), exports);
+__exportStar(require("./TokenSchemasBuilder"), exports);
+__exportStar(require("./TokenSeriesMetadataBuilder"), exports);
+__exportStar(require("./MetadataHelper"), exports);

package/dist/cjs/core/types/Carbon/Blockchain/Modules/TokenHelper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenHelper = void 0;
+const CarbonSerialization_1 = require("../../../CarbonSerialization");
+const Bytes32_1 = require("../../Bytes32");
+class TokenHelper {
+    static getNftAddress(carbonTokenId, instanceId) {
+        const w = new CarbonSerialization_1.CarbonBinaryWriter();
+        w.write(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) // Carbon NFT ID prefix
+        );
+        w.write8u(carbonTokenId);
+        w.write8u(instanceId);
+        return new Bytes32_1.Bytes32(w.toUint8Array());
+    }
+    static readUint64LE(bytes, offset) {
+        let result = 0n;
+        for (let i = 0; i < 8; i++) {
+            result |= BigInt(bytes[offset + i]) << (BigInt(i) * 8n);
+        }
+        return result;
+    }
+    /**
+     * Unpacks a Carbon NFT address (32 bytes) into its logical parts:
+     * - carbonTokenId: identifies the NFT token contract
+     * - instanceId: 64-bit composite id (series + mint)
+     * - seriesId / mintNumber: 32-bit halves of instanceId
+     */
+    static unpackNftAddress(address) {
+        const carbonTokenId = this.readUint64LE(address, 16);
+        const instanceId = this.readUint64LE(address, 24);
+        const seriesId = Number(instanceId & 0xffffffffn);
+        const mintNumber = Number((instanceId >> 32n) & 0xffffffffn);
+        return {
+            carbonTokenId,
+            instanceId,
+            seriesId,
+            mintNumber,
+        };
+    }
+}
+exports.TokenHelper = TokenHelper;

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

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsg = void 0;
+const Bytes32_1 = require("../Bytes32");
+const SmallString_1 = require("../SmallString");
+const TxTypes_1 = require("../TxTypes");
+const TxMsgCall_1 = require("./TxMsgCall");
+const TxMsgCallMulti_1 = require("./TxMsgCallMulti");
+const TxMsgMintFungible_1 = require("./TxMsgMintFungible");
+const TxMsgMintNonFungible_1 = require("./TxMsgMintNonFungible");
+const TxMsgTrade_1 = require("./TxMsgTrade");
+const TxMsgTransferFungible_1 = require("./TxMsgTransferFungible");
+const TxMsgTransferFungibleGasPayer_1 = require("./TxMsgTransferFungibleGasPayer");
+const TxMsgTransferNonFungibleMulti_1 = require("./TxMsgTransferNonFungibleMulti");
+const TxMsgTransferNonFungibleMultiGasPayer_1 = require("./TxMsgTransferNonFungibleMultiGasPayer");
+const TxMsgTransferNonFungibleSingle_1 = require("./TxMsgTransferNonFungibleSingle");
+const TxMsgTransferNonFungibleSingleGasPayer_1 = require("./TxMsgTransferNonFungibleSingleGasPayer");
+const TxMsgBurnFungible_1 = require("./TxMsgBurnFungible");
+const TxMsgBurnFungibleGasPayer_1 = require("./TxMsgBurnFungibleGasPayer");
+const TxMsgBurnNonFungible_1 = require("./TxMsgBurnNonFungible");
+const TxMsgBurnNonFungibleGasPayer_1 = require("./TxMsgBurnNonFungibleGasPayer");
+const TxMsgPhantasma_1 = require("./TxMsgPhantasma");
+const TxMsgPhantasmaRaw_1 = require("./TxMsgPhantasmaRaw");
+class TxMsg {
+    constructor(type = TxTypes_1.TxTypes.Call, expiry = 0n, // int64
+    maxGas = 0n, // uint64
+    maxData = 0n, // uint64
+    gasFrom = new Bytes32_1.Bytes32(), payload = new SmallString_1.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_1.TxTypes.Call:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.Call_Multi:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.Trade:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Single:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Single_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Multi:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Multi_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.MintFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.BurnFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.BurnFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.MintNonFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.BurnNonFungible:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.BurnNonFungible_GasPayer:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.TxTypes.Phantasma:
+                this.msg.write(w);
+                break;
+            case TxTypes_1.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_1.Bytes32.read(r);
+        this.payload = SmallString_1.SmallString.read(r);
+        switch (this.type) {
+            case TxTypes_1.TxTypes.Call:
+                this.msg = TxMsgCall_1.TxMsgCall.read(r);
+                break;
+            case TxTypes_1.TxTypes.Call_Multi:
+                this.msg = TxMsgCallMulti_1.TxMsgCallMulti.read(r);
+                break;
+            case TxTypes_1.TxTypes.Trade:
+                this.msg = TxMsgTrade_1.TxMsgTrade.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferFungible:
+                this.msg = TxMsgTransferFungible_1.TxMsgTransferFungible.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferFungible_GasPayer:
+                this.msg = TxMsgTransferFungibleGasPayer_1.TxMsgTransferFungibleGasPayer.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Single:
+                this.msg = TxMsgTransferNonFungibleSingle_1.TxMsgTransferNonFungibleSingle.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Single_GasPayer:
+                this.msg = TxMsgTransferNonFungibleSingleGasPayer_1.TxMsgTransferNonFungibleSingleGasPayer.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Multi:
+                this.msg = TxMsgTransferNonFungibleMulti_1.TxMsgTransferNonFungibleMulti.read(r);
+                break;
+            case TxTypes_1.TxTypes.TransferNonFungible_Multi_GasPayer:
+                this.msg = TxMsgTransferNonFungibleMultiGasPayer_1.TxMsgTransferNonFungibleMultiGasPayer.read(r);
+                break;
+            case TxTypes_1.TxTypes.MintFungible:
+                this.msg = TxMsgMintFungible_1.TxMsgMintFungible.read(r);
+                break;
+            case TxTypes_1.TxTypes.BurnFungible:
+                this.msg = TxMsgBurnFungible_1.TxMsgBurnFungible.read(r);
+                break;
+            case TxTypes_1.TxTypes.BurnFungible_GasPayer:
+                this.msg = TxMsgBurnFungibleGasPayer_1.TxMsgBurnFungibleGasPayer.read(r);
+                break;
+            case TxTypes_1.TxTypes.MintNonFungible:
+                this.msg = TxMsgMintNonFungible_1.TxMsgMintNonFungible.read(r);
+                break;
+            case TxTypes_1.TxTypes.BurnNonFungible:
+                this.msg = TxMsgBurnNonFungible_1.TxMsgBurnNonFungible.read(r);
+                break;
+            case TxTypes_1.TxTypes.BurnNonFungible_GasPayer:
+                this.msg = TxMsgBurnNonFungibleGasPayer_1.TxMsgBurnNonFungibleGasPayer.read(r);
+                break;
+            case TxTypes_1.TxTypes.Phantasma:
+                this.msg = TxMsgPhantasma_1.TxMsgPhantasma.read(r);
+                break;
+            case TxTypes_1.TxTypes.Phantasma_Raw:
+                this.msg = TxMsgPhantasmaRaw_1.TxMsgPhantasmaRaw.read(r);
+                break;
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    static read(r) {
+        const v = new TxMsg();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsg = TxMsg;

package/dist/cjs/core/types/Carbon/Blockchain/TxMsgBurnFungible.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgBurnFungible = void 0;
+const IntX_1 = require("../IntX");
+class TxMsgBurnFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.amount = IntX_1.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_1.IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgBurnFungible();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgBurnFungible = TxMsgBurnFungible;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgBurnFungibleGasPayer = void 0;
+const Bytes32_1 = require("../Bytes32");
+const IntX_1 = require("../IntX");
+class TxMsgBurnFungibleGasPayer {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.from = new Bytes32_1.Bytes32();
+        this.amount = IntX_1.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_1.Bytes32.read(r);
+        this.amount = IntX_1.IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgBurnFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgBurnFungibleGasPayer = TxMsgBurnFungibleGasPayer;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgBurnNonFungible = void 0;
+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;
+    }
+}
+exports.TxMsgBurnNonFungible = TxMsgBurnNonFungible;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgBurnNonFungibleGasPayer = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgBurnNonFungibleGasPayer {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.from = new Bytes32_1.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_1.Bytes32.read(r);
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgBurnNonFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgBurnNonFungibleGasPayer = TxMsgBurnNonFungibleGasPayer;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgCallMulti = void 0;
+const TxMsgCall_1 = require("./TxMsgCall");
+class TxMsgCallMulti {
+    constructor(calls = []) {
+        this.calls = calls;
+    }
+    write(w) {
+        w.writeArrayBlob(this.calls);
+    }
+    read(r) {
+        this.calls = r.readArrayBlob(TxMsgCall_1.TxMsgCall);
+    }
+    static read(r) {
+        const v = new TxMsgCallMulti();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgCallMulti = TxMsgCallMulti;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgMintFungible = void 0;
+const Bytes32_1 = require("../Bytes32");
+const IntX_1 = require("../IntX");
+class TxMsgMintFungible {
+    constructor(init) {
+        this.tokenId = 0n;
+        this.to = new Bytes32_1.Bytes32();
+        this.amount = IntX_1.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_1.Bytes32.read(r);
+        this.amount = IntX_1.IntX.read(r);
+    }
+    static read(r) {
+        const v = new TxMsgMintFungible();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgMintFungible = TxMsgMintFungible;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgPhantasma = void 0;
+const SmallString_1 = require("../SmallString");
+class TxMsgPhantasma {
+    constructor(init) {
+        this.nexus = new SmallString_1.SmallString('');
+        this.chain = new SmallString_1.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_1.SmallString.read(r);
+        this.chain = SmallString_1.SmallString.read(r);
+        this.script = r.readArray();
+    }
+    static read(r) {
+        const v = new TxMsgPhantasma();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgPhantasma = TxMsgPhantasma;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgPhantasmaRaw = void 0;
+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;
+    }
+}
+exports.TxMsgPhantasmaRaw = TxMsgPhantasmaRaw;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTrade = void 0;
+const TxMsgBurnFungibleGasPayer_1 = require("./TxMsgBurnFungibleGasPayer");
+const TxMsgBurnNonFungibleGasPayer_1 = require("./TxMsgBurnNonFungibleGasPayer");
+const TxMsgMintFungible_1 = require("./TxMsgMintFungible");
+const TxMsgMintNonFungible_1 = require("./TxMsgMintNonFungible");
+const TxMsgTransferFungibleGasPayer_1 = require("./TxMsgTransferFungibleGasPayer");
+const TxMsgTransferNonFungibleSingleGasPayer_1 = require("./TxMsgTransferNonFungibleSingleGasPayer");
+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_1.TxMsgTransferFungibleGasPayer);
+        this.transferN = r.readArrayBlob(TxMsgTransferNonFungibleSingleGasPayer_1.TxMsgTransferNonFungibleSingleGasPayer);
+        this.mintF = r.readArrayBlob(TxMsgMintFungible_1.TxMsgMintFungible);
+        this.burnF = r.readArrayBlob(TxMsgBurnFungibleGasPayer_1.TxMsgBurnFungibleGasPayer);
+        this.mintN = r.readArrayBlob(TxMsgMintNonFungible_1.TxMsgMintNonFungible);
+        this.burnN = r.readArrayBlob(TxMsgBurnNonFungibleGasPayer_1.TxMsgBurnNonFungibleGasPayer);
+    }
+    static read(r) {
+        const v = new TxMsgTrade();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTrade = TxMsgTrade;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTransferFungibleGasPayer = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgTransferFungibleGasPayer {
+    constructor(init) {
+        this.to = new Bytes32_1.Bytes32();
+        this.from = new Bytes32_1.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_1.Bytes32.read(r);
+        this.from = Bytes32_1.Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.amount = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferFungibleGasPayer();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTransferFungibleGasPayer = TxMsgTransferFungibleGasPayer;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTransferNonFungibleMulti = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgTransferNonFungibleMulti {
+    constructor(init) {
+        this.to = new Bytes32_1.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_1.Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceIds = r.readArray64u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleMulti();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTransferNonFungibleMulti = TxMsgTransferNonFungibleMulti;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTransferNonFungibleMultiGasPayer = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgTransferNonFungibleMultiGasPayer {
+    constructor(init) {
+        this.to = new Bytes32_1.Bytes32();
+        this.from = new Bytes32_1.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_1.Bytes32.read(r);
+        this.from = Bytes32_1.Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceIds = r.readArray64u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleMultiGasPayer();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTransferNonFungibleMultiGasPayer = TxMsgTransferNonFungibleMultiGasPayer;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTransferNonFungibleSingle = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgTransferNonFungibleSingle {
+    constructor(init) {
+        this.to = new Bytes32_1.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_1.Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleSingle();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTransferNonFungibleSingle = TxMsgTransferNonFungibleSingle;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxMsgTransferNonFungibleSingleGasPayer = void 0;
+const Bytes32_1 = require("../Bytes32");
+class TxMsgTransferNonFungibleSingleGasPayer {
+    constructor(init) {
+        this.to = new Bytes32_1.Bytes32();
+        this.from = new Bytes32_1.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_1.Bytes32.read(r);
+        this.from = Bytes32_1.Bytes32.read(r);
+        this.tokenId = r.read8u();
+        this.instanceId = r.read8u();
+    }
+    static read(r) {
+        const v = new TxMsgTransferNonFungibleSingleGasPayer();
+        v.read(r);
+        return v;
+    }
+}
+exports.TxMsgTransferNonFungibleSingleGasPayer = TxMsgTransferNonFungibleSingleGasPayer;