@xelis/sdk 0.11.32 → 0.11.34

package/dist/esm/contract/typed_contract.js

@@ -1,35 +1,4 @@
-import { createVMParameter, createContractInvocation } from './xvm_serializer.js';
-// Convert ABI type to validator type
-function normalizeType(abiType) {
-    const typeMap = {
-        'Hash': 'Hash',
-        'Address': 'Address',
-        'PublicKey': 'PublicKey',
-        'Blob': 'Blob',
-        'u256': 'u256',
-        'u128': 'u128',
-        'u64': 'u64',
-        'u32': 'u32',
-        'u16': 'u16',
-        'u8': 'u8',
-        'boolean': 'boolean',
-        'bool': 'boolean',
-        'string': 'string',
-        'String': 'string',
-        'Boolean': 'boolean',
-        'U256': 'u256',
-        'U128': 'u128',
-        'U64': 'u64',
-        'U32': 'u32',
-        'U16': 'u16',
-        'U8': 'u8'
-    };
-    const normalized = typeMap[abiType];
-    if (!normalized) {
-        throw new Error(`Unknown ABI type: ${abiType}`);
-    }
-    return normalized;
-}
+import { createContractInvocation, typeRegistry, defineEnum, defineStruct, createVMParameter } from './xvm_serializer.js';
 /**
  * Strongly typed contract class
  */
