npm install ethers

const { ethers } = require('ethers');

// Global configuration
let config = {
    baseURL: 'https://rpc.testnet.alchemychain.com',
    privateKey: ''
};

// Configure API endpoint and private key
function Config(url, key) {
    config.baseURL = url;
    config.privateKey = key;
}

// Unified signature method (supports array parameter handling)
function generateSignature(params) {
    const sortedKeys = Object.keys(params).sort();
    const messageParts = [];

    for (const key of sortedKeys) {
        const value = params[key];

        if (value == null) {
            continue;
        }

        if (Array.isArray(value)) {
            if (value.length > 0) {
                const arrayElements = value
                    .filter(element => element != null)
                    .map(element => String(element));
                messageParts.push(...arrayElements);
            }
        } else {
            const formattedValue = String(value);
            messageParts.push(formattedValue);
        }
    }
    const message = messageParts.join(',');

    const messageBytes = ethers.toUtf8Bytes(message);
    const messageHash = ethers.keccak256(messageBytes);

    // Ensure the private key has 0x prefix
    let privateKey = config.privateKey;
    if (!privateKey.startsWith('0x')) {
        privateKey = '0x' + privateKey;
    }

    const wallet = new ethers.Wallet(privateKey);
    const signature = wallet.signingKey.sign(messageHash);

    return {
        r: ethers.getBigInt(signature.r).toString(),
        s: ethers.getBigInt(signature.s).toString(),
        v: signature.v.toString()
    };
}

// Create response object (supports method chaining)
function createResponse(data, error) {
    return {
        success: function(callback) {
            if (!error && data) {
                callback(data);
            }
            return this;
        },
        error: function(callback) {
            if (error) {
                callback(error);
            }
            return this;
        }
    };
}

// Example usage - Token creation
const createTokenParams = {
    decimals: 8,
    masterAuthority: "0xa6459EF31C68DCF46cC603C526526DB1C6eE4fD1",
    name: "My Token",
    nonce: 0,
    recentCheckpoint: 12345,
    symbol: "MTK"
};
const createTokenSignature = generateSignature(createTokenParams);

// Example usage - Dynamic call (includes array parameters)
const mintParams = {
    methodArgs: ["0x1234567890123456789012345678901234567890", "1000000000000000000"],
    nonce: 1,
    recentCheckpoint: 12346,
    token: "0x1234567890123456789012345678901234567890"
};
const mintSignature = generateSignature(mintParams);

// Actual API call example
async function CreateToken(name, symbol, decimals, masterAuthority) {
    try {
        const blockNum = await getBlockNumber();
        const nonce = 0;

        const params = {
            decimals: decimals,
            masterAuthority: masterAuthority,
            name: name,
            nonce: nonce,
            recentCheckpoint: blockNum,
            symbol: symbol
        };
        const signature = generateSignature(params);

        const reqParams = {
            decimals: decimals,
            masterAuthority: masterAuthority,
            name: name,
            symbol: symbol,
            nonce: nonce,
            recentCheckpoint: blockNum,
            signature: signature
        };
        const result = await rpcCall("create_token", reqParams);
        return createResponse(result, null);
    } catch (error) {
        return createResponse(null, error);
    }
}