@xelis/sdk 0.11.14 → 0.11.16

package/dist/esm/contract/contract.js

@@ -0,0 +1,172 @@
+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;
+}
+/**
+ * Contract class that dynamically generates methods based on ABI
+ */
+export class Contract {
+    constructor(address, abi) {
+        this.address = address;
+        this.abi = abi;
+        this.methods = new Map();
+        // Parse ABI and set up methods map
+        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);
+            }
+        }
+    }
+    /**
+     * Creates a dynamic method on the contract instance
+     */
+    createDynamicMethod(entry) {
+        const methodName = entry.name;
+        // Create a method that properly binds 'this'
+        const method = (params) => {
+            return this.invoke(methodName, params);
+        };
+        // Add the method to the instance
+        this[methodName] = method;
+    }
+    /**
+     * Invoke a contract method by name
+     * @param methodName - Name of the method from the ABI
+     * @param params - Parameters for the method call
+     */
+    invoke(methodName, params = {}) {
+        const entry = this.methods.get(methodName);
+        if (!entry) {
+            throw new Error(`Method '${methodName}' not found in contract ABI`);
+        }
+        // Extract special parameters
+        const { maxGas, deposits, ...methodParams } = params;
+        // Build parameter list according to ABI
+        const parameters = [];
+        for (const abiParam of entry.params) {
+            const value = methodParams[abiParam.name];
+            if (value === undefined) {
+                throw new Error(`Missing required parameter '${abiParam.name}' for method '${methodName}'`);
+            }
+            try {
+                const normalizedType = normalizeType(abiParam.type);
+                const vmParam = createVMParameter(value, normalizedType);
+                parameters.push(vmParam);
+            }
+            catch (error) {
+                throw new Error(`Invalid parameter '${abiParam.name}' for method '${methodName}': ${error}`);
+            }
+        }
+        // Create the contract invocation
+        const invocationParams = {
+            contract: this.address,
+            chunkId: entry.chunk_id,
+            parameters,
+            maxGas: maxGas || 200000000
+        };
+        if (deposits && Object.keys(deposits).length > 0) {
+            invocationParams.deposits = deposits;
+        }
+        return createContractInvocation(invocationParams);
+    }
+    /**
+     * Get list of available methods
+     */
+    getMethods() {
+        return Array.from(this.methods.keys());
+    }
+    /**
+     * Get method signature information
+     */
+    getMethodSignature(methodName) {
+        return this.methods.get(methodName);
+    }
+    /**
+     * Validate parameters for a method without creating the transaction
+     */
+    validateParams(methodName, params) {
+        const entry = this.methods.get(methodName);
+        if (!entry) {
+            throw new Error(`Method '${methodName}' 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}'`);
+            }
+            // Validate type
+            try {
+                const normalizedType = normalizeType(abiParam.type);
+                createVMParameter(methodParams[abiParam.name], normalizedType, true);
+            }
+            catch (error) {
+                throw new Error(`Invalid parameter '${abiParam.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}'`);
+            }
+        }
+        return true;
+    }
+}
+/**
+ * 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) {
+    return new Contract(address, abi);
+}
+/**
+ * Factory for creating multiple contracts with the same ABI
+ */
+export class ContractFactory {
+    constructor(abi) {
+        this.abi = abi;
+    }
+    /**
+     * Create a new contract instance at the specified address
+     */
+    at(address) {
+        return createContract(address, this.abi);
+    }
+    /**
+     * Get the ABI
+     */
+    getABI() {
+        return this.abi;
+    }
+}

package/dist/esm/contract/typed_contract.js

