@xelis/sdk 0.11.15 → 0.11.17

package/dist/cjs/address/bech32.js

@@ -1,44 +1,35 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.encode = exports.decode = exports.convertBits = void 0;
-var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-var GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
-var SEPARTOR = ":";
+const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+const SEPARTOR = ":";
 var ErrHrpMixCase = "mix case is not allowed in human readable part";
 var ErrInvalidChecksum = "invalid checksum";
 var ErrNonZeroPadding = "non zero padding";
 var ErrIllegalZeroPadding = "illegal zero padding";
 var ErrHrpEmpty = "human readable part is empty";
 function ErrSeparatorInvalidPosition(pos) {
-    return "invalid separator position: ".concat(pos);
+    return `invalid separator position: ${pos}`;
 }
 function ErrHrpInvalidCharacter(c) {
-    return "invalid character value in human readable part: ".concat(c);
+    return `invalid character value in human readable part: ${c}`;
 }
 function ErrInvalidIndex(index) {
-    return "invalid index ".concat(index);
+    return `invalid index ${index}`;
 }
 function ErrInvalidValue(value, max) {
-    return "invalid value: ".concat(value, ", max is ").concat(max);
+    return `invalid value: ${value}, max is ${max}`;
 }
 function ErrInvalidDataRange(value, from) {
-    return "invalid data range: ".concat(value, ", max is ").concat(from);
+    return `invalid data range: ${value}, max is ${from}`;
 }
 function polymod(values) {
-    var chk = 1;
-    values.forEach(function (value) {
-        var top = chk >> 25;
+    let chk = 1;
+    values.forEach((value) => {
+        let top = chk >> 25;
         chk = ((chk & 0x1ffffff) << 5) ^ value;
-        GENERATOR.forEach(function (item, i) {
+        GENERATOR.forEach((item, i) => {
             if (((top >> i) & 1) === 1) {
                 chk ^= item;
             }
@@ -47,34 +38,34 @@ function polymod(values) {
     return chk;
 }
 function hrpExpand(hrp) {
-    var encoder = new TextEncoder();
-    var bytes = encoder.encode(hrp);
-    var result = [];
-    bytes.forEach(function (c) { return result.push(c >> 5); });
+    let encoder = new TextEncoder();
+    let bytes = encoder.encode(hrp);
+    let result = [];
+    bytes.forEach((c) => result.push(c >> 5));
     result.push(0);
-    bytes.forEach(function (c) { return result.push(c & 31); });
+    bytes.forEach((c) => result.push(c & 31));
     return result;
 }
 function verifyChecksum(hrp, data) {
-    var vec = hrpExpand(hrp);
-    vec = __spreadArray(__spreadArray([], vec, true), data, true);
+    let vec = hrpExpand(hrp);
+    vec = [...vec, ...data];
     return polymod(vec) === 1;
 }
 function createChecksum(hrp, data) {
-    var result = [0, 0, 0, 0, 0, 0];
-    var values = __spreadArray(__spreadArray(__spreadArray([], hrpExpand(hrp), true), data, true), result, true);
-    var pm = polymod(values) ^ 1;
-    for (var i = 0; i < 6; i++) {
+    let result = [0, 0, 0, 0, 0, 0];
+    let values = [...hrpExpand(hrp), ...data, ...result];
+    let pm = polymod(values) ^ 1;
+    for (let i = 0; i < 6; i++) {
         result[i] = pm >> (5 * (5 - i)) & 31;
     }
     return result;
 }
 function convertBits(data, from, to, pad) {
-    var result = [];
-    var acc = 0;
-    var bits = 0;
-    var maxValue = (1 << to) - 1;
-    data.forEach(function (value) {
+    let result = [];
+    let acc = 0;
+    let bits = 0;
+    let maxValue = (1 << to) - 1;
+    data.forEach((value) => {
         if (value >> from !== 0) {
             throw ErrInvalidDataRange(value, from);
         }
@@ -103,25 +94,25 @@ function decode(bech) {
     if (bech.toUpperCase() !== bech && bech.toLowerCase() !== bech) {
         throw ErrHrpMixCase;
     }
-    var pos = bech.indexOf(SEPARTOR);
+    let pos = bech.indexOf(SEPARTOR);
     if (pos < 1 || pos + 7 > bech.length) {
         throw ErrSeparatorInvalidPosition(pos);
     }
-    var hrp = bech.substring(0, pos);
-    var encoder = new TextEncoder();
-    var hrpBytes = encoder.encode(hrp);
-    var decoded = [];
-    hrpBytes.forEach(function (value) {
+    let hrp = bech.substring(0, pos);
+    let encoder = new TextEncoder();
+    let hrpBytes = encoder.encode(hrp);
+    let decoded = [];
+    hrpBytes.forEach((value) => {
         if (value < 33 || value > 126) {
             throw ErrHrpInvalidCharacter(value);
         }
     });
-    for (var i = pos + 1; i < bech.length; i++) {
+    for (let i = pos + 1; i < bech.length; i++) {
         if (i >= bech.length) {
             throw ErrInvalidIndex(i);
         }
-        var c = bech[i];
-        var index = CHARSET.indexOf(c);
+        let c = bech[i];
+        let index = CHARSET.indexOf(c);
         if (index === -1) {
             throw ErrHrpInvalidCharacter;
         }
@@ -131,16 +122,16 @@ function decode(bech) {
         throw ErrInvalidChecksum;
     }
     decoded.splice(decoded.length - 6, 6);
-    return { hrp: hrp, decoded: decoded };
+    return { hrp, decoded };
 }
 exports.decode = decode;
 function encode(hrp, data) {
     if (hrp.length === 0) {
         throw ErrHrpEmpty;
     }
-    var encoder = new TextEncoder();
-    var hrpBytes = encoder.encode(hrp);
-    hrpBytes.forEach(function (value) {
+    let encoder = new TextEncoder();
+    let hrpBytes = encoder.encode(hrp);
+    hrpBytes.forEach((value) => {
         if (value < 33 || value > 126) {
             throw ErrHrpInvalidCharacter(value);
         }
@@ -149,19 +140,19 @@ function encode(hrp, data) {
         throw ErrHrpMixCase;
     }
     hrp = hrp.toLowerCase();
-    var combined = __spreadArray(__spreadArray([], data, true), createChecksum(hrp, data), true);
-    var result = __spreadArray(__spreadArray([], Array.from(hrpBytes), true), [SEPARTOR.charCodeAt(0)], false);
-    combined.forEach(function (index) {
+    let combined = [...data, ...createChecksum(hrp, data)];
+    let result = [...Array.from(hrpBytes), SEPARTOR.charCodeAt(0)];
+    combined.forEach((index) => {
         if (index > CHARSET.length) {
             throw ErrInvalidValue(index, CHARSET.length);
         }
-        var value = CHARSET.charCodeAt(index);
+        let value = CHARSET.charCodeAt(index);
         if (!value) {
             throw ErrInvalidIndex(index);
         }
         result.push(value);
     });
-    var decoder = new TextDecoder();
+    let decoder = new TextDecoder();
     return decoder.decode(new Uint8Array(result));
 }
 exports.encode = encode;

package/dist/cjs/address/index.js

@@ -1,21 +1,21 @@
 "use strict";
-exports.__esModule = true;
-var bech32_1 = require("./bech32");
-var value_1 = require("../data/value");
+Object.defineProperty(exports, "__esModule", { value: true });
+const bech32_1 = require("./bech32");
+const value_1 = require("../data/value");
 var PrefixAddress = "xel";
 var TestnetPrefixAddress = "xet";
 var ExtraDataLimit = 1024;
 var ErrIntegratedDataLimit = "invalid data in integrated address, maximum size reached";
 var ErrInvalidNetworkPrefix = "invalid network prefix (xel or xet)";
-var Address = /** @class */ (function () {
-    function Address(data, hrp) {
+class Address {
+    constructor(data, hrp) {
         this.isMainnet = hrp === PrefixAddress;
         this.publicKey = Array.from(data);
         switch (data[32]) {
             case 1:
                 this.isIntegrated = true;
-                var extraData = new Uint8Array(this.publicKey.slice(33));
-                var reader = new value_1.ValueReader(extraData);
+                let extraData = new Uint8Array(this.publicKey.slice(33));
+                let reader = new value_1.ValueReader(extraData);
                 this.extraData = reader.read();
                 break;
             case 0:
@@ -25,31 +25,30 @@ var Address = /** @class */ (function () {
                 throw "invalid address type";
         }
     }
-    Address.fromString = function (addr) {
-        var _a = (0, bech32_1.decode)(addr), hrp = _a.hrp, decoded = _a.decoded;
+    static fromString(addr) {
+        let { hrp, decoded } = (0, bech32_1.decode)(addr);
         if (hrp !== PrefixAddress && hrp !== TestnetPrefixAddress) {
             throw ErrInvalidNetworkPrefix;
         }
-        var bits = (0, bech32_1.convertBits)(decoded, 5, 8, false);
+        let bits = (0, bech32_1.convertBits)(decoded, 5, 8, false);
         return new Address(bits, hrp);
-    };
-    Address.isValid = function (addr) {
+    }
+    static isValid(addr) {
         try {
             Address.fromString(addr);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
-    };
-    Address.prototype.format = function () {
-        var bits = (0, bech32_1.convertBits)(this.publicKey, 8, 5, true);
-        var hrp = PrefixAddress;
+    }
+    format() {
+        let bits = (0, bech32_1.convertBits)(this.publicKey, 8, 5, true);
+        let hrp = PrefixAddress;
         if (!this.isMainnet) {
             hrp = TestnetPrefixAddress;
         }
         return (0, bech32_1.encode)(hrp, bits);
-    };
-    return Address;
-}());
-exports["default"] = Address;
+    }
+}
+exports.default = Address;

package/dist/cjs/config.js

@@ -1,42 +1,30 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.XELIS_DECIMALS = exports.XELIS_ASSET = exports.LOCAL_XSWD_WS = exports.LOCAL_XSWD_URL = exports.LOCAL_WALLET_WS = exports.LOCAL_WALLET_RPC = exports.LOCAL_WALLET_URL = exports.LOCAL_NODE_WS = exports.TESTNET_NODE_WS = exports.MAINNET_NODE_WS = exports.LOCAL_NODE_RPC = exports.TESTNET_NODE_RPC = exports.MAINNET_NODE_RPC = exports.LOCAL_NODE_URL = exports.TESTNET_NODE_URL = exports.MAINNET_NODE_URL = exports.XSWD_PORT = exports.WALLET_RPC_PORT = exports.DAEMON_RPC_PORT = void 0;
-exports.DAEMON_RPC_PORT = "8080";
-exports.WALLET_RPC_PORT = "8081";
-exports.XSWD_PORT = "44325";
-exports.MAINNET_NODE_URL = "node.xelis.io";
-exports.TESTNET_NODE_URL = "testnet-node.xelis.io";
-exports.LOCAL_NODE_URL = "127.0.0.1:".concat(exports.DAEMON_RPC_PORT);
-exports.MAINNET_NODE_RPC = "https://".concat(exports.MAINNET_NODE_URL, "/json_rpc");
-exports.TESTNET_NODE_RPC = "https://".concat(exports.TESTNET_NODE_URL, "/json_rpc");
-exports.LOCAL_NODE_RPC = "http://".concat(exports.LOCAL_NODE_URL, "/json_rpc");
-exports.MAINNET_NODE_WS = "wss://".concat(exports.MAINNET_NODE_URL, "/json_rpc");
-exports.TESTNET_NODE_WS = "wss://".concat(exports.TESTNET_NODE_URL, "/json_rpc");
-exports.LOCAL_NODE_WS = "ws://".concat(exports.LOCAL_NODE_URL, "/json_rpc");
-exports.LOCAL_WALLET_URL = "127.0.0.1:".concat(exports.WALLET_RPC_PORT);
-exports.LOCAL_WALLET_RPC = "http://".concat(exports.LOCAL_WALLET_URL, "/json_rpc");
-exports.LOCAL_WALLET_WS = "ws://".concat(exports.LOCAL_WALLET_URL, "/json_rpc");
-exports.LOCAL_XSWD_URL = "127.0.0.1:".concat(exports.XSWD_PORT);
-exports.LOCAL_XSWD_WS = "ws://".concat(exports.LOCAL_XSWD_URL, "/xswd");
-exports.XELIS_ASSET = "0000000000000000000000000000000000000000000000000000000000000000";
+exports.DAEMON_RPC_PORT = `8080`;
+exports.WALLET_RPC_PORT = `8081`;
+exports.XSWD_PORT = `44325`;
+exports.MAINNET_NODE_URL = `node.xelis.io`;
+exports.TESTNET_NODE_URL = `testnet-node.xelis.io`;
+exports.LOCAL_NODE_URL = `127.0.0.1:${exports.DAEMON_RPC_PORT}`;
+exports.MAINNET_NODE_RPC = `https://${exports.MAINNET_NODE_URL}/json_rpc`;
+exports.TESTNET_NODE_RPC = `https://${exports.TESTNET_NODE_URL}/json_rpc`;
+exports.LOCAL_NODE_RPC = `http://${exports.LOCAL_NODE_URL}/json_rpc`;
+exports.MAINNET_NODE_WS = `wss://${exports.MAINNET_NODE_URL}/json_rpc`;
+exports.TESTNET_NODE_WS = `wss://${exports.TESTNET_NODE_URL}/json_rpc`;
+exports.LOCAL_NODE_WS = `ws://${exports.LOCAL_NODE_URL}/json_rpc`;
+exports.LOCAL_WALLET_URL = `127.0.0.1:${exports.WALLET_RPC_PORT}`;
+exports.LOCAL_WALLET_RPC = `http://${exports.LOCAL_WALLET_URL}/json_rpc`;
+exports.LOCAL_WALLET_WS = `ws://${exports.LOCAL_WALLET_URL}/json_rpc`;
+exports.LOCAL_XSWD_URL = `127.0.0.1:${exports.XSWD_PORT}`;
+exports.LOCAL_XSWD_WS = `ws://${exports.LOCAL_XSWD_URL}/xswd`;
+exports.XELIS_ASSET = `0000000000000000000000000000000000000000000000000000000000000000`;
 exports.XELIS_DECIMALS = 8;
-exports["default"] = {
-    MAINNET_NODE_URL: exports.MAINNET_NODE_URL,
-    TESTNET_NODE_URL: exports.TESTNET_NODE_URL,
-    MAINNET_NODE_RPC: exports.MAINNET_NODE_RPC,
-    TESTNET_NODE_RPC: exports.TESTNET_NODE_RPC,
-    LOCAL_NODE_RPC: exports.LOCAL_NODE_RPC,
-    MAINNET_NODE_WS: exports.MAINNET_NODE_WS,
-    TESTNET_NODE_WS: exports.TESTNET_NODE_WS,
-    LOCAL_NODE_WS: exports.LOCAL_NODE_WS,
-    DAEMON_RPC_PORT: exports.DAEMON_RPC_PORT,
-    WALLET_RPC_PORT: exports.WALLET_RPC_PORT,
-    XSWD_PORT: exports.XSWD_PORT,
-    LOCAL_WALLET_URL: exports.LOCAL_WALLET_URL,
-    LOCAL_WALLET_RPC: exports.LOCAL_WALLET_RPC,
-    LOCAL_WALLET_WS: exports.LOCAL_WALLET_WS,
-    LOCAL_XSWD_URL: exports.LOCAL_XSWD_URL,
-    LOCAL_XSWD_WS: exports.LOCAL_XSWD_WS,
-    XELIS_ASSET: exports.XELIS_ASSET,
-    XELIS_DECIMALS: exports.XELIS_DECIMALS
+exports.default = {
+    MAINNET_NODE_URL: exports.MAINNET_NODE_URL, TESTNET_NODE_URL: exports.TESTNET_NODE_URL,
+    MAINNET_NODE_RPC: exports.MAINNET_NODE_RPC, TESTNET_NODE_RPC: exports.TESTNET_NODE_RPC, LOCAL_NODE_RPC: exports.LOCAL_NODE_RPC,
+    MAINNET_NODE_WS: exports.MAINNET_NODE_WS, TESTNET_NODE_WS: exports.TESTNET_NODE_WS, LOCAL_NODE_WS: exports.LOCAL_NODE_WS,
+    DAEMON_RPC_PORT: exports.DAEMON_RPC_PORT, WALLET_RPC_PORT: exports.WALLET_RPC_PORT, XSWD_PORT: exports.XSWD_PORT,
+    LOCAL_WALLET_URL: exports.LOCAL_WALLET_URL, LOCAL_WALLET_RPC: exports.LOCAL_WALLET_RPC, LOCAL_WALLET_WS: exports.LOCAL_WALLET_WS,
+    LOCAL_XSWD_URL: exports.LOCAL_XSWD_URL, LOCAL_XSWD_WS: exports.LOCAL_XSWD_WS, XELIS_ASSET: exports.XELIS_ASSET, XELIS_DECIMALS: exports.XELIS_DECIMALS
 };

package/dist/cjs/contract/contract.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractFactory = exports.createContract = exports.Contract = void 0;
+const xvm_serializer_1 = require("./xvm_serializer");
+;
+// 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
+ */
+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 = (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);
+    }
+    /**
+     * 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);
+                (0, xvm_serializer_1.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;
+    }
+}
+exports.Contract = Contract;
+/**
+ * Helper function to create a typed contract instance
+ * This provides better TypeScript support when the ABI is known at compile time
+ */
+function createContract(address, abi) {
+    return new Contract(address, abi);
+}
+exports.createContract = createContract;
+/**
+ * Factory for creating multiple contracts with the same ABI
+ */
+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;
+    }
+}
+exports.ContractFactory = ContractFactory;