# Function insights This page provides a behind-the-scenes look at the text-based token minting and contract deployment processes within the Xyxyx API. We will illustrate how the [Ethers v6 Library](https://docs.ethers.org/v6/getting-started/) is used under the hood, and why the wallet private key is critical to sign transactions autonomously — allowing calls to be made without user interaction via a front-end. *** #### Overview By leveraging Ethers, the API can: 1. **Connect to the blockchain** via a provider (e.g., `ethers.JsonRpcProvider`). 2. **Create a wallet** (signer) using the private key that you provide in each request. 3. **Deploy contracts** through the `ContractFactory`. 4. **Mint tokens** by calling contract methods. Because the private key is included with every request (rather than stored server-side), you remain fully responsible for its confidentiality. However, this design still allows an entirely automated flow for contract deployment and token minting, without interactive wallet confirmations. *** #### Mint Token ```js const { ethers } = require("ethers"); const contractAbi = require("../utils/ERC-721F/abi.json"); // Load the contract const contract = new ethers.Contract(contractAddress, contractAbi, wallet); // Mint cost in wei (10000000000 WEI === 0.00000001 ETH) const weiCost = ethers.parseUnits(mintCost.toString(), "wei"); // Execute the mint function on the contract const tx = await contract.mint(tokenId, svgBody, { value: weiCost }); // Wait for the transaction to be mined const receipt = await tx.wait(); ``` **Explanation** 1. **Import Ethers:**\ Using `require("ethers")` imports the core Ethers library. 2. **Load Contract ABI:**\ The ABI (Application Binary Interface) `abi.json` describes the functions, events, and error signatures of the ERC-721F contract. It allows Ethers to understand how to encode calls to `mint()` and decode contract responses. 3. **Create Contract Instance:** ```js const contract = new ethers.Contract(contractAddress, contractAbi, wallet); ``` * `contractAddress` is the on-chain address of the deployed contract. * `contractAbi` is the ABI loaded from the JSON file. * `wallet` is an instance of `ethers.Wallet`, which includes the private key (provided by the user in the request) and a provider. * Passing the `wallet` as the third parameter ensures that all contract calls are signed by the wallet. 4. **Calculate Mint Cost in Wei:** ```js const weiCost = ethers.parseUnits(mintCost.toString(), "wei"); ``` * `ethers.parseUnits()` converts a string or numeric value into a **BigInt** representing the smallest unit (in this case, wei). * This is crucial for Ethereum transactions, which require values in wei rather than ETH. 5. **Call the Mint Function:** ```js const tx = await contract.mint(tokenId, svgBody, { value: weiCost }); ``` * `mint(tokenId, svgBody, { value: weiCost })` executes the smart contract’s `mint()` method. * The `value` field indicates how much Ether (in wei) to send along with the transaction. * Behind the scenes, the wallet signs this transaction, requiring no additional user confirmation beyond providing the private key up front. 6. **Await Transaction Confirmation:** ```js const receipt = await tx.wait(); ``` * Ethers `wait()` method suspends execution until the transaction is mined on the blockchain. * The returned `receipt` includes details like block number, gas used, and transaction status. **Reference Material** * [Contracts in Ethers v6](https://docs.ethers.org/v6/getting-started/#contracts) * [Signers and Wallets](https://docs.ethers.org/v6/getting-started/#accounts) *** #### Deploy Smart Contract ```js // Create the ContractFactory const factory = new ethers.ContractFactory(deployData.abi, deployData.bytecode, wallet); // Deploy the contract with the given parameters const contractFactory = await factory.deploy(name, ticker, parseInt(supply), mintPrice, onlyOwnerMint); // Wait for the contract to be mined await contractFactory.deploymentTransaction().wait(); // Retrieve the deployed contract address const contractAddress = await contractFactory.getAddress(); const deploymentHash = await contractFactory.deploymentTransaction().hash; ``` **Explanation** 1. **Initialize ContractFactory:** ```js const factory = new ethers.ContractFactory(deployData.abi, deployData.bytecode, wallet); ``` * `deployData.abi` is the ABI for the contract being deployed. * `deployData.bytecode` contains the compiled contract bytecode. * The `wallet` signer is provided by the user on each request and used to sign the deployment transaction. 2. **Deploy the Contract:** ```js const contractFactory = await factory.deploy(name, ticker, parseInt(supply), mintPrice, onlyOwnerMint); ``` * `factory.deploy(...)` sends a transaction to create a new contract on-chain. * The parameters (`name`, `ticker`, `supply`, `mintPrice`, `onlyOwnerMint`) are passed to the constructor of the contract. * Under the hood, Ethers automatically calculates the gas limit and constructs the transaction data required for deployment. 3. **Await Mining:** ```js await contractFactory.deploymentTransaction().wait(); ``` * Similar to the mint example, this waits until the deployment transaction is confirmed. * Once confirmed, the contract is live on the blockchain. 4. **Obtain Deployment Details:** ```js const contractAddress = await contractFactory.getAddress(); const deploymentHash = await contractFactory.deploymentTransaction().hash; ``` * `getAddress()` retrieves the newly deployed contract address. * `deploymentTransaction().hash` gives the transaction hash of the deploy transaction. * These details can be used for logging, user notifications, or subsequent on-chain interactions. **Reference Material** * [Contract Factories in Ethers v6](https://docs.ethers.org/v6/getting-started/#contracts%E2%80%93contractfactory) * [Transaction Lifecycle](https://docs.ethers.org/v6/getting-started/#transactions) *** #### Why the private key is necessary? * **Automatic signing:** Without the private key provided in each request, every transaction would require interactive approval from a front-end wallet (e.g., MetaMask). This manual process is not suitable for automated or large-scale operations. * **Autonomous execution:** Including the private key in the API call allows the service to sign and broadcast transactions programmatically, enabling continuous, unattended minting and deployment. *** #### Security & Custody * **User responsibility:** The Xyxyx API does not store or persist your private key. You are required to provide the private key each time you make a request. As a result, you have full responsibility for its security. * **Protecting your key:** If your private key is compromised, unauthorized transactions could be performed on your behalf. Always use secure channels and best practices when transmitting private keys. * **No server-side sustody:** Since the API does not manage or retain your private key, there is no server-side wallet custody. Every signed transaction is generated by you, on demand, within each request. *** #### Summary By integrating Ethers v6 and requiring the wallet private key on every request, the Xyxyx API lets you deploy contracts or mint tokens without building a separate front-end signing flow. This approach empowers full autonomy while keeping private key custody in your hands. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://developer.xyxyx.pro/utilities/function-insights.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.