@@ -38,21 +7,17 @@ export class TypedContract {
         this.address = address;
         this.abi = abi;
         this.methods = new Map();
-        // Initialize methods
+        this.register_internal_types();
         for (const entry of abi.data) {
             if (entry.type === 'entry') {
-                console.log("new method", entry.name);
                 this.methods.set(entry.name, entry);
             }
         }
-        // Return a Proxy to handle dynamic method calls
         return new Proxy(this, {
             get(target, prop, receiver) {
-                // If it's a known property/method, return it
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // If it's a string property that matches a method name, create dynamic method
                 if (typeof prop === 'string' && target.methods.has(prop)) {
                     return (params) => target.invokeUnsafe(prop, params);
                 }
@@ -60,81 +25,159 @@ export class TypedContract {
             }
         });
     }
+    /**
+     * Register all custom types from ABI
+     */
+    register_internal_types() {
+        if (!this.abi.internal_types)
+            return;
+        for (const type_def of this.abi.internal_types) {
+            if (type_def.kind === 'enum' && type_def.variants) {
+                typeRegistry.register(defineEnum(type_def.name, type_def.variants));
+            }
+            else if (type_def.kind === 'struct' && type_def.fields) {
+                typeRegistry.register(defineStruct(type_def.name, type_def.fields));
+            }
+        }
+    }
+    /**
+     * Helper to create struct values with positional arguments
+     * Validates field types immediately
+     * @param type_name - Name of the struct type
+     * @param field_values - Field values in the order defined in ABI
+     */
+    struct(type_name, ...field_values) {
+        const type_def = this.abi.internal_types?.find(t => t.name === type_name && t.kind === 'struct');
+        if (!type_def || !type_def.fields) {
+            throw new Error(`Struct type '${type_name}' not found in contract ABI`);
+        }
+        if (field_values.length !== type_def.fields.length) {
+            throw new Error(`Struct '${type_name}' expects ${type_def.fields.length} fields ` +
+                `(${type_def.fields.map(f => f.name).join(', ')}), ` +
+                `but got ${field_values.length}`);
+        }
+        const result = {};
+        for (let i = 0; i < type_def.fields.length; i++) {
+            const field = type_def.fields[i];
+            const value = field_values[i];
+            try {
+                createVMParameter(value, field.type);
+            }
+            catch (error) {
+                throw new Error(`Invalid value for field '${field.name}' (position ${i}) of struct '${type_name}': ${error}`);
+            }
+            result[field.name] = value;
+        }
+        return result;
+    }
+    /**
+     * Helper to create enum values with positional arguments
+     * Validates field types immediately
+     * @param type_name - Name of the enum type
+     * @param variant_name - Name of the variant
+     * @param field_values - Field values in the order defined in ABI
+     */
+    enum(type_name, variant_name, ...field_values) {
+        const type_def = this.abi.internal_types?.find(t => t.name === type_name && t.kind === 'enum');
+        if (!type_def || !type_def.variants) {
+            throw new Error(`Enum type '${type_name}' not found in contract ABI`);
+        }
+        const variant = type_def.variants.find(v => v.name === variant_name);
+        if (!variant) {
+            const available = type_def.variants.map(v => v.name).join(', ');
+            throw new Error(`Unknown variant '${variant_name}' for enum '${type_name}'. ` +
+                `Available variants: ${available}`);
+        }
+        if (field_values.length !== variant.fields.length) {
+            throw new Error(`Variant '${variant_name}' of enum '${type_name}' expects ${variant.fields.length} fields ` +
+                `(${variant.fields.map(f => f.name).join(', ')}), ` +
+                `but got ${field_values.length}`);
+        }
+        const result = { type: variant_name };
+        for (let i = 0; i < variant.fields.length; i++) {
+            const field = variant.fields[i];
+            const value = field_values[i];
+            try {
+                createVMParameter(value, field.type);
+            }
+            catch (error) {
+                throw new Error(`Invalid value for field '${field.name}' (position ${i}) of variant '${variant_name}' in enum '${type_name}': ${error}`);
+            }
+            result[field.name] = value;
+        }
+        return result;
+    }
     /**
      * Internal method to invoke contract functions
      */
-    invokeUnsafe(methodName, params = {}) {
-        const entry = this.methods.get(methodName);
+    invokeUnsafe(method_name, params = {}) {
+        const entry = this.methods.get(method_name);
         if (!entry) {
-            throw new Error(`Method '${methodName}' not found in contract ABI`);
+            throw new Error(`Method '${method_name}' not found in contract ABI`);
         }
-        // Extract special parameters
-        const { maxGas, deposits, ...methodParams } = params;
-        // Build parameter list according to ABI
+        const { maxGas, deposits, permission, ...method_params } = params;
         const parameters = [];
-        for (const abiParam of entry.params) {
-            const value = methodParams[abiParam.name];
-            // Check if parameter is required
-            if (value === undefined && !abiParam.optional) {
-                if (abiParam.default !== undefined) {
-                    methodParams[abiParam.name] = abiParam.default;
+        for (const abi_param of entry.params) {
+            const value = method_params[abi_param.name];
+            if (value === undefined && !abi_param.optional) {
+                if (abi_param.default !== undefined) {
+                    method_params[abi_param.name] = abi_param.default;
                 }
                 else {
-                    throw new Error(`Missing required parameter '${abiParam.name}' for method '${methodName}'`);
+                    throw new Error(`Missing required parameter '${abi_param.name}' for method '${method_name}'`);
                 }
             }
             if (value !== undefined) {
                 try {
-                    const normalizedType = normalizeType(abiParam.type);
-                    const vmParam = createVMParameter(value, normalizedType);
-                    parameters.push(vmParam);
+                    const VMParam = createVMParameter(value, abi_param.type);
+                    parameters.push(VMParam);
                 }
                 catch (error) {
-                    throw new Error(`Invalid parameter '${abiParam.name}' for method '${methodName}': ${error}`);
+                    throw new Error(`Invalid parameter '${abi_param.name}' for method '${method_name}': ${error}`);
                 }
             }
         }
-        // Create the contract invocation
-        const invocationParams = {
+        const invocation_params = {
             contract: this.address,
-            chunkId: entry.chunk_id,
+            chunk_id: entry.chunk_id,
             parameters,
-            maxGas: maxGas || 200000000
+            permission,
+            maxGas: maxGas || 50000000
         };
         if (deposits && Object.keys(deposits).length > 0) {
-            invocationParams.deposits = deposits;
+            invocation_params.deposits = deposits;
         }
-        return createContractInvocation(invocationParams);
+        return createContractInvocation(invocation_params);
     }
     /**
      * Type-safe invoke method
      */
-    invoke(methodName, params) {
-        return this.invokeUnsafe(methodName, params);
+    invoke(method_name, params) {
+        return this.invokeUnsafe(method_name, params);
     }
     /**
      * Get list of available methods
      */
-    getMethods() {
+    get_methods() {
         return Array.from(this.methods.keys());
     }
     /**
      * Get method signature information
      */
-    getMethodSignature(methodName) {
-        return this.methods.get(methodName);
+    get_method_signature(method_name) {
+        return this.methods.get(method_name);
     }
     /**
      * Generate TypeScript interface for the contract
      */
-    generateInterface() {
+    generate_interface() {
         const lines = [
             `interface ${this.constructor.name}Methods {`
         ];
         for (const [name, entry] of this.methods) {
             const params = entry.params.map(p => {
                 const optional = p.optional ? '?' : '';
-                return `    ${p.name}${optional}: ${this.getTypeScriptType(p.type)};`;
+                return `    ${p.name}${optional}: ${this.get_typescript_type(p.type)};`;
             }).join('\n');
             lines.push(`  ${name}(params: {`);
             lines.push(params);
@@ -146,8 +189,8 @@ export class TypedContract {
         lines.push('}');
         return lines.join('\n');
     }
-    getTypeScriptType(abiType) {
-        const typeMap = {
+    get_typescript_type(abi_type) {
+        const type_map = {
             'Hash': 'string',
             'Address': 'string',
             'PublicKey': 'string',
@@ -170,51 +213,54 @@ export class TypedContract {
             'U8': 'number',
             'u8': 'number'
         };
-        return typeMap[abiType] || 'any';
+        return type_map[abi_type] || 'any';
     }
 }
 /**
  * Create a typed contract instance with full TypeScript support
  */
-export function createTypedContract(address, abi) {
+export function create_typed_contract(address, abi) {
     return new TypedContract(address, abi);
 }
 /**
  * Contract factory with strong typing
  */
 export class TypedContractFactory {
-    constructor(abi, contractName = 'Contract') {
+    constructor(abi, contract_name = 'Contract') {
         this.abi = abi;
-        this.contractName = contractName;
+        this.contract_name = contract_name;
     }
     /**
      * Create a new contract instance at the specified address
      */
     at(address) {
-        return createTypedContract(address, this.abi);
+        return create_typed_contract(address, this.abi);
     }
     /**
      * Get the ABI
      */
-    getABI() {
+    get_abi() {
         return this.abi;
     }
     /**
      * Generate TypeScript definitions for this contract
      */
-    generateTypeDefinitions() {
+    generate_type_definitions() {
         const contract = new TypedContract('0x0', this.abi);
-        return contract.generateInterface();
+        return contract.generate_interface();
     }
 }
 /**
  * Utility to validate ABI structure
  */
-export function validateABI(abi) {
-    if (!Array.isArray(abi)) {
+export function validate_abi(abi) {
+    if (!abi || typeof abi !== 'object') {
+        return false;
+    }
+    if (!Array.isArray(abi.data)) {
         return false;
     }
-    for (const entry of abi) {
+    for (const entry of abi.data) {
         if (typeof entry !== 'object' || !entry) {
             return false;
         }
@@ -227,7 +273,7 @@ export function validateABI(abi) {
         if (!Array.isArray(entry.params)) {
             return false;
         }
-        if (entry.type !== 'entry' && entry.type !== 'view') {
+        if (entry.type !== 'entry') {
             return false;
         }
         for (const param of entry.params) {
@@ -241,11 +287,11 @@ export function validateABI(abi) {
 /**
  * Helper to create a contract from JSON ABI
  */
-export async function createContractFromJSON(address, abiPath) {
-    const response = await fetch(abiPath);
+export async function create_contract_from_json(address, abi_path) {
+    const response = await fetch(abi_path);
     const abi = await response.json();
-    if (!validateABI(abi.data)) {
+    if (!validate_abi(abi)) {
         throw new Error('Invalid ABI structure');
     }
-    return createTypedContract(address, abi);
+    return create_typed_contract(address, abi);
 }

package/dist/esm/contract/xvm_serializer.js

@@ -1,5 +1,5 @@
 // Known opaque types that need special wrapping
-const OPAQUE_TYPES = new Set(['Hash', 'Address', 'PublicKey', 'Blob' /** TODO */]);
+const OPAQUE_TYPES = new Set(['Hash', 'Address', 'PublicKey', 'Blob']);
 // Type validation and conversion helpers
 const TYPE_VALIDATORS = {
     'u256': (v) => {
@@ -73,12 +73,12 @@ const TYPE_VALIDATORS = {
  * @param type - The type string (e.g., 'u64', 'Hash', 'string')
  * @param validate - Whether to validate and convert the value (default: true)
  */
-export function createVMParameter(value, type, validate = true) {
-    let processedValue = value;
+export function createVMPrimitive(value, type, validate = true) {
+    let processed_value = value;
     // Validate and convert value if requested
     if (validate && TYPE_VALIDATORS[type]) {
         try {
-            processedValue = TYPE_VALIDATORS[type](value);
+            processed_value = TYPE_VALIDATORS[type](value);
         }
         catch (error) {
             throw new Error(`Failed to create VM parameter for type ${type}: ${error}`);
@@ -87,62 +87,279 @@ export function createVMParameter(value, type, validate = true) {
     // Handle opaque types (Hash, Address, PublicKey)
     if (OPAQUE_TYPES.has(type)) {
         return {
-            type: "default",
+            type: "primitive",
             value: {
                 type: "opaque",
                 value: {
                     type: type,
-                    value: processedValue
+                    value: processed_value
                 }
             }
         };
     }
     // Handle regular types
     return {
-        type: "default",
+        type: "primitive",
         value: {
             type: type,
-            value: processedValue
+            value: processed_value
         }
     };
 }
+/**
+ * Serialize an array of values
+ */
+export function serialize_array(items, item_type) {
+    const serialized_items = items.map(item => createVMParameter(item, item_type));
+    return {
+        type: "array",
+        value: serialized_items
+    };
+}
+/**
+ * Serialize a map
+ */
+export function serialize_map(map, keyType, valueType) {
+    const entries = [];
+    for (const [key, value] of Object.entries(map)) {
+        const serialized_key = createVMParameter(key, keyType);
+        const serialized_value = createVMParameter(value, valueType);
+        entries.push([serialized_key, serialized_value]);
+    }
+    return {
+        type: "map",
+        value: entries
+    };
+}
+/**
+ * Serialize an optional value
+ */
+export function serialize_optional(value, inner_type) {
+    if (value === null || value === undefined) {
+        return {
+            type: "option",
+            value: null
+        };
+    }
+    return {
+        type: "option",
+        value: createVMParameter(value, inner_type)
+    };
+}
 /**
  * Convenience functions for common types
  */
-export const vmParam = {
-    hash: (value) => createVMParameter(value, 'Hash'),
-    address: (value) => createVMParameter(value, 'Address'),
-    publicKey: (value) => createVMParameter(value, 'PublicKey'),
-    blob: (value) => createVMParameter(value, 'Blob'),
-    u64: (value) => createVMParameter(value, 'u64'),
-    u32: (value) => createVMParameter(value, 'u32'),
-    u16: (value) => createVMParameter(value, 'u16'),
-    u8: (value) => createVMParameter(value, 'u8'),
-    string: (value) => createVMParameter(value, 'string'),
-    boolean: (value) => createVMParameter(value, 'boolean'),
+export const VMParam = {
+    hash: (value) => createVMPrimitive(value, 'Hash'),
+    address: (value) => createVMPrimitive(value, 'Address'),
+    public_key: (value) => createVMPrimitive(value, 'PublicKey'),
+    blob: (value) => createVMPrimitive(value, 'Blob'),
+    u64: (value) => createVMPrimitive(value, 'u64'),
+    u32: (value) => createVMPrimitive(value, 'u32'),
+    u16: (value) => createVMPrimitive(value, 'u16'),
+    u8: (value) => createVMPrimitive(value, 'u8'),
+    string: (value) => createVMPrimitive(value, 'string'),
+    boolean: (value) => createVMPrimitive(value, 'boolean'),
 };
+/**
+ * Define an enum type from ABI schema
+ */
+export function defineEnum(name, variants) {
+    const variantNames = variants.map(v => v.name);
+    return {
+        name,
+        // NEW: mark kind & expose a matcher
+        // (safe to add; SerializableType is duck-typed)
+        // @ts-ignore - widen at runtime
+        kind: 'enum',
+        // @ts-ignore
+        hasVariant: (vn) => variantNames.includes(vn),
+        to_VMParameter(value) {
+            const variant_index = variants.findIndex(v => v.name === value.type);
+            if (variant_index === -1) {
+                throw new Error(`Unknown variant '${value.type}' for enum '${name}'`);
+            }
+            const variant = variants[variant_index];
+            const expected_fields = new Set(variant.fields.map(f => f.name));
+            expected_fields.add('type');
+            for (const key of Object.keys(value)) {
+                if (!expected_fields.has(key)) {
+                    throw new Error(`Unknown field '${key}' for variant '${value.type}' of enum '${name}'. ` +
+                        `Expected fields: ${Array.from(expected_fields).filter(f => f !== 'type').join(', ')}`);
+                }
+            }
+            const params = [
+                VMParam.u8(variant_index)
+            ];
+            for (const field_schema of variant.fields) {
+                const field_value = value[field_schema.name];
+                if (field_value === undefined) {
+                    throw new Error(`Missing field '${field_schema.name}' for variant '${value.type}' of enum '${name}'`);
+                }
+                params.push(createVMParameter(field_value, field_schema.type));
+            }
+            return { type: "object", value: params };
+        }
+    };
+}
+/**
+ * Define a struct type from ABI schema
+ */
+export function defineStruct(name, fields) {
+    return {
+        name,
+        // NEW: mark kind for structs
+        // @ts-ignore
+        kind: 'struct',
+        to_VMParameter(value) {
+            const expected_fields = new Set(fields.map(f => f.name));
+            for (const key of Object.keys(value)) {
+                if (!expected_fields.has(key)) {
+                    throw new Error(`Unknown field '${key}' for struct '${name}'. ` +
+                        `Expected fields: ${Array.from(expected_fields).join(', ')}`);
+                }
+            }
+            const params = [];
+            for (const field_schema of fields) {
+                const field_value = value[field_schema.name];
+                if (field_value === undefined) {
+                    throw new Error(`Missing field '${field_schema.name}' for struct '${name}'`);
+                }
+                params.push(createVMParameter(field_value, field_schema.type));
+            }
+            return { type: "object", value: params };
+        }
+    };
+}
+/**
+ * Type registry - simple Map for custom types
+ */
+class TypeRegistry {
+    constructor() {
+        this.types = new Map();
+    }
+    register(definition) {
+        this.types.set(definition.name, definition);
+        return definition;
+    }
+    get(name) {
+        return this.types.get(name);
+    }
+    has(name) {
+        return this.types.has(name);
+    }
+    clear() {
+        this.types.clear();
+    }
+    all() {
+        return this.types.values();
+    }
+}
+export const typeRegistry = new TypeRegistry();
+/**
+ * Enhanced parameter creation that handles both primitive and custom types
+ * @param value - The value to serialize
+ * @param type - The type string (primitive or custom type name)
+ * @param validate - Whether to validate primitive values (default: true)
+ */
+export function createVMParameter(value, type, validate = true) {
+    // Pass-through already-serialized parameters
+    if (value && typeof value === 'object' && 'type' in value && 'value' in value) {
+        return value;
+    }
+    // Arrays
+    if (type.endsWith('[]')) {
+        const inner_type = type.slice(0, -2);
+        if (!Array.isArray(value)) {
+            throw new Error(`Expected array for type ${type}, got ${typeof value}`);
+        }
+        return serialize_array(value, inner_type);
+    }
+    // Optionals
+    if (type.startsWith('optional<') && type.endsWith('>')) {
+        const inner_type = type.slice(9, -1);
+        return serialize_optional(value, inner_type);
+    }
+    // Maps
+    const map_match = type.match(/^map<(.+),\s*(.+)>$/);
+    if (map_match) {
+        const [, keyType, valueType] = map_match;
+        if (typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`Expected object for type ${type}, got ${typeof value}`);
+        }
+        return serialize_map(value, keyType.trim(), valueType.trim());
+    }
+    // Generic enum/struct notations: enum<Foo>, struct<Bar>
+    const enumGeneric = type.match(/^enum<\s*([^>]+)\s*>$/i);
+    if (enumGeneric) {
+        const realType = enumGeneric[1].trim();
+        const custom = typeRegistry.get(realType);
+        if (!custom)
+            throw new Error(`Unregistered enum type: ${realType}`);
+        return custom.to_VMParameter(value);
+    }
+    const structGeneric = type.match(/^struct<\s*([^>]+)\s*>$/i);
+    if (structGeneric) {
+        const realType = structGeneric[1].trim();
+        const custom = typeRegistry.get(realType);
+        if (!custom)
+            throw new Error(`Unregistered struct type: ${realType}`);
+        return custom.to_VMParameter(value);
+    }
+    // Preferred: named custom type
+    const custom_type = typeRegistry.get(type);
+    if (custom_type) {
+        return custom_type.to_VMParameter(value);
+    }
+    // **Fix for ABI that says literally "enum"/"struct"**
+    if (type === 'enum' && value && typeof value === 'object' && 'type' in value) {
+        const variantName = value.type;
+        for (const t of typeRegistry.all()) {
+            const anyT = t;
+            if (anyT?.kind === 'enum' && typeof anyT.hasVariant === 'function' && anyT.hasVariant(variantName)) {
+                return t.to_VMParameter(value);
+            }
+        }
+        throw new Error(`Cannot resolve enum type for variant '${variantName}'. Is it registered?`);
+    }
+    if (type === 'struct') {
+        // Best-effort: if your ABI truly says "struct" w/o a name, you’ll need a hint.
+        // You can add your own resolution heuristic here if you have one.
+        throw new Error(`Unknown struct subtype; ABI must specify struct<Foo> or a named type`);
+    }
+    // Primitive fallback
+    if (type in TYPE_VALIDATORS) {
+        return createVMPrimitive(value, type, validate);
+    }
+    console.error("[VMParam] unknown type", type, { value });
+    throw new Error(`Unknown type: ${type}`);
+}
+// ============================================================================
+// Contract Invocation Helpers
+// ============================================================================
 /**
  * Creates a deposits object for contract calls
  * @param deposits - Object mapping token hashes to amounts
  */
 export function createDeposits(deposits) {
     const result = {};
-    for (const [tokenHash, amount] of Object.entries(deposits)) {
+    for (const [token_hash, amount] of Object.entries(deposits)) {
         // Validate hash format
-        if (!/^[0-9a-fA-F]{64}$/.test(tokenHash)) {
-            throw new Error(`Invalid token hash format: ${tokenHash}`);
+        if (!/^[0-9a-fA-F]{64}$/.test(token_hash)) {
+            throw new Error(`Invalid token hash format: ${token_hash}`);
         }
-        result[tokenHash] = { amount };
+        result[token_hash] = { amount };
     }
     return result;
 }
 export function createContractInvocation(params) {
-    const { contract, chunkId, parameters = [], deposits, maxGas = 200000000 } = params;
+    const { contract, chunk_id, parameters = [], deposits, permission, maxGas = 50000000 } = params;
     const result = {
         invoke_contract: {
             contract,
             max_gas: maxGas,
-            chunk_id: chunkId,
+            entry_id: chunk_id,
+            permission,
             parameters
         }
     };
@@ -152,11 +369,11 @@ export function createContractInvocation(params) {
     return result;
 }
 export function createContractDeployment(params) {
-    const { bytecode, hasConstructor = false, maxGas = 200000000 } = params;
+    const { bytecode, hasConstructor = false, maxGas = 50000000 } = params;
     const result = {
         deploy_contract: {
             module: bytecode,
-            ...(hasConstructor && { invoke: { max_gas: maxGas } })
+            ...(hasConstructor && { invoke: { maxGas } })
         }
     };
     return result;