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

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

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushMetadataField = exports.findMetadataField = exports.standardMetadataFields = exports.nftDefaultMetadataFields = exports.seriesDefaultMetadataFields = exports.FieldType = exports.MetadataField = void 0;
+const utils_1 = require("../../../../../utils");
+const Bytes16_1 = require("../../../Bytes16");
+const Bytes32_1 = require("../../../Bytes32");
+const Bytes64_1 = require("../../../Bytes64");
+const Vm_1 = require("../../Vm");
+const StandardMeta_1 = require("../StandardMeta");
+const INT64_MIN = -(1n << 63n);
+const INT64_MAX = (1n << 63n) - 1n;
+const UINT64_MAX = (1n << 64n) - 1n;
+const INT256_MIN = -(1n << 255n);
+const INT256_MAX = (1n << 255n) - 1n;
+const UINT256_MAX = (1n << 256n) - 1n;
+class MetadataField {
+}
+exports.MetadataField = MetadataField;
+class FieldType {
+}
+exports.FieldType = FieldType;
+exports.seriesDefaultMetadataFields = [
+    { name: StandardMeta_1.StandardMeta.id.data, type: Vm_1.VmType.Int256 },
+    { name: 'mode', type: Vm_1.VmType.Int8 },
+    { name: 'rom', type: Vm_1.VmType.Bytes }
+];
+exports.nftDefaultMetadataFields = [
+    { name: StandardMeta_1.StandardMeta.id.data, type: Vm_1.VmType.Int256 },
+    { name: 'rom', type: Vm_1.VmType.Bytes }
+];
+exports.standardMetadataFields = [
+    { name: 'name', type: Vm_1.VmType.String },
+    { name: 'description', type: Vm_1.VmType.String },
+    { name: 'imageURL', type: Vm_1.VmType.String },
+    { name: 'infoURL', type: Vm_1.VmType.String },
+    { name: 'royalties', type: Vm_1.VmType.Int32 }
+];
+function findMetadataField(fields, name) {
+    return fields.find(f => f.name.toLowerCase() === name.toLowerCase());
+}
+exports.findMetadataField = findMetadataField;
+function pushMetadataField(fieldSchema, metadata, metadataFields) {
+    let found = metadataFields.find(f => f.name === fieldSchema.name.data);
+    if (!found) {
+        found = metadataFields.find(f => f.name.toLowerCase() === fieldSchema.name.data.toLowerCase());
+        if (found) {
+            throw Error(`Metadata field '${fieldSchema.name.data}' provided in incorrect case: '${found.name}'`);
+        }
+        throw Error(`Metadata field '${fieldSchema.name.data}' is mandatory`);
+    }
+    const normalizedValue = normalizeMetadataValue(fieldSchema.schema, fieldSchema.name.data, found.value);
+    metadata.fields.push(Vm_1.VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, normalizedValue));
+}
+exports.pushMetadataField = pushMetadataField;
+function normalizeMetadataValue(schema, fieldName, value) {
+    if (value === null || value === undefined) {
+        throw Error(`Metadata field '${fieldName}' is mandatory`);
+    }
+    const isArray = (schema.type & Vm_1.VmType.Array) === Vm_1.VmType.Array;
+    const baseType = (isArray ? (schema.type & ~Vm_1.VmType.Array) : schema.type);
+    if (isArray) {
+        if (!Array.isArray(value)) {
+            throw Error(`Metadata field '${fieldName}' must be provided as an array`);
+        }
+        return normalizeArrayValue(baseType, fieldName, value, schema.structure);
+    }
+    return normalizeScalarValue(baseType, fieldName, value, schema.structure);
+}
+function normalizeScalarValue(type, fieldName, value, structSchema) {
+    switch (type) {
+        case Vm_1.VmType.String:
+            return ensureNonEmptyString(fieldName, value);
+        case Vm_1.VmType.Int8:
+            return ensureIntegerInRange(fieldName, value, -0x80, 0x7f, 0xff);
+        case Vm_1.VmType.Int16:
+            return ensureIntegerInRange(fieldName, value, -0x8000, 0x7fff, 0xffff);
+        case Vm_1.VmType.Int32:
+            return ensureIntegerInRange(fieldName, value, -0x80000000, 0x7fffffff, 0xffffffff);
+        case Vm_1.VmType.Int64:
+            return ensureBigInt(fieldName, value, INT64_MIN, INT64_MAX, 'Int64', UINT64_MAX);
+        case Vm_1.VmType.Int256:
+            return ensureBigInt(fieldName, value, INT256_MIN, INT256_MAX, 'Int256', UINT256_MAX);
+        case Vm_1.VmType.Bytes:
+            return ensureBytes(fieldName, value);
+        case Vm_1.VmType.Bytes16:
+            return ensureBytes16(fieldName, value);
+        case Vm_1.VmType.Bytes32:
+            return ensureBytes32(fieldName, value);
+        case Vm_1.VmType.Bytes64:
+            return ensureBytes64(fieldName, value);
+        case Vm_1.VmType.Struct:
+            return normalizeStructValue(fieldName, structSchema, value);
+        default:
+            throw Error(`Metadata field '${fieldName}' has unsupported type '${Vm_1.VmType[type] ?? type}'`);
+    }
+}
+function normalizeArrayValue(type, fieldName, values, structSchema) {
+    const elementPath = (index) => `${fieldName}[${index}]`;
+    switch (type) {
+        case Vm_1.VmType.String:
+            return values.map((val, idx) => ensureNonEmptyString(elementPath(idx), val));
+        case Vm_1.VmType.Int8:
+            return Uint8Array.from(values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x80, 0x7f, 0xff) & 0xff));
+        case Vm_1.VmType.Int16:
+            return values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x8000, 0x7fff, 0xffff));
+        case Vm_1.VmType.Int32:
+            return values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x80000000, 0x7fffffff, 0xffffffff));
+        case Vm_1.VmType.Int64:
+            return values.map((val, idx) => ensureBigInt(elementPath(idx), val, INT64_MIN, INT64_MAX, 'Int64', UINT64_MAX));
+        case Vm_1.VmType.Int256:
+            return values.map((val, idx) => ensureBigInt(elementPath(idx), val, INT256_MIN, INT256_MAX, 'Int256', UINT256_MAX));
+        case Vm_1.VmType.Bytes:
+            return values.map((val, idx) => ensureBytes(elementPath(idx), val));
+        case Vm_1.VmType.Bytes16:
+            return values.map((val, idx) => ensureBytes16(elementPath(idx), val));
+        case Vm_1.VmType.Bytes32:
+            return values.map((val, idx) => ensureBytes32(elementPath(idx), val));
+        case Vm_1.VmType.Bytes64:
+            return values.map((val, idx) => ensureBytes64(elementPath(idx), val));
+        case Vm_1.VmType.Struct: {
+            if (!structSchema) {
+                throw Error(`Metadata field '${fieldName}' is missing schema for struct elements`);
+            }
+            const sa = new Vm_1.VmStructArray();
+            sa.schema = structSchema;
+            sa.structs = values.map((val, idx) => normalizeStructValue(elementPath(idx), structSchema, val));
+            return sa;
+        }
+        default:
+            throw Error(`Metadata field '${fieldName}' with type '${Vm_1.VmType[type] ?? type}' does not support array values`);
+    }
+}
+function normalizeStructValue(fieldName, structSchema, value) {
+    if (!structSchema) {
+        throw Error(`Metadata field '${fieldName}' is missing struct schema`);
+    }
+    const struct = new Vm_1.VmDynamicStruct();
+    struct.fields = [];
+    const providedFields = metadataStructInputToFields(fieldName, value);
+    structSchema.fields.forEach(childSchema => {
+        let childValue = providedFields.find(f => f.name === childSchema.name.data);
+        if (!childValue) {
+            childValue = providedFields.find(f => f.name.toLowerCase() === childSchema.name.data.toLowerCase());
+            if (childValue) {
+                throw Error(`Metadata field '${childSchema.name.data}' provided in incorrect case inside '${fieldName}': '${childValue.name}'`);
+            }
+            throw Error(`Metadata field '${fieldName}.${childSchema.name.data}' is mandatory`);
+        }
+        const normalized = normalizeMetadataValue(childSchema.schema, `${fieldName}.${childSchema.name.data}`, childValue.value);
+        struct.fields.push(Vm_1.VmNamedDynamicVariable.from(childSchema.name, childSchema.schema.type, normalized));
+    });
+    const allowedNames = new Set(structSchema.fields.map(f => f.name.data.toLowerCase()));
+    for (const provided of providedFields) {
+        if (!allowedNames.has(provided.name.toLowerCase())) {
+            throw Error(`Metadata field '${fieldName}' received unknown property '${provided.name}'`);
+        }
+    }
+    return struct;
+}
+function metadataStructInputToFields(fieldName, value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array || typeof value !== "object") {
+        throw Error(`Metadata field '${fieldName}' must be provided as an object or array of fields`);
+    }
+    return Object.entries(value).map(([name, val]) => ({
+        name,
+        value: val
+    }));
+}
+function ensureNonEmptyString(fieldName, value) {
+    if (typeof value !== "string") {
+        throw Error(`Metadata field '${fieldName}' must be a string`);
+    }
+    if (value.trim().length === 0) {
+        throw Error(`Metadata field '${fieldName}' is mandatory`);
+    }
+    return value;
+}
+function ensureIntegerInRange(fieldName, value, min, max, unsignedMax) {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        const rangeText = unsignedMax !== undefined
+            ? `an integer between ${min} and ${max} or between 0 and ${unsignedMax}`
+            : `an integer between ${min} and ${max}`;
+        throw Error(`Metadata field '${fieldName}' must be ${rangeText}`);
+    }
+    const fitsSigned = value >= min && value <= max;
+    const fitsUnsigned = unsignedMax !== undefined && value >= 0 && value <= unsignedMax;
+    if (!fitsSigned && !fitsUnsigned) {
+        const rangeText = unsignedMax !== undefined
+            ? `between ${min} and ${max} or between 0 and ${unsignedMax}`
+            : `between ${min} and ${max}`;
+        throw Error(`Metadata field '${fieldName}' must be ${rangeText}`);
+    }
+    return value;
+}
+function ensureBigInt(fieldName, value, min, max, label, unsignedMax) {
+    let bigintValue;
+    if (typeof value === "bigint") {
+        bigintValue = value;
+    }
+    else if (typeof value === "number" && Number.isInteger(value)) {
+        if (!Number.isSafeInteger(value)) {
+            throw Error(`Metadata field '${fieldName}' must be provided as a bigint when it exceeds safe integer range`);
+        }
+        bigintValue = BigInt(value);
+    }
+    else {
+        throw Error(`Metadata field '${fieldName}' must be a bigint or a safe integer number`);
+    }
+    const hasSignedRange = min !== undefined && max !== undefined;
+    const fitsSigned = hasSignedRange ? bigintValue >= min && bigintValue <= max : false;
+    const hasUnsignedRange = unsignedMax !== undefined;
+    const fitsUnsigned = hasUnsignedRange ? bigintValue >= 0 && bigintValue <= unsignedMax : false;
+    if (!fitsSigned && !fitsUnsigned) {
+        const signedPart = hasSignedRange ? `between ${min.toString()} and ${max.toString()}` : null;
+        const unsignedPart = hasUnsignedRange ? `between 0 and ${unsignedMax.toString()}` : null;
+        const rangeText = [signedPart, unsignedPart].filter(Boolean).join(' or ');
+        const labelSuffix = label ? ` (${label})` : '';
+        throw Error(`Metadata field '${fieldName}' must be ${rangeText}${labelSuffix}`);
+    }
+    return bigintValue;
+}
+function ensureBytes(fieldName, value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            throw Error(`Metadata field '${fieldName}' must be a byte array or hex string`);
+        }
+        try {
+            return (0, utils_1.hexToBytes)(trimmed);
+        }
+        catch {
+            throw Error(`Metadata field '${fieldName}' must be a byte array or hex string`);
+        }
+    }
+    throw Error(`Metadata field '${fieldName}' must be a byte array or hex string`);
+}
+function ensureFixedBytes(fieldName, value, expectedLength) {
+    const bytes = ensureBytes(fieldName, value);
+    if (bytes.length !== expectedLength) {
+        throw Error(`Metadata field '${fieldName}' must be exactly ${expectedLength} bytes`);
+    }
+    return bytes;
+}
+function ensureBytes16(fieldName, value) {
+    return new Bytes16_1.Bytes16(ensureFixedBytes(fieldName, value, 16));
+}
+function ensureBytes32(fieldName, value) {
+    return new Bytes32_1.Bytes32(ensureFixedBytes(fieldName, value, 32));
+}
+function ensureBytes64(fieldName, value) {
+    return new Bytes64_1.Bytes64(ensureFixedBytes(fieldName, value, 64));
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftRomBuilder = void 0;
+const CarbonSerialization_1 = require("../../../../CarbonSerialization");
+const Vm_1 = require("../../Vm");
+const StandardMeta_1 = require("../StandardMeta");
+const MetadataHelper_1 = require("./MetadataHelper");
+class NftRomBuilder {
+    static buildAndSerialize(nftRomSchema, phantasmaNftId, metadata) {
+        const wRom = new CarbonSerialization_1.CarbonBinaryWriter();
+        const romField = (0, MetadataHelper_1.findMetadataField)(metadata, 'rom');
+        let rom;
+        if (romField) {
+            if (!(romField.value instanceof Uint8Array || typeof romField.value === "string")) {
+                throw Error("'rom' must be a byte array or hex string");
+            }
+            rom = romField.value;
+        }
+        const nftRom = new Vm_1.VmDynamicStruct();
+        nftRom.fields = [
+            Vm_1.VmNamedDynamicVariable.from(StandardMeta_1.StandardMeta.id, Vm_1.VmType.Int256, phantasmaNftId),
+            Vm_1.VmNamedDynamicVariable.from('rom', Vm_1.VmType.Bytes, rom ? rom : [])
+        ];
+        nftRomSchema.fields.forEach(s => {
+            // We don't verify default fields here, they are treated differently
+            // in the code above.
+            if (!MetadataHelper_1.nftDefaultMetadataFields.some(df => df.name === s.name.data)) {
+                (0, MetadataHelper_1.pushMetadataField)(s, nftRom, metadata);
+            }
+        });
+        nftRom.writeWithSchema(nftRomSchema, wRom);
+        // console.log("nftRom.fields.length: ", nftRom.fields.length);
+        // TokenSchemasBuilder.logSchema(nftRomSchema);
+        return wRom.toUint8Array();
+    }
+}
+exports.NftRomBuilder = NftRomBuilder;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriesInfoBuilder = void 0;
+const Vm_1 = require("../../Vm");
+const SeriesInfo_1 = require("../SeriesInfo");
+const TokenSeriesMetadataBuilder_1 = require("./TokenSeriesMetadataBuilder");
+class SeriesInfoBuilder {
+    static build(seriesSchema, phantasmaSeriesId, maxMint, maxSupply, ownerPublicKey, metadata) {
+        const serializedMetadata = TokenSeriesMetadataBuilder_1.TokenSeriesMetadataBuilder.buildAndSerialize(seriesSchema, phantasmaSeriesId, metadata);
+        return new SeriesInfo_1.SeriesInfo({
+            maxMint: maxMint,
+            maxSupply: maxSupply,
+            owner: ownerPublicKey,
+            metadata: serializedMetadata,
+            rom: new Vm_1.VmStructSchema(),
+            ram: new Vm_1.VmStructSchema(),
+        });
+    }
+}
+exports.SeriesInfoBuilder = SeriesInfoBuilder;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenInfoBuilder = void 0;
+const SmallString_1 = require("../../../SmallString");
+const CarbonTokenFlags_1 = require("../../CarbonTokenFlags");
+const TokenInfo_1 = require("../TokenInfo");
+const TokenSchemasBuilder_1 = require("./TokenSchemasBuilder");
+class TokenInfoBuilder {
+    static build(symbol, maxSupply, isNFT, decimals, creatorPublicKey, metadata, tokenSchemas) {
+        const { ok, error } = this.checkIsValidSymbol(symbol);
+        if (!ok) {
+            throw Error(error ?? "Unknown error");
+        }
+        const tokenInfo = new TokenInfo_1.TokenInfo();
+        tokenInfo.maxSupply = maxSupply;
+        tokenInfo.flags = 0; // Small fungible
+        if (isNFT) {
+            if (!maxSupply.is8ByteSafe()) {
+                throw Error("NFT maximum supply must fit into Int64");
+            }
+            tokenInfo.flags = CarbonTokenFlags_1.CarbonTokenFlags.NonFungible;
+        }
+        else {
+            if (!maxSupply.is8ByteSafe()) {
+                tokenInfo.flags = CarbonTokenFlags_1.CarbonTokenFlags.BigFungible;
+            }
+        }
+        tokenInfo.decimals = decimals;
+        tokenInfo.owner = creatorPublicKey;
+        tokenInfo.symbol = new SmallString_1.SmallString(symbol);
+        if (isNFT) {
+            if (!metadata) {
+                throw new Error('metadata is required for NFTs');
+            }
+            tokenInfo.metadata = metadata;
+            if (!tokenSchemas) {
+                throw new Error('tokenSchemas is required for NFTs');
+            }
+            tokenInfo.tokenSchemas = TokenSchemasBuilder_1.TokenSchemasBuilder.serialize(tokenSchemas);
+        }
+        return tokenInfo;
+    }
+    /**
+    * Mirrors carbon::CheckIsValidSymbol from contracts/token.cpp.
+    * Returns true when valid, or false when the symbol must be rejected.
+    */
+    static checkIsValidSymbol(symbol) {
+        if (!symbol || symbol.length === 0) {
+            return { ok: false, error: "Symbol validation error: Empty string is invalid" };
+        }
+        if (symbol.length > this.maxSymbolLength) {
+            return { ok: false, error: "Symbol validation error: Too long" };
+        }
+        for (let i = 0; i < symbol.length; i++) {
+            const code = symbol.charCodeAt(i);
+            const isUppercaseAsciiLetter = code >= 0x41 && code <= 0x5a; // 'A'..'Z'
+            if (!isUppercaseAsciiLetter) {
+                return { ok: false, error: "Symbol validation error: Anything outside A–Z is forbidden (digits, accents, etc.)" };
+            }
+        }
+        return { ok: true, error: null };
+    }
+}
+exports.TokenInfoBuilder = TokenInfoBuilder;
+TokenInfoBuilder.maxSymbolLength = 255;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenMetadataBuilder = void 0;
+const CarbonSerialization_1 = require("../../../../CarbonSerialization");
+const Vm_1 = require("../../Vm");
+class TokenMetadataBuilder {
+    static buildAndSerialize(fields) {
+        const requiredFields = ['name', 'icon', 'url', 'description'];
+        if (!fields || Object.keys(fields).length < requiredFields.length) {
+            throw new Error('Token metadata is mandatory');
+        }
+        if (Object.values(fields).some(v => typeof v !== 'string')) {
+            throw new Error('All metadata fields must be strings');
+        }
+        const missing = requiredFields.filter(field => typeof fields[field] !== 'string' || fields[field].trim() === '');
+        if (missing.length > 0) {
+            throw new Error(`Token metadata is missing required fields: ${missing.join(', ')}`);
+        }
+        this.validateIcon(fields['icon']);
+        const metadataFields = [];
+        for (const [key, value] of Object.entries(fields)) {
+            metadataFields.push(Vm_1.VmNamedDynamicVariable.from(key, Vm_1.VmType.String, value));
+        }
+        const struct = new Vm_1.VmDynamicStruct();
+        struct.fields = metadataFields;
+        const wMetadata = new CarbonSerialization_1.CarbonBinaryWriter();
+        struct.write(wMetadata);
+        return wMetadata.toUint8Array();
+    }
+    static validateIcon(icon) {
+        const candidate = icon?.trim();
+        if (!candidate || candidate.length === 0) {
+            throw new Error('Token metadata icon must be a base64-encoded data URI (PNG, JPEG, or SVG)');
+        }
+        if (!this.iconDataUriPrefixPattern.test(candidate)) {
+            throw new Error('Token metadata icon must be a base64-encoded data URI (PNG, JPEG, or SVG)');
+        }
+        const payload = candidate.slice(candidate.indexOf(',') + 1).trim();
+        if (!payload) {
+            throw new Error('Token metadata icon must include a non-empty base64 payload');
+        }
+        if (!this.base64PayloadPattern.test(payload) || payload.length % 4 !== 0) {
+            throw new Error('Token metadata icon payload is not valid base64');
+        }
+        try {
+            const decoded = Buffer.from(payload, 'base64');
+            if (decoded.length === 0) {
+                throw new Error('Token metadata icon must include a non-empty base64 payload');
+            }
+            const normalizedPayload = decoded.toString('base64').replace(/=+$/, '');
+            const normalizedInput = payload.replace(/=+$/, '');
+            if (normalizedPayload !== normalizedInput) {
+                throw new Error('Token metadata icon payload is not valid base64');
+            }
+        }
+        catch (err) {
+            throw new Error('Token metadata icon payload is not valid base64');
+        }
+    }
+}
+exports.TokenMetadataBuilder = TokenMetadataBuilder;
+TokenMetadataBuilder.iconDataUriPrefixPattern = /^data:image\/(png|jpeg|svg\+xml);base64,/i;
+TokenMetadataBuilder.base64PayloadPattern = /^[A-Za-z0-9+/]+={0,2}$/;

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

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSchemasBuilder = exports.parseTokenSchemasJson = exports.TokenSchemasJson = void 0;
+const utils_1 = require("../../../../../utils");
+const CarbonSerialization_1 = require("../../../../CarbonSerialization");
+const VmNamedVariableSchema_1 = require("../../Vm/VmNamedVariableSchema");
+const VmStructSchema_1 = require("../../Vm/VmStructSchema");
+const VmType_1 = require("../../Vm/VmType");
+const TokenSchemas_1 = require("../TokenSchemas");
+const MetadataHelper_1 = require("./MetadataHelper");
+class TokenSchemasJson {
+}
+exports.TokenSchemasJson = TokenSchemasJson;
+function parseTokenSchemasJson(json) {
+    const raw = JSON.parse(json);
+    const pickArray = (k) => {
+        const arr = raw[k];
+        if (!Array.isArray(arr))
+            throw new Error(`${k} must be an array`);
+        return arr.map((it) => {
+            if (typeof it?.name !== 'string')
+                throw new Error(`${k} field name must be string`);
+            if (typeof it?.type !== 'string')
+                throw new Error(`${k} field type must be string`);
+            return { name: it.name, type: (0, VmType_1.vmTypeFromString)(it.type) };
+        });
+    };
+    return {
+        seriesMetadata: pickArray('seriesMetadata'),
+        rom: pickArray('rom'),
+        ram: pickArray('ram'),
+    };
+}
+exports.parseTokenSchemasJson = parseTokenSchemasJson;
+class TokenSchemasBuilder {
+    static assertMetadataField(schemas, fieldTypes) {
+        fieldTypes.forEach(fieldType => {
+            let fieldIsFound = false;
+            schemas.forEach(schema => {
+                const found = schema.fields.find(x => x.name.data === fieldType.name);
+                if (found != undefined) {
+                    if (found.schema.type != fieldType.type) {
+                        return { ok: false, error: `Type mismatch for ${fieldType.name} field, must be ${found.schema.type} instead of ${fieldType}` };
+                    }
+                    fieldIsFound = true;
+                }
+                else {
+                    const found2 = schema.fields.find(x => x.name.data.toLowerCase() === fieldType.name.toLowerCase());
+                    if (found2 != undefined) {
+                        return { ok: false, error: `Case mismatch for ${fieldType.name} field, must be ${found2.name}` };
+                    }
+                }
+            });
+            if (!fieldIsFound) {
+                return { ok: false, error: `Mandatory metadata field not found: ${fieldType.name}` };
+            }
+        });
+        return { ok: true, error: null };
+    }
+    static defaultSeriesSchema(sharedMetadata) {
+        // Series metadata schema
+        const schema = new VmStructSchema_1.VmStructSchema();
+        schema.fields = [];
+        {
+            // Default fields
+            MetadataHelper_1.seriesDefaultMetadataFields.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+            if (sharedMetadata) {
+                MetadataHelper_1.standardMetadataFields.forEach(f => {
+                    schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+                });
+            }
+        }
+        return schema;
+    }
+    static defaultNftRomSchema(sharedMetadata) {
+        // NFT ROM schema
+        const schema = new VmStructSchema_1.VmStructSchema();
+        schema.fields = [];
+        {
+            // Default fields
+            MetadataHelper_1.nftDefaultMetadataFields.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+            if (!sharedMetadata) {
+                // They are default for all NFTs
+                MetadataHelper_1.standardMetadataFields.forEach(f => {
+                    schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+                });
+            }
+        }
+        return schema;
+    }
+    static seriesSchemaFromFieldTypes(fieldTypes) {
+        // Series metadata schema
+        const schema = new VmStructSchema_1.VmStructSchema();
+        schema.fields = [];
+        {
+            // Default fields. Adding them always
+            MetadataHelper_1.seriesDefaultMetadataFields.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+            fieldTypes.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+        }
+        return schema;
+    }
+    static nftRomSchemaFromFieldTypes(fieldTypes) {
+        // NFT ROM schema
+        const schema = new VmStructSchema_1.VmStructSchema();
+        schema.fields = [];
+        {
+            // Default fields. Adding them always
+            MetadataHelper_1.nftDefaultMetadataFields.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+            fieldTypes.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+        }
+        return schema;
+    }
+    static nftRamSchemaFromFieldTypes(fieldTypes) {
+        if (fieldTypes.length == 0) {
+            return new VmStructSchema_1.VmStructSchema([], VmStructSchema_1.VmStructSchema.Flags.DynamicExtras);
+        }
+        // RAM schema
+        const schema = new VmStructSchema_1.VmStructSchema();
+        schema.fields = [];
+        {
+            fieldTypes.forEach(f => {
+                schema.fields.push(new VmNamedVariableSchema_1.VmNamedVariableSchema(f.name, f.type));
+            });
+        }
+        return schema;
+    }
+    static prepareStandard(sharedMetadata) {
+        const tokenSchemas = new TokenSchemas_1.TokenSchemas();
+        // Token's series metadata schema
+        tokenSchemas.seriesMetadata = this.defaultSeriesSchema(sharedMetadata);
+        // NFT's ROM schema
+        tokenSchemas.rom = this.defaultNftRomSchema(sharedMetadata);
+        // NFT's RAM schema
+        tokenSchemas.ram = new VmStructSchema_1.VmStructSchema([], VmStructSchema_1.VmStructSchema.Flags.DynamicExtras);
+        return tokenSchemas;
+    }
+    static fromJson(json) {
+        const tokenSchemasJson = parseTokenSchemasJson(json);
+        const tokenSchemas = new TokenSchemas_1.TokenSchemas();
+        tokenSchemas.seriesMetadata = this.seriesSchemaFromFieldTypes(tokenSchemasJson.seriesMetadata);
+        tokenSchemas.rom = this.nftRomSchemaFromFieldTypes(tokenSchemasJson.rom);
+        tokenSchemas.ram = this.nftRamSchemaFromFieldTypes(tokenSchemasJson.ram);
+        const { ok, error } = this.verify(tokenSchemas);
+        if (!ok) {
+            throw Error(error ?? "Unknown error");
+        }
+        return tokenSchemas;
+    }
+    static verify(schemas) {
+        let result = this.assertMetadataField([schemas.seriesMetadata, schemas.rom], MetadataHelper_1.standardMetadataFields);
+        if (!result.ok) {
+            return result;
+        }
+        result = this.assertMetadataField([schemas.seriesMetadata], MetadataHelper_1.seriesDefaultMetadataFields);
+        if (!result.ok) {
+            return result;
+        }
+        result = this.assertMetadataField([schemas.rom], MetadataHelper_1.nftDefaultMetadataFields);
+        if (!result.ok) {
+            return result;
+        }
+        return { ok: true, error: null };
+    }
+    static serialize(tokenSchemas) {
+        const schemaBuf = new CarbonSerialization_1.CarbonBinaryWriter();
+        tokenSchemas.write(schemaBuf);
+        return schemaBuf.toUint8Array();
+    }
+    static serializeHex(tokenSchemas) {
+        return (0, utils_1.bytesToHex)(this.serialize(tokenSchemas));
+    }
+    static logSchema(schema) {
+        schema.fields.forEach(f => console.log("Schema field: ", f.name.data));
+    }
+}
+exports.TokenSchemasBuilder = TokenSchemasBuilder;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSeriesMetadataBuilder = void 0;
+const CarbonSerialization_1 = require("../../../../CarbonSerialization");
+const Vm_1 = require("../../Vm");
+const StandardMeta_1 = require("../StandardMeta");
+const MetadataHelper_1 = require("./MetadataHelper");
+class TokenSeriesMetadataBuilder {
+    static buildAndSerialize(seriesMetadataSchema, newPhantasmaSeriesId, metadata) {
+        const wMetadata = new CarbonSerialization_1.CarbonBinaryWriter();
+        const sharedRomField = (0, MetadataHelper_1.findMetadataField)(metadata, 'rom');
+        let rom;
+        if (sharedRomField) {
+            if (!(sharedRomField.value instanceof Uint8Array || typeof sharedRomField.value === "string")) {
+                throw Error("'rom' must be a byte array or hex string");
+            }
+            rom = sharedRomField.value;
+        }
+        let seriesMetadata = new Vm_1.VmDynamicStruct();
+        seriesMetadata.fields = [
+            Vm_1.VmNamedDynamicVariable.from(StandardMeta_1.StandardMeta.id, Vm_1.VmType.Int256, newPhantasmaSeriesId),
+            Vm_1.VmNamedDynamicVariable.from('mode', Vm_1.VmType.Int8, rom == null || rom.length == 0 ? 0 : 1),
+            Vm_1.VmNamedDynamicVariable.from('rom', Vm_1.VmType.Bytes, rom ? rom : [])
+        ];
+        seriesMetadataSchema.fields.forEach(s => {
+            // We don't verify default fields here, they are treated differently
+            // in the code above.
+            if (!MetadataHelper_1.seriesDefaultMetadataFields.some(df => df.name === s.name.data)) {
+                (0, MetadataHelper_1.pushMetadataField)(s, seriesMetadata, metadata);
+            }
+        });
+        seriesMetadata.writeWithSchema(seriesMetadataSchema, wMetadata);
+        return wMetadata.toUint8Array();
+    }
+}
+exports.TokenSeriesMetadataBuilder = TokenSeriesMetadataBuilder;