phantasma-sdk-ts 0.2.0-rc.16 → 0.2.0-rc.17

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

@@ -1,8 +1,18 @@
 "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;
@@ -38,16 +48,211 @@ function pushMetadataField(fieldSchema, metadata, metadataFields) {
         }
         throw Error(`Metadata field '${fieldSchema.name.data}' is mandatory`);
     }
-    if (fieldSchema.schema.type === Vm_1.VmType.String && typeof found.value === "string") {
-        if (found.value && found.value.trim().length != 0) {
-            metadata.fields.push(Vm_1.VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, found.value));
+    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;
         }
-        else {
-            throw Error(`Metadata field '${fieldSchema.name.data}' is mandatory`);
+        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 {
-        metadata.fields.push(Vm_1.VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, found.value));
+        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));
 }
-exports.pushMetadataField = pushMetadataField;

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

@@ -1,5 +1,15 @@
-import { VmNamedDynamicVariable, VmType } from "../../Vm";
+import { hexToBytes } from "../../../../../utils";
+import { Bytes16 } from "../../../Bytes16";
+import { Bytes32 } from "../../../Bytes32";
+import { Bytes64 } from "../../../Bytes64";
+import { VmDynamicStruct, VmNamedDynamicVariable, VmStructArray, VmType, } from "../../Vm";
 import { StandardMeta } from "../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;
 export class MetadataField {
 }
 export class FieldType {
@@ -32,15 +42,210 @@ export function pushMetadataField(fieldSchema, metadata, metadataFields) {
         }
         throw Error(`Metadata field '${fieldSchema.name.data}' is mandatory`);
     }
