@xelis/sdk 0.11.15 → 0.11.16

package/dist/cjs/contract/typed_contract.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContractFromJSON = exports.validateABI = exports.TypedContractFactory = exports.createTypedContract = exports.TypedContract = void 0;
+const xvm_serializer_1 = require("./xvm_serializer");
+// 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
+ */
+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 = (0, xvm_serializer_1.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 (0, xvm_serializer_1.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';
+    }
+}
+exports.TypedContract = TypedContract;
+/**
+ * Create a typed contract instance with full TypeScript support
+ */
+function createTypedContract(address, abi) {
+    return new TypedContract(address, abi);
+}
+exports.createTypedContract = createTypedContract;
+/**
+ * Contract factory with strong typing
+ */
+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();
+    }
+}
+exports.TypedContractFactory = TypedContractFactory;
+/**
+ * Utility to validate ABI structure
+ */
+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;
+}
+exports.validateABI = validateABI;
+/**
+ * Helper to create a contract from JSON ABI
+ */
+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);
+}
+exports.createContractFromJSON = createContractFromJSON;

package/dist/cjs/contract/xvm_serializer.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContractDeployment = exports.createContractInvocation = exports.createDeposits = exports.vmParam = exports.createVMParameter = void 0;
+// 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)
+ */
+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
+        }
+    };
+}
+exports.createVMParameter = createVMParameter;
+/**
+ * Convenience functions for common types
+ */
+exports.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
+ */
+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;
+}
+exports.createDeposits = createDeposits;
+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;
+}
+exports.createContractInvocation = createContractInvocation;
+function createContractDeployment(params) {
+    const { bytecode, hasConstructor = false, maxGas = 200000000 } = params;
+    const result = {
+        deploy_contract: {
+            module: bytecode,
+            ...(hasConstructor && { invoke: { max_gas: maxGas } })
+        }
+    };
+    return result;
+}
+exports.createContractDeployment = createContractDeployment;