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

package/dist/esm/core/types/Carbon/Blockchain/Modules/SeriesInfo.js

@@ -0,0 +1,34 @@
+import { Bytes32 } from '../../Bytes32';
+import { VmStructSchema } from '../Vm/VmStructSchema';
+export class SeriesInfo {
+    constructor(init) {
+        this.maxMint = 0;
+        this.maxSupply = 0;
+        this.owner = new Bytes32();
+        this.metadata = new Uint8Array();
+        this.rom = new VmStructSchema();
+        this.ram = new VmStructSchema();
+        Object.assign(this, init);
+    }
+    write(w) {
+        w.write4u(this.maxMint);
+        w.write4u(this.maxSupply);
+        this.owner.write(w);
+        w.writeArray(this.metadata);
+        this.rom.write(w);
+        this.ram.write(w);
+    }
+    read(r) {
+        this.maxMint = r.read4u();
+        this.maxSupply = r.read4u();
+        this.owner = Bytes32.read(r);
+        this.metadata = r.readArray();
+        this.rom = r.readBlob(VmStructSchema);
+        this.ram = r.readBlob(VmStructSchema);
+    }
+    static read(r) {
+        const v = new SeriesInfo();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Modules/StandardMeta.js

@@ -0,0 +1,26 @@
+import { SmallString } from '../../SmallString';
+export const StandardMeta = {
+    id: new SmallString('_i'),
+    Chain: {
+        address: new SmallString('_a'),
+        name: new SmallString('_n'),
+        nexus: new SmallString('_x'),
+        tokenomics: new SmallString('_t'),
+    },
+    Token: {
+        staking_org_id: new SmallString('_soi'),
+        staking_org_threshold: new SmallString('_sot'),
+        staking_reward_token: new SmallString('_srt'),
+        staking_reward_period: new SmallString('_srp'),
+        staking_reward_mul: new SmallString('_srm'),
+        staking_reward_div: new SmallString('_srd'),
+        staking_lock: new SmallString('_sl'),
+        staking_booster_token: new SmallString('_sbt'),
+        staking_booster_mul: new SmallString('_sbm'),
+        staking_booster_div: new SmallString('_sbd'),
+        staking_booster_limit: new SmallString('_sbl'),
+        phantasma_script: new SmallString('_phs'),
+        phantasma_abi: new SmallString('_phb'),
+        pre_burn: new SmallString('_brn'),
+    },
+};

package/dist/esm/core/types/Carbon/Blockchain/Modules/TokenContract_Methods.js

@@ -0,0 +1,25 @@
+export var TokenContract_Methods;
+(function (TokenContract_Methods) {
+    TokenContract_Methods[TokenContract_Methods["TransferFungible"] = 0] = "TransferFungible";
+    TokenContract_Methods[TokenContract_Methods["TransferNonFungible"] = 1] = "TransferNonFungible";
+    TokenContract_Methods[TokenContract_Methods["CreateToken"] = 2] = "CreateToken";
+    TokenContract_Methods[TokenContract_Methods["MintFungible"] = 3] = "MintFungible";
+    TokenContract_Methods[TokenContract_Methods["BurnFungible"] = 4] = "BurnFungible";
+    TokenContract_Methods[TokenContract_Methods["GetBalance"] = 5] = "GetBalance";
+    TokenContract_Methods[TokenContract_Methods["CreateTokenSeries"] = 6] = "CreateTokenSeries";
+    TokenContract_Methods[TokenContract_Methods["DeleteTokenSeries"] = 7] = "DeleteTokenSeries";
+    TokenContract_Methods[TokenContract_Methods["MintNonFungible"] = 8] = "MintNonFungible";
+    TokenContract_Methods[TokenContract_Methods["BurnNonFungible"] = 9] = "BurnNonFungible";
+    TokenContract_Methods[TokenContract_Methods["GetInstances"] = 10] = "GetInstances";
+    TokenContract_Methods[TokenContract_Methods["GetNonFungibleInfo"] = 11] = "GetNonFungibleInfo";
+    TokenContract_Methods[TokenContract_Methods["GetNonFungibleInfoByRomId"] = 12] = "GetNonFungibleInfoByRomId";
+    TokenContract_Methods[TokenContract_Methods["GetSeriesInfo"] = 13] = "GetSeriesInfo";
+    TokenContract_Methods[TokenContract_Methods["GetSeriesInfoByMetaId"] = 14] = "GetSeriesInfoByMetaId";
+    TokenContract_Methods[TokenContract_Methods["GetTokenInfo"] = 15] = "GetTokenInfo";
+    TokenContract_Methods[TokenContract_Methods["GetTokenInfoBySymbol"] = 16] = "GetTokenInfoBySymbol";
+    TokenContract_Methods[TokenContract_Methods["GetTokenSupply"] = 17] = "GetTokenSupply";
+    TokenContract_Methods[TokenContract_Methods["GetSeriesSupply"] = 18] = "GetSeriesSupply";
+    TokenContract_Methods[TokenContract_Methods["GetTokenIdBySymbol"] = 19] = "GetTokenIdBySymbol";
+    TokenContract_Methods[TokenContract_Methods["GetBalances"] = 20] = "GetBalances";
+    TokenContract_Methods[TokenContract_Methods["CreateMintedTokenSeries"] = 21] = "CreateMintedTokenSeries";
+})(TokenContract_Methods || (TokenContract_Methods = {}));

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

@@ -0,0 +1,37 @@
+import { CarbonBinaryWriter } from '../../../CarbonSerialization';
+import { Bytes32 } from '../../Bytes32';
+export class TokenHelper {
+    static getNftAddress(carbonTokenId, instanceId) {
+        const w = new 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(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,
+        };
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Modules/TokenInfo.js

@@ -0,0 +1,46 @@
+import { IntX } from '../../IntX';
+import { Bytes32 } from '../../Bytes32';
+import { SmallString } from '../../SmallString';
+import { CarbonTokenFlags } from '../CarbonTokenFlags';
+export class TokenInfo {
+    constructor(init) {
+        this.maxSupply = new IntX();
+        this.flags = CarbonTokenFlags.None;
+        this.decimals = 0;
+        this.owner = new Bytes32();
+        this.symbol = new SmallString();
+        this.metadata = new Uint8Array();
+        this.tokenSchemas = undefined;
+        Object.assign(this, init);
+    }
+    write(w) {
+        this.maxSupply.write(w);
+        w.write1(this.flags & 0xff);
+        w.write1(this.decimals & 0xff);
+        this.owner.write(w);
+        this.symbol.write(w);
+        w.writeArray(this.metadata);
+        if ((this.flags & CarbonTokenFlags.NonFungible) !== 0) {
+            w.writeArray(this.tokenSchemas ?? new Uint8Array());
+        }
+    }
+    read(r) {
+        this.maxSupply = r.readBlob(IntX);
+        this.flags = r.read1();
+        this.decimals = r.read1();
+        this.owner = Bytes32.read(r);
+        this.symbol = r.readBlob(SmallString);
+        this.metadata = r.readArray();
+        if ((this.flags & CarbonTokenFlags.NonFungible) !== 0) {
+            this.tokenSchemas = r.readArray();
+        }
+        else {
+            this.tokenSchemas = undefined;
+        }
+    }
+    static read(r) {
+        const v = new TokenInfo();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/Modules/TokenSchemas.js

@@ -0,0 +1,24 @@
+import { VmStructSchema } from '../Vm/VmStructSchema';
+export class TokenSchemas {
+    constructor(init) {
+        this.seriesMetadata = new VmStructSchema();
+        this.rom = new VmStructSchema();
+        this.ram = new VmStructSchema();
+        Object.assign(this, init);
+    }
+    write(w) {
+        this.seriesMetadata.write(w);
+        this.rom.write(w);
+        this.ram.write(w);
+    }
+    read(r) {
+        this.seriesMetadata = r.readBlob(VmStructSchema);
+        this.rom = r.readBlob(VmStructSchema);
+        this.ram = r.readBlob(VmStructSchema);
+    }
+    static read(r) {
+        const v = new TokenSchemas();
+        v.read(r);
+        return v;
+    }
+}

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

@@ -0,0 +1,7 @@
+export * from "./Builders";
+export * from "./SeriesInfo";
+export * from "./StandardMeta";
+export * from "./TokenContract_Methods";
+export * from "./TokenHelper";
+export * from "./TokenInfo";
+export * from "./TokenSchemas";

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

@@ -0,0 +1,109 @@
+import { Bytes32 } from '../Bytes32';
+import { Bytes64 } from '../Bytes64';
+import { TxTypes } from '../TxTypes';
+import { Witness } from '../Witness';
+import { TxMsg } from './TxMsg';
+export class SignedTxMsg {
+    constructor(msg, witnesses) {
+        this.msg = msg;
+        this.witnesses = witnesses;
+    }
+    write(w) {
+        this.msg.write(w);
+        switch (this.msg.type) {
+            case TxTypes.TransferFungible:
+            case TxTypes.TransferNonFungible_Single:
+            case TxTypes.TransferNonFungible_Multi:
+            case TxTypes.MintFungible:
+            case TxTypes.BurnFungible:
+            case TxTypes.MintNonFungible:
+            case TxTypes.BurnNonFungible: {
+                if (this.witnesses.length !== 1)
+                    throw new Error('Expected 1 witness');
+                const w0 = this.witnesses[0];
+                // assert witness address equals msg.gasFrom
+                if (!w0.address.equals(this.msg.gasFrom))
+                    throw new Error('Witness address mismatch');
+                w.write64(w0.signature.bytes);
+                break;
+            }
+            case TxTypes.TransferFungible_GasPayer:
+            case TxTypes.TransferNonFungible_Single_GasPayer:
+            case TxTypes.TransferNonFungible_Multi_GasPayer:
+            case TxTypes.BurnFungible_GasPayer:
+            case TxTypes.BurnNonFungible_GasPayer: {
+                if (this.witnesses.length !== 2)
+                    throw new Error('Expected 2 witnesses');
+                const w0 = this.witnesses[0];
+                const w1 = this.witnesses[1];
+                if (!w0.address.equals(this.msg.gasFrom))
+                    throw new Error('Gas witness address mismatch');
+                // selecting "from" depends on concrete message type
+                w.write64(w0.signature.bytes);
+                w.write64(w1.signature.bytes);
+                throw new Error('Unsupported transaction type');
+                break;
+            }
+            case TxTypes.Call:
+            case TxTypes.Call_Multi:
+            case TxTypes.Trade:
+            case TxTypes.Phantasma: {
+                w.writeArrayBlob(this.witnesses);
+                break;
+            }
+            case TxTypes.Phantasma_Raw: {
+                if (this.witnesses.length !== 0)
+                    throw new Error('No witnesses expected');
+                break;
+            }
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    read(r) {
+        this.msg = TxMsg.read(r);
+        this.witnesses = [];
+        switch (this.msg.type) {
+            case TxTypes.TransferFungible:
+            case TxTypes.TransferNonFungible_Single:
+            case TxTypes.TransferNonFungible_Multi:
+            case TxTypes.MintFungible:
+            case TxTypes.BurnFungible:
+            case TxTypes.MintNonFungible:
+            case TxTypes.BurnNonFungible: {
+                const sig = Bytes64.read(r);
+                this.witnesses = [new Witness(this.msg.gasFrom, sig)];
+                break;
+            }
+            case TxTypes.TransferFungible_GasPayer:
+            case TxTypes.TransferNonFungible_Single_GasPayer:
+            case TxTypes.TransferNonFungible_Multi_GasPayer:
+            case TxTypes.BurnFungible_GasPayer:
+            case TxTypes.BurnNonFungible_GasPayer: {
+                const sig0 = Bytes64.read(r);
+                const sig1 = Bytes64.read(r);
+                // "from" resolution depends on concrete message type; omitted here
+                this.witnesses = [new Witness(this.msg.gasFrom, sig0), new Witness(Bytes32.Empty, sig1)];
+                throw new Error('Unsupported transaction type');
+                break;
+            }
+            case TxTypes.Call:
+            case TxTypes.Call_Multi:
+            case TxTypes.Trade:
+            case TxTypes.Phantasma: {
+                this.witnesses = r.readArrayBlob(Witness);
+                break;
+            }
+            case TxTypes.Phantasma_Raw:
+                this.witnesses = [];
+                break;
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    static read(r) {
+        const v = new SignedTxMsg();
+        v.read(r);
+        return v;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/TxHelpers/CreateTokenSeriesTxHelper.js

@@ -0,0 +1,50 @@
+import { bytesToHex, hexToBytes } from '../../../../utils';
+import { CarbonBinaryReader, CarbonBinaryWriter } from '../../../CarbonSerialization';
+import { Bytes32 } from '../../Bytes32';
+import { SmallString } from '../../SmallString';
+import { TxTypes } from '../../TxTypes';
+import { TxMsgSigner } from '../Extensions/TxMsgSigner';
+import { ModuleId } from '../ModuleId';
+import { TokenContract_Methods } from '../Modules';
+import { TxMsg } from '../TxMsg';
+import { TxMsgCall } from '../TxMsgCall';
+import { CreateSeriesFeeOptions } from './FeeOptions';
+export class CreateTokenSeriesTxHelper {
+    /** Build a Tx without signing. */
+    static buildTx(tokenId, // ulong
+    seriesInfo, creatorPublicKey, feeOptions, maxData, expiry) {
+        const fees = feeOptions ?? new CreateSeriesFeeOptions();
+        const maxGas = fees.calculateMaxGas();
+        const argsW = new CarbonBinaryWriter();
+        argsW.write8(tokenId);
+        seriesInfo.write(argsW);
+        // --- Tx message: Call(Token.CreateTokenSeries, args) ---
+        const msg = new TxMsg();
+        msg.type = TxTypes.Call;
+        msg.expiry = expiry || BigInt(Date.now() + 60000);
+        msg.maxGas = maxGas;
+        msg.maxData = maxData;
+        msg.gasFrom = creatorPublicKey;
+        msg.payload = SmallString.empty;
+        const call = new TxMsgCall();
+        call.moduleId = ModuleId.Token;
+        call.methodId = TokenContract_Methods.CreateTokenSeries;
+        call.args = argsW.toUint8Array();
+        msg.msg = call;
+        return msg;
+    }
+    /** Build and sign, returning raw bytes. */
+    static buildTxAndSign(tokenId, seriesInfo, signer, feeOptions, maxData, expiry) {
+        const tx = this.buildTx(tokenId, seriesInfo, new Bytes32(signer.PublicKey), feeOptions, maxData, expiry);
+        return TxMsgSigner.signAndSerialize(tx, signer);
+    }
+    /** Build, sign and return hex string. */
+    static buildTxAndSignHex(tokenId, seriesInfo, signer, feeOptions, maxData, expiry) {
+        return bytesToHex(this.buildTxAndSign(tokenId, seriesInfo, signer, feeOptions, maxData, expiry));
+    }
+    static parseResult(resultHex) {
+        // UInt32 carbon seriesId
+        const r = new CarbonBinaryReader(hexToBytes(resultHex));
+        return r.read4u();
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/TxHelpers/CreateTokenTxHelper.js

@@ -0,0 +1,45 @@
+import { bytesToHex, hexToBytes } from '../../../../utils';
+import { CarbonBinaryReader, CarbonBinaryWriter } from '../../../CarbonSerialization';
+import { Bytes32 } from '../../Bytes32';
+import { SmallString } from '../../SmallString';
+import { TxTypes } from '../../TxTypes';
+import { TxMsgSigner } from '../Extensions/TxMsgSigner';
+import { ModuleId } from '../ModuleId';
+import { TokenContract_Methods } from '../Modules';
+import { TxMsg } from '../TxMsg';
+import { TxMsgCall } from '../TxMsgCall';
+import { CreateTokenFeeOptions } from './FeeOptions';
+export class CreateTokenTxHelper {
+    static buildTx(tokenInfo, creatorPublicKey, feeOptions, maxData, expiry) {
+        const fees = feeOptions ?? new CreateTokenFeeOptions();
+        const maxGas = fees.calculateMaxGas(tokenInfo.symbol);
+        const msg = new TxMsg();
+        msg.type = TxTypes.Call;
+        msg.expiry = expiry || BigInt(Date.now() + 60000);
+        msg.maxGas = maxGas;
+        msg.maxData = maxData;
+        msg.gasFrom = creatorPublicKey;
+        msg.payload = SmallString.empty;
+        const argsW = new CarbonBinaryWriter();
+        tokenInfo.write(argsW);
+        const call = new TxMsgCall();
+        call.moduleId = ModuleId.Token;
+        call.methodId = TokenContract_Methods.CreateToken;
+        call.args = argsW.toUint8Array();
+        msg.msg = call;
+        return msg;
+    }
+    static buildTxAndSign(tokenInfo, signer, feeOptions, maxData, expiry) {
+        const tx = this.buildTx(tokenInfo, new Bytes32(signer.PublicKey), feeOptions, maxData, expiry);
+        return TxMsgSigner.signAndSerialize(tx, signer);
+    }
+    static buildTxAndSignHex(tokenInfo, signer, feeOptions, maxData, expiry) {
+        const bytes = this.buildTxAndSign(tokenInfo, signer, feeOptions, maxData, expiry);
+        return bytesToHex(bytes);
+    }
+    static parseResult(resultHex) {
+        // UInt32 carbon tokenId
+        const r = new CarbonBinaryReader(hexToBytes(resultHex));
+        return r.read4u();
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/TxHelpers/FeeOptions.js

@@ -0,0 +1,49 @@
+// namespace PhantasmaPhoenix.Protocol.Carbon.Blockchain.TxHelpers
+/** Base fee options with sensible defaults. */
+export class FeeOptions {
+    constructor(gasFeeBase = 10000n, feeMultiplier = 1000n) {
+        this.gasFeeBase = gasFeeBase;
+        this.feeMultiplier = feeMultiplier;
+    }
+    calculateMaxGas(..._args) {
+        return this.gasFeeBase * this.feeMultiplier;
+    }
+}
+/** Fee options for token creation transactions. */
+export class CreateTokenFeeOptions extends FeeOptions {
+    constructor(gasFeeBase = 10000n, gasFeeCreateTokenBase = 10000000000n, gasFeeCreateTokenSymbol = 10000000000n, feeMultiplier = 10000n) {
+        super(gasFeeBase, feeMultiplier);
+        this.gasFeeCreateTokenBase = gasFeeCreateTokenBase;
+        this.gasFeeCreateTokenSymbol = gasFeeCreateTokenSymbol;
+    }
+    calculateMaxGas(...args) {
+        let symbol = '';
+        if (args.length > 0 && typeof args[0] === 'object' && args[0] !== null && 'data' in args[0]) {
+            const s = args[0];
+            symbol = s.data;
+        }
+        const symbolLen = symbol.length;
+        const shift = symbolLen > 0 ? BigInt(symbolLen - 1) : 0n;
+        const symbolCost = this.gasFeeCreateTokenSymbol >> shift;
+        return (this.gasFeeBase + this.gasFeeCreateTokenBase + symbolCost) * this.feeMultiplier;
+    }
+}
+/** Fee options for creating a new series on an NFT token. */
+export class CreateSeriesFeeOptions extends FeeOptions {
+    constructor(gasFeeBase = 10000n, gasFeeCreateSeriesBase = 2500000000n, feeMultiplier = 10000n) {
+        super(gasFeeBase, feeMultiplier);
+        this.gasFeeCreateSeriesBase = gasFeeCreateSeriesBase;
+    }
+    calculateMaxGas(..._args) {
+        return (this.gasFeeBase + this.gasFeeCreateSeriesBase) * this.feeMultiplier;
+    }
+}
+/** Fee options for minting non-fungible tokens (NFT instances). */
+export class MintNftFeeOptions extends FeeOptions {
+    constructor(gasFeeBase = 10000n, feeMultiplier = 1000n) {
+        super(gasFeeBase, feeMultiplier);
+    }
+    calculateMaxGas(..._args) {
+        return this.gasFeeBase * this.feeMultiplier;
+    }
+}

package/dist/esm/core/types/Carbon/Blockchain/TxHelpers/MintNonFungibleTxHelper.js

@@ -0,0 +1,54 @@
+import { bytesToHex, hexToBytes } from '../../../../utils';
+import { CarbonBinaryReader } from '../../../CarbonSerialization';
+import { Bytes32 } from '../../Bytes32';
+import { SmallString } from '../../SmallString';
+import { TxTypes } from '../../TxTypes';
+import { TxMsgSigner } from '../Extensions/TxMsgSigner';
+import { TokenHelper } from '../Modules/TokenHelper';
+import { TxMsg } from '../TxMsg';
+import { TxMsgMintNonFungible } from '../TxMsgMintNonFungible';
+import { MintNftFeeOptions } from './FeeOptions';
+export class MintNonFungibleTxHelper {
+    // Build a Tx without signing
+    static buildTx(carbonTokenId, carbonSeriesId, senderPublicKey, receiverPublicKey, rom, ram, feeOptions, maxData, expiry) {
+        const fees = feeOptions ?? new MintNftFeeOptions();
+        const maxGas = fees.calculateMaxGas();
+        const msg = new TxMsg();
+        msg.type = TxTypes.MintNonFungible;
+        msg.expiry = expiry || BigInt(Date.now() + 60000);
+        msg.maxGas = maxGas;
+        msg.maxData = maxData;
+        msg.gasFrom = senderPublicKey;
+        msg.payload = SmallString.empty;
+        const mint = new TxMsgMintNonFungible();
+        mint.tokenId = carbonTokenId;
+        mint.seriesId = carbonSeriesId;
+        mint.to = receiverPublicKey;
+        mint.rom = rom;
+        mint.ram = ram;
+        msg.msg = mint;
+        return msg;
+    }
+    // Build and sign, returning raw bytes
+    static buildTxAndSign(tokenId, seriesId, signer, receiverPublicKey, rom, ram, feeOptions, maxData, expiry) {
+        const senderPub = new Bytes32(signer.PublicKey);
+        const tx = this.buildTx(tokenId, seriesId, senderPub, receiverPublicKey, rom, ram, feeOptions, maxData, expiry);
+        return TxMsgSigner.signAndSerialize(tx, signer);
+    }
+    // Build, sign and return hex string
+    static buildTxAndSignHex(tokenId, seriesId, signer, receiverPublicKey, rom, ram, feeOptions, maxData, expiry) {
+        const bytes = this.buildTxAndSign(tokenId, seriesId, signer, receiverPublicKey, rom, ram, feeOptions, maxData, expiry);
+        return bytesToHex(bytes);
+    }
+    static parseResult(carbonTokenId, resultHex) {
+        const result = [];
+        const r = new CarbonBinaryReader(hexToBytes(resultHex));
+        const count = r.read4u();
+        for (let i = 0; i < count; i++) {
+            const instanceId = r.read8u();
+            const carbonNftId = TokenHelper.getNftAddress(carbonTokenId, instanceId);
+            result.push(carbonNftId);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./CreateTokenSeriesTxHelper";
+export * from "./CreateTokenTxHelper";
+export * from "./FeeOptions";
+export * from "./MintNonFungibleTxHelper";