-    if (fieldSchema.schema.type === VmType.String && typeof found.value === "string") {
-        if (found.value && found.value.trim().length != 0) {
-            metadata.fields.push(VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, found.value));
+    const normalizedValue = normalizeMetadataValue(fieldSchema.schema, fieldSchema.name.data, found.value);
+    metadata.fields.push(VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, normalizedValue));
+}
+function normalizeMetadataValue(schema, fieldName, value) {
+    if (value === null || value === undefined) {
+        throw Error(`Metadata field '${fieldName}' is mandatory`);
+    }
+    const isArray = (schema.type & VmType.Array) === VmType.Array;
+    const baseType = (isArray ? (schema.type & ~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 VmType.String:
+            return ensureNonEmptyString(fieldName, value);
+        case VmType.Int8:
+            return ensureIntegerInRange(fieldName, value, -0x80, 0x7f, 0xff);
+        case VmType.Int16:
+            return ensureIntegerInRange(fieldName, value, -0x8000, 0x7fff, 0xffff);
+        case VmType.Int32:
+            return ensureIntegerInRange(fieldName, value, -0x80000000, 0x7fffffff, 0xffffffff);
+        case VmType.Int64:
+            return ensureBigInt(fieldName, value, INT64_MIN, INT64_MAX, 'Int64', UINT64_MAX);
+        case VmType.Int256:
+            return ensureBigInt(fieldName, value, INT256_MIN, INT256_MAX, 'Int256', UINT256_MAX);
+        case VmType.Bytes:
+            return ensureBytes(fieldName, value);
+        case VmType.Bytes16:
+            return ensureBytes16(fieldName, value);
+        case VmType.Bytes32:
+            return ensureBytes32(fieldName, value);
+        case VmType.Bytes64:
+            return ensureBytes64(fieldName, value);
+        case VmType.Struct:
+            return normalizeStructValue(fieldName, structSchema, value);
+        default:
+            throw Error(`Metadata field '${fieldName}' has unsupported type '${VmType[type] ?? type}'`);
+    }
+}
+function normalizeArrayValue(type, fieldName, values, structSchema) {
+    const elementPath = (index) => `${fieldName}[${index}]`;
+    switch (type) {
+        case VmType.String:
+            return values.map((val, idx) => ensureNonEmptyString(elementPath(idx), val));
+        case VmType.Int8:
+            return Uint8Array.from(values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x80, 0x7f, 0xff) & 0xff));
+        case VmType.Int16:
+            return values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x8000, 0x7fff, 0xffff));
+        case VmType.Int32:
+            return values.map((val, idx) => ensureIntegerInRange(elementPath(idx), val, -0x80000000, 0x7fffffff, 0xffffffff));
+        case VmType.Int64:
+            return values.map((val, idx) => ensureBigInt(elementPath(idx), val, INT64_MIN, INT64_MAX, 'Int64', UINT64_MAX));
+        case VmType.Int256:
+            return values.map((val, idx) => ensureBigInt(elementPath(idx), val, INT256_MIN, INT256_MAX, 'Int256', UINT256_MAX));
+        case VmType.Bytes:
+            return values.map((val, idx) => ensureBytes(elementPath(idx), val));
+        case VmType.Bytes16:
+            return values.map((val, idx) => ensureBytes16(elementPath(idx), val));
+        case VmType.Bytes32:
+            return values.map((val, idx) => ensureBytes32(elementPath(idx), val));
+        case VmType.Bytes64:
+            return values.map((val, idx) => ensureBytes64(elementPath(idx), val));
+        case VmType.Struct: {
+            if (!structSchema) {
+                throw Error(`Metadata field '${fieldName}' is missing schema for struct elements`);
+            }
+            const sa = new 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 '${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 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(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}'`);
         }
-        else {
-            throw Error(`Metadata field '${fieldSchema.name.data}' is mandatory`);
+    }
+    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 {
-        metadata.fields.push(VmNamedDynamicVariable.from(fieldSchema.name, fieldSchema.schema.type, found.value));
+        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 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(ensureFixedBytes(fieldName, value, 16));
+}
+function ensureBytes32(fieldName, value) {
+    return new Bytes32(ensureFixedBytes(fieldName, value, 32));
+}
+function ensureBytes64(fieldName, value) {
+    return new Bytes64(ensureFixedBytes(fieldName, value, 64));
 }

package/dist/types/core/types/Carbon/Blockchain/Modules/Builders/MetadataHelper.d.ts

@@ -1,7 +1,7 @@
 import { VmDynamicStruct, VmNamedVariableSchema, VmType } from "../../Vm";
 export declare class MetadataField {
     name: string;
-    value: string | number | Uint8Array | bigint;
+    value: MetadataValueInput;
 }
 export declare class FieldType {
     name: string;
@@ -12,4 +12,13 @@ export declare const nftDefaultMetadataFields: readonly FieldType[];
 export declare const standardMetadataFields: readonly FieldType[];
 export declare function findMetadataField(fields: MetadataField[], name: string): MetadataField;
 export declare function pushMetadataField(fieldSchema: VmNamedVariableSchema, metadata: VmDynamicStruct, metadataFields: MetadataField[]): void;
+type MetadataPlainValue = string | number | bigint | Uint8Array;
+interface MetadataStructRecord {
+    [key: string]: MetadataValueInput;
+}
+interface MetadataValueArray extends Array<MetadataValueInput> {
+}
+type MetadataStructInput = MetadataField[] | MetadataStructRecord;
+export type MetadataValueInput = MetadataPlainValue | MetadataStructInput | MetadataValueArray;
+export {};
 //# sourceMappingURL=MetadataHelper.d.ts.map

package/dist/types/core/types/Carbon/Blockchain/Modules/Builders/MetadataHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetadataHelper.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/types/Carbon/Blockchain/Modules/Builders/MetadataHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAA0B,qBAAqB,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlG,qBAAa,aAAa;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;CAC9C;AAED,qBAAa,SAAS;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,2BAA2B,EAAE,SAAS,SAAS,EAIlD,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,SAAS,SAAS,EAG/C,CAAC;AAEX,eAAO,MAAM,sBAAsB,EAAE,SAAS,SAAS,EAM7C,CAAC;AAEX,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAEtF;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,qBAAqB,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,GAAG,IAAI,CAmBtI"}
+{"version":3,"file":"MetadataHelper.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/types/Carbon/Blockchain/Modules/Builders/MetadataHelper.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EAEf,qBAAqB,EAGrB,MAAM,EAEP,MAAM,UAAU,CAAC;AAUlB,qBAAa,aAAa;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAED,qBAAa,SAAS;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,2BAA2B,EAAE,SAAS,SAAS,EAIlD,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,SAAS,SAAS,EAG/C,CAAC;AAEX,eAAO,MAAM,sBAAsB,EAAE,SAAS,SAAS,EAM7C,CAAC;AAEX,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAEtF;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,qBAAqB,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,GAAG,IAAI,CAiBtI;AAED,KAAK,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAChE,UAAU,oBAAoB;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAC;CACnC;AACD,UAAU,kBAAmB,SAAQ,KAAK,CAAC,kBAAkB,CAAC;CAAG;AACjE,KAAK,mBAAmB,GAAG,aAAa,EAAE,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,kBAAkB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phantasma-sdk-ts",
-  "version": "0.2.0-rc.16",
+  "version": "0.2.0-rc.17",
   "description": "Javascript SDK for interacting with the Phantasma Chain",
   "author": "Phantasma Team",
   "main": "dist/cjs/index.js",