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

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/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/esm/core/index.js

@@ -0,0 +1,9 @@
+export * from './rpc/phantasma';
+export * from './rpc';
+export * from './vm';
+export * from './tx';
+export * from './utils';
+export * from './types';
+export * from './interfaces';
+export * from './ledger';
+export * from './link';

package/dist/esm/core/interfaces/Carbon/ICarbonBlob.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/Carbon/index.js

@@ -0,0 +1 @@
+export * from "./ICarbonBlob";

package/dist/esm/core/interfaces/IContract.js

@@ -0,0 +1,22 @@
+export var NativeContractKind;
+(function (NativeContractKind) {
+    NativeContractKind[NativeContractKind["Gas"] = 0] = "Gas";
+    NativeContractKind[NativeContractKind["Block"] = 1] = "Block";
+    NativeContractKind[NativeContractKind["Stake"] = 2] = "Stake";
+    NativeContractKind[NativeContractKind["Swap"] = 3] = "Swap";
+    NativeContractKind[NativeContractKind["Account"] = 4] = "Account";
+    NativeContractKind[NativeContractKind["Consensus"] = 5] = "Consensus";
+    NativeContractKind[NativeContractKind["Governance"] = 6] = "Governance";
+    NativeContractKind[NativeContractKind["Storage"] = 7] = "Storage";
+    NativeContractKind[NativeContractKind["Validator"] = 8] = "Validator";
+    NativeContractKind[NativeContractKind["Interop"] = 9] = "Interop";
+    NativeContractKind[NativeContractKind["Exchange"] = 10] = "Exchange";
+    NativeContractKind[NativeContractKind["Privacy"] = 11] = "Privacy";
+    NativeContractKind[NativeContractKind["Relay"] = 12] = "Relay";
+    NativeContractKind[NativeContractKind["Ranking"] = 13] = "Ranking";
+    NativeContractKind[NativeContractKind["Market"] = 14] = "Market";
+    NativeContractKind[NativeContractKind["Friends"] = 15] = "Friends";
+    NativeContractKind[NativeContractKind["Mail"] = 16] = "Mail";
+    NativeContractKind[NativeContractKind["Sale"] = 17] = "Sale";
+    NativeContractKind[NativeContractKind["Unknown"] = 18] = "Unknown";
+})(NativeContractKind || (NativeContractKind = {}));

package/dist/esm/core/interfaces/IKeyPair.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/ISerializable.js

@@ -0,0 +1,2 @@
+export class ISerializable {
+}

package/dist/esm/core/interfaces/IStack.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/interfaces/IToken.js

@@ -0,0 +1,19 @@
+export var TokenFlags;
+(function (TokenFlags) {
+    TokenFlags[TokenFlags["None"] = 0] = "None";
+    TokenFlags[TokenFlags["Transferable"] = 1] = "Transferable";
+    TokenFlags[TokenFlags["Fungible"] = 2] = "Fungible";
+    TokenFlags[TokenFlags["Finite"] = 4] = "Finite";
+    TokenFlags[TokenFlags["Divisible"] = 8] = "Divisible";
+    TokenFlags[TokenFlags["Fuel"] = 16] = "Fuel";
+    TokenFlags[TokenFlags["Stakable"] = 32] = "Stakable";
+    TokenFlags[TokenFlags["Fiat"] = 64] = "Fiat";
+    TokenFlags[TokenFlags["Swappable"] = 128] = "Swappable";
+    TokenFlags[TokenFlags["Burnable"] = 256] = "Burnable";
+    TokenFlags[TokenFlags["Mintable"] = 512] = "Mintable";
+})(TokenFlags || (TokenFlags = {}));
+export var TokenSeriesMode;
+(function (TokenSeriesMode) {
+    TokenSeriesMode[TokenSeriesMode["Unique"] = 0] = "Unique";
+    TokenSeriesMode[TokenSeriesMode["Duplicated"] = 1] = "Duplicated";
+})(TokenSeriesMode || (TokenSeriesMode = {}));

package/dist/esm/core/interfaces/Signature.js

@@ -0,0 +1,20 @@
+import { PBinaryWriter } from "../types";
+export var SignatureKind;
+(function (SignatureKind) {
+    SignatureKind[SignatureKind["None"] = 0] = "None";
+    SignatureKind[SignatureKind["Ed25519"] = 1] = "Ed25519";
+    SignatureKind[SignatureKind["ECDSA"] = 2] = "ECDSA";
+})(SignatureKind || (SignatureKind = {}));
+export class ISignature {
+}
+export class Signature {
+    Verify(message, address) {
+        return this.VerifyMultiple(message, [address]);
+    }
+    ToByteArray() {
+        const stream = new Uint8Array(64);
+        const writer = new PBinaryWriter(stream);
+        this.SerializeData(writer);
+        return new Uint8Array(stream);
+    }
+}

package/dist/esm/core/interfaces/index.js

@@ -0,0 +1,7 @@
+export * from "./Carbon";
+export * from "./IStack";
+export * from "./IToken";
+export * from "./IContract";
+export * from "./IKeyPair";
+export * from "./ISerializable";
+export * from "./Signature";

package/dist/esm/core/ledger/Address-Transcode.js

@@ -0,0 +1,41 @@
+import * as bs58 from 'bs58';
+import { Address, Base16, PhantasmaKeys } from '../types';
+/**
+ * Gets the address from a private key.
+ * @param privateKey The private key as a string.
+ * @returns The address as a string.
+ */
+export const GetAddressFromPrivateKey = (privateKey) => {
+    const keys = PhantasmaKeys.fromWIF(privateKey);
+    const publicKey = keys.Address.Text;
+    return publicKey;
+};
+/**
+ * Gets the address from a public key.
+ * @param publicKey The public key as a string.
+ * @returns The address as a string.
+ */
+export const GetAddressFromPublicKey = (publicKey) => {
+    // Assuming Base16.decodeUint8Array is a function that decodes a base16 string to Uint8Array
+    let pubKeyBytes = Base16.decodeUint8Array(publicKey);
+    // Create a new array and set the first two elements
+    let addrArray = new Uint8Array(34);
+    addrArray[0] = 1;
+    // Copy 32 bytes from the 2nd position of pubKeyBytes to addrArray, starting from the 3rd position of addrArray
+    addrArray.set(pubKeyBytes.slice(0, 32), 2);
+    return 'P' + bs58.encode(addrArray);
+};
+/**
+ * Gets the address from a public key.
+ * @param publicKey Public key as a string.
+ * @returns Address
+ */
+export const GetAddressPublicKeyFromPublicKey = (publicKey) => {
+    let pubKeyBytes = Base16.decodeUint8Array(publicKey);
+    // Create a new array and set the first two elements
+    let addrArray = new Uint8Array(34);
+    addrArray[0] = 1;
+    // Copy 32 bytes from the 2nd position of pubKeyBytes to addrArray, starting from the 3rd position of addrArray
+    addrArray.set(pubKeyBytes.slice(0, 32), 2);
+    return Address.FromPublickKey(addrArray);
+};