@@ -0,0 +1,251 @@
+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;
+}
+/**
+ * Strongly typed contract class
+ */
+export class TypedContract {
+    constructor(address, abi) {
+        this.address = address;
+        this.abi = abi;
+        this.methods = new Map();
+        // Initialize methods
+        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);
+                }
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Internal method to invoke contract functions
+     */
+    invokeUnsafe(methodName, params = {}) {
+        const entry = this.methods.get(methodName);
+        if (!entry) {
+            throw new Error(`Method '${methodName}' not found in contract ABI`);
+        }
+        // Extract special parameters
+        const { maxGas, deposits, ...methodParams } = params;
+        // Build parameter list according to ABI
+        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;
+                }
+                else {
+                    throw new Error(`Missing required parameter '${abiParam.name}' for method '${methodName}'`);
+                }
+            }
+            if (value !== undefined) {
+                try {
+                    const normalizedType = normalizeType(abiParam.type);
+                    const vmParam = createVMParameter(value, normalizedType);
+                    parameters.push(vmParam);
+                }
+                catch (error) {
+                    throw new Error(`Invalid parameter '${abiParam.name}' for method '${methodName}': ${error}`);
+                }
+            }
+        }
+        // Create the contract invocation
+        const invocationParams = {
+            contract: this.address,
+            chunkId: entry.chunk_id,
+            parameters,
+            maxGas: maxGas || 200000000
+        };
+        if (deposits && Object.keys(deposits).length > 0) {
+            invocationParams.deposits = deposits;
+        }
+        return createContractInvocation(invocationParams);
+    }
+    /**
+     * Type-safe invoke method
+     */
+    invoke(methodName, params) {
+        return this.invokeUnsafe(methodName, params);
+    }
+    /**
+     * Get list of available methods
+     */
+    getMethods() {
+        return Array.from(this.methods.keys());
+    }
+    /**
+     * Get method signature information
+     */
+    getMethodSignature(methodName) {
+        return this.methods.get(methodName);
+    }
+    /**
+     * Generate TypeScript interface for the contract
+     */
+    generateInterface() {
+        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)};`;
+            }).join('\n');
+            lines.push(`  ${name}(params: {`);
+            lines.push(params);
+            lines.push('    maxGas?: number;');
+            lines.push('    deposits?: Record<string, number | bigint>;');
+            lines.push('  }): Record<string, any>;');
+            lines.push('');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    getTypeScriptType(abiType) {
+        const typeMap = {
+            'Hash': 'string',
+            'Address': 'string',
+            'PublicKey': 'string',
+            'Blob': 'string',
+            'String': 'string',
+            'string': 'string',
+            'Boolean': 'boolean',
+            'boolean': 'boolean',
+            'bool': 'boolean',
+            'U256': 'bigint | number',
+            'u256': 'bigint | number',
+            'U128': 'bigint | number',
+            'u128': 'bigint | number',
+            'U64': 'bigint | number',
+            'u64': 'bigint | number',
+            'U32': 'number',
+            'u32': 'number',
+            'U16': 'number',
+            'u16': 'number',
+            'U8': 'number',
+            'u8': 'number'
+        };
+        return typeMap[abiType] || 'any';
+    }
+}
+/**
+ * Create a typed contract instance with full TypeScript support
+ */
+export function createTypedContract(address, abi) {
+    return new TypedContract(address, abi);
+}
+/**
+ * Contract factory with strong typing
+ */
+export class TypedContractFactory {
+    constructor(abi, contractName = 'Contract') {
+        this.abi = abi;
+        this.contractName = contractName;
+    }
+    /**
+     * Create a new contract instance at the specified address
+     */
+    at(address) {
+        return createTypedContract(address, this.abi);
+    }
+    /**
+     * Get the ABI
+     */
+    getABI() {
+        return this.abi;
+    }
+    /**
+     * Generate TypeScript definitions for this contract
+     */
+    generateTypeDefinitions() {
+        const contract = new TypedContract('0x0', this.abi);
+        return contract.generateInterface();
+    }
+}
+/**
+ * Utility to validate ABI structure
+ */
+export function validateABI(abi) {
+    if (!Array.isArray(abi)) {
+        return false;
+    }
+    for (const entry of abi) {
+        if (typeof entry !== 'object' || !entry) {
+            return false;
+        }
+        if (typeof entry.chunk_id !== 'number') {
+            return false;
+        }
+        if (typeof entry.name !== 'string') {
+            return false;
+        }
+        if (!Array.isArray(entry.params)) {
+            return false;
+        }
+        if (entry.type !== 'entry' && entry.type !== 'view') {
+            return false;
+        }
+        for (const param of entry.params) {
+            if (typeof param.name !== 'string' || typeof param.type !== 'string') {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Helper to create a contract from JSON ABI
+ */
+export async function createContractFromJSON(address, abiPath) {
+    const response = await fetch(abiPath);
+    const abi = await response.json();
+    if (!validateABI(abi.data)) {
+        throw new Error('Invalid ABI structure');
+    }
+    return createTypedContract(address, abi);
+}

package/dist/esm/contract/xvm_serializer.js

@@ -0,0 +1,163 @@
+// Known opaque types that need special wrapping
+const OPAQUE_TYPES = new Set(['Hash', 'Address', 'PublicKey', 'Blob' /** TODO */]);
+// Type validation and conversion helpers
+const TYPE_VALIDATORS = {
+    'u256': (v) => {
+        const num = typeof v === 'bigint' ? v : BigInt(v);
+        if (num < 0n)
+            throw new Error(`Value ${v} cannot be negative for u256`);
+        return Number(num);
+    },
+    'u128': (v) => {
+        const num = typeof v === 'bigint' ? v : BigInt(v);
+        if (num < 0n)
+            throw new Error(`Value ${v} cannot be negative for u128`);
+        return Number(num);
+    },
+    'u64': (v) => {
+        const num = typeof v === 'bigint' ? v : BigInt(v);
+        if (num < 0n || num > 0xffffffffffffffffn) {
+            throw new Error(`Value ${v} is out of range for u64`);
+        }
+        return Number(num);
+    },
+    'u32': (v) => {
+        const num = Number(v);
+        if (num < 0 || num > 0xFFFFFFFF || !Number.isInteger(num)) {
+            throw new Error(`Value ${v} is not a valid u32`);
+        }
+        return num;
+    },
+    'u16': (v) => {
+        const num = Number(v);
+        if (num < 0 || num > 0xFFFF || !Number.isInteger(num)) {
+            throw new Error(`Value ${v} is not a valid u16`);
+        }
+        return num;
+    },
+    'u8': (v) => {
+        const num = Number(v);
+        if (num < 0 || num > 255 || !Number.isInteger(num)) {
+            throw new Error(`Value ${v} is not a valid u8`);
+        }
+        return num;
+    },
+    'boolean': (v) => Boolean(v),
+    'string': (v) => String(v),
+    'Hash': (v) => {
+        const str = String(v);
+        if (!/^[0-9a-fA-F]{64}$/.test(str)) {
+            throw new Error(`Value ${v} is not a valid 64-character hex hash`);
+        }
+        return str;
+    },
+    'Address': (v) => {
+        const str = String(v);
+        // TODO validate
+        return str;
+    },
+    'PublicKey': (v) => {
+        const str = String(v);
+        // TODO validate
+        return str;
+    },
+    'Blob': (v) => {
+        const str = String(v);
+        // TODO validate
+        return str;
+    }
+};
+/**
+ * Creates a VM-compatible parameter object
+ * @param value - The value to wrap
+ * @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;
+    // Validate and convert value if requested
+    if (validate && TYPE_VALIDATORS[type]) {
+        try {
+            processedValue = TYPE_VALIDATORS[type](value);
+        }
+        catch (error) {
+            throw new Error(`Failed to create VM parameter for type ${type}: ${error}`);
+        }
+    }
+    // Handle opaque types (Hash, Address, PublicKey)
+    if (OPAQUE_TYPES.has(type)) {
+        return {
+            type: "default",
+            value: {
+                type: "opaque",
+                value: {
+                    type: type,
+                    value: processedValue
+                }
+            }
+        };
+    }
+    // Handle regular types
+    return {
+        type: "default",
+        value: {
+            type: type,
+            value: processedValue
+        }
+    };
+}
+/**
+ * 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'),
+};
+/**
+ * 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)) {
+        // Validate hash format
+        if (!/^[0-9a-fA-F]{64}$/.test(tokenHash)) {
+            throw new Error(`Invalid token hash format: ${tokenHash}`);
+        }
+        result[tokenHash] = { amount };
+    }
+    return result;
+}
+export function createContractInvocation(params) {
+    const { contract, chunkId, parameters = [], deposits, maxGas = 200000000 } = params;
+    const result = {
+        invoke_contract: {
+            contract,
+            max_gas: maxGas,
+            chunk_id: chunkId,
+            parameters
+        }
+    };
+    if (deposits && Object.keys(deposits).length > 0) {
+        result.invoke_contract.deposits = createDeposits(deposits);
+    }
+    return result;
+}
+export function createContractDeployment(params) {
+    const { bytecode, hasConstructor = false, maxGas = 200000000 } = params;
+    const result = {
+        deploy_contract: {
+            module: bytecode,
+            ...(hasConstructor && { invoke: { max_gas: maxGas } })
+        }
+    };
+    return result;
+}