@xelis/sdk 0.11.31 → 0.11.33

package/dist/esm/contract/contract.js

@@ -1,34 +1,4 @@
-import { createVMParameter, createContractInvocation } from './xvm_serializer.js';
-;
-// Convert ABI type to our 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',
-        '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';
 /**
  * Contract class that dynamically generates methods based on ABI
  */
@@ -37,107 +7,179 @@ export class Contract {
         this.address = address;
         this.abi = abi;
         this.methods = new Map();
-        // Parse ABI and set up methods map
+        this.register_internal_types();
         for (const entry of abi.data) {
             if (entry.type === 'entry') {
                 this.methods.set(entry.name, entry);
-                // Dynamically add method to the instance
-                this.createDynamicMethod(entry);
+                this.create_dynamic_method(entry);
+            }
+        }
+    }
+    /**
+     * 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;
     }
     /**
      * Creates a dynamic method on the contract instance
      */
-    createDynamicMethod(entry) {
-        const methodName = entry.name;
-        // Create a method that properly binds 'this'
+    create_dynamic_method(entry) {
+        const method_name = entry.name;
         const method = (params) => {
-            return this.invoke(methodName, params);
+            return this.invoke(method_name, params);
         };
-        // Add the method to the instance
-        this[methodName] = method;
+        this[method_name] = method;
     }
     /**
      * Invoke a contract method by name
-     * @param methodName - Name of the method from the ABI
+     * @param method_name - Name of the method from the ABI
      * @param params - Parameters for the method call
      */
-    invoke(methodName, params = {}) {
-        const entry = this.methods.get(methodName);
+    invoke(method_name, params = { permission: "all" }) {
+        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];
+        for (const abi_param of entry.params) {
+            const value = method_params[abi_param.name];
             if (value === undefined) {
-                throw new Error(`Missing required parameter '${abiParam.name}' for method '${methodName}'`);
+                throw new Error(`Missing required parameter '${abi_param.name}' for method '${method_name}'`);
             }
             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);
     }
     /**
      * 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);
     }
     /**
      * Validate parameters for a method without creating the transaction
      */
-    validateParams(methodName, params) {
-        const entry = this.methods.get(methodName);
+    validate_params(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`);
         }
-        const { deposits, maxGas, ...methodParams } = params;
-        // Check all required parameters are present
-        for (const abiParam of entry.params) {
-            if (!(abiParam.name in methodParams)) {
-                throw new Error(`Missing required parameter '${abiParam.name}'`);
+        const { deposits, maxGas, ...method_params } = params;
+        for (const abi_param of entry.params) {
+            if (!(abi_param.name in method_params)) {
+                throw new Error(`Missing required parameter '${abi_param.name}'`);
             }
-            // Validate type
             try {
-                const normalizedType = normalizeType(abiParam.type);
-                createVMParameter(methodParams[abiParam.name], normalizedType, true);
+                createVMParameter(method_params[abi_param.name], abi_param.type, true);
             }
             catch (error) {
-                throw new Error(`Invalid parameter '${abiParam.name}': ${error}`);
+                throw new Error(`Invalid parameter '${abi_param.name}': ${error}`);
             }
         }
-        // Check for extra parameters
-        const expectedParams = new Set(entry.params.map(p => p.name));
-        for (const key in methodParams) {
-            if (!expectedParams.has(key)) {
-                console.warn(`Warning: Unexpected parameter '${key}' for method '${methodName}'`);
+        const expected_params = new Set(entry.params.map(p => p.name));
+        for (const key in method_params) {
+            if (!expected_params.has(key)) {
+                console.warn(`Warning: Unexpected parameter '${key}' for method '${method_name}'`);
             }
         }
         return true;
@@ -147,7 +189,7 @@ export class Contract {
  * Helper function to create a typed contract instance
  * This provides better TypeScript support when the ABI is known at compile time
  */
-export function createContract(address, abi) {
+export function create_contract(address, abi) {
     return new Contract(address, abi);
 }
 /**
@@ -161,12 +203,12 @@ export class ContractFactory {
      * Create a new contract instance at the specified address
      */
     at(address) {
-        return createContract(address, this.abi);
+        return create_contract(address, this.abi);
     }
     /**
      * Get the ABI
      */
-    getABI() {
+    get_abi() {
         return this.abi;
     }
 }

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);
 }