New Crowdin updates

docs_es/Dev-Guide/bridge-with-layerzero.md

@@ -0,0 +1,163 @@
+---
+sidebar_label: Bridging Tokens to Core With LayerZero
+hide_table_of_contents: false
+sidebar_position: 2
+---
+
+# Bridging Tokens to Core With LayerZero
+
+--- 
+
+This guide outlines the steps to bridge your ERC-20 token to Core using Omnichain Fungible Tokens (OFT) via LayerZero. LayerZero's protocol enables seamless cross-chain communications, allowing your token to operate across multiple chains. Please refer to LayerZero for all the[ supported source blockchains](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids).
+
+## Overview
+
+Before proceeding, you should be aware of what omnichain fungible tokens and the LayerZero protocol are.&#x20
+
+**Omnichain Fungible Token (OFT)**: Enables the creation of tokens native to multiple chains, simplifying token management and enhancing interoperability.
+
+**LayerZero Protocol**: Serves as foundational technology for cross-chain interactions, providing a reliable method for different blockchains to communicate, ensuring secure and efficient transactions.
+
+## Bridging Existing ERC-20 Tokens to Core
+
+### Deploy LayerZero ProxyOFTV2 Contract on the Source Chain
+
+First, **access the ProxyOFTV2 contract** by retrieving the `ProxyOFTV2` contract code from the[ official repository](https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft/v2/ProxyOFTV2.sol).
+
+Then\*\*, adjust the ProxyOFTV2 contract for the source blockchain\*\*, like this:
+
+```
+constructor(
+        address _token,
+        uint8 _sharedDecimals,
+        address _lzEndpoint
+```
+
+Here's some context on what's present in this code snippet:
+
+- **Token Contract Address** (`_token`): Provide the ERC-20 token contract address for a contract that's already been deployed on the source chain. If your token was USDC on Ethereum, for example, you’d use contract address [0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48](https://etherscan.io/address/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)
+- **Shared Decimals** (`_sharedDecimals`): Set the number of decimal places for the token in the LayerZero environment. The shared decimals normalize the differences between data type across EVM and non-EVM chains. It is a good practice to use a smaller shared decimal point on all chains so that your token can have a larger balance.
+  - If your token is deployed on non-EVM chains, it should be set as the lowest decimals across all chains.
+  - If your tokens are only deployed on EVM chains and all have decimals larger than eight, this value should be set as `8`.
+  - Please refer to this[ LayerZero doc](https://layerzero.gitbook.io/docs/evm-guides/layerzero-omnichain-contracts/oft/oftv2#what-should-i-set-as-shared-decimals) for more info.
+- **LayerZero Endpoint Address for Source Chain** (`_lzEndpoint`): This endpoint address is required for the contract to interact with the LayerZero protocol. For example, Ethereum endpoint: 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675.
+- Please refer to the[ LayerZero documentation](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) for the endpoints for supported blockchains.
+
+Finally, **deploy the `ProxyOFTV2` contract** to the chosen source blockchain.
+
+### Deploy LayerZero OFTV2 Contract on Core Chain
+
+First, **access the OFTV2 contract** by retrieving the `ProxyOFTV2` contract code from the[ official repository](https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft/v2/OFTV2.sol).
+
+\
+Then, **prepare parameters for OFTV2 Contract deployment on Core Chain**, like so:
+
+```
+constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 _sharedDecimals,
+        address _lzEndpoint
+```
+
+Here's some context on what's happening in this code snippet:
+
+- **Token Name** (`_name`): Specify your token name (e.g. USD Coin)
+- **Token Symbol** (`_symbol`): Specify your token symbol (e.g. USDC)
+- **Shared Decimals** (`_sharedDecimals`): Match the shared decimals in the `ProxyOFTV2` on the source chain.
+- **LayerZero Endpoint Address for Core Chain** (`_lzEndpoint`): The endpoint address for Core Chain is `0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4`.
+- Please refer to the[ LayerZero documentation](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) for endpoints of the supported blockchains.
+
+Finally, **deploy the Contract on CoreDAO:** deploy this OFTV2 contract to the Core blockchain.
+
+### Linking Contracts via Trusted Remotes
+
+The term "trusted remote" comes from EVM-to-EVM messaging, and refers to the 40 bytes that identify the contract from which you will receive messages in your LayerZero User Application contract. The 40 bytes object is the packed bytes of the `remoteAddress` and the `localAddress`.
+
+You can generate `TrustedRemote` using `ethers.js`:
+
+```
+// the trusted remote (or sometimes referred to as the path or pathData)
+// is the packed 40 bytes object of the REMOTE + LOCAL user application contract addresses
+
+let trustedRemote = hre.ethers.utils.solidityPack(
+    ['address','address'],
+    [remoteContract.address, localContract.address]
+)
+```
+
+On the source blockchain, call the `ProxyOFTV2` contract's  `setTrustedRemoteAddress` function with the following parameters:
+
+- `trustedRemote`: This is the 40 bytes generated by trusted remote in the previous step
+- `localContract`: This is the source chain’s `ProxyOFTV2` contract address.
+- `remoteContract`: This is the Core chain’s `OFTV2` contract address
+
+On the Core blockchain, call the `OFTV2` contract's `setTrustedRemoteAddress` function with the following parameters:
+
+- `trustedRemote`: This is the 40 bytes generated by trusted remote in the previous step.
+- `localContract`: This is the Core chain’s `OFTV2` contract address.
+- `remoteContract`: This is the source chain’s `ProxyOFTV2` contract address
+
+For more info, please refer to the[ LayerZero guide for setting trusted remotes](https://layerzero.gitbook.io/docs/evm-guides/master/set-trusted-remotes) to link your contracts across the two networks.
+
+### Set Minimum Gas Limit for Each Chain
+
+You'll need to set the minimum gas limit for each chain. It's advisable to use a 200k minimum for all EVM chains; the only major exception is Arbitrum, where the gas limit should be 2M. Here are the steps.
+
+First, call `setMinDstGas` on the source chain (Core’s[ chainId is 153](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids)). Be sure to include the packet type ("0" means send, "1" means send and call) and the gas limit amount.
+
+Then, call `setMinDstGas` on Core Chain with the[ chainId of the source chain](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids). Be sure to include the packet type ("0" meaning send, "1" meaning send and call) and the gas limit amount.
+
+Finally, make sure that your `AdapterParams` gas limit is greater than `setMinDstGas`.
+
+For more info, please refer to the[ LayerZero guide](https://layerzero.gitbook.io/docs/evm-guides/layerzero-omnichain-contracts/oft/oftv2).
+
+### Transfer Tokens Cross-Chain
+
+Here, we'll cover the basic steps involved in transferring tokens across chains.
+
+First, ensure that you have [Node.js](https://nodejs.org/) and [npm](https://www.npmjs.com/) installed.
+
+Then, clone the `oft-transfer-script` repository found [here](https://github.com/LayerZero-Labs/oft-transfer-script/tree/main).
+
+With that done, navigate to the `hardhat` folder in the cloned repository and run `npm install` to install the required npm packages.
+
+Next, create an `.env` file in the root directory of the repository and add the following variables:
+
+- `RPC_ENDPOINT`: This should be the URL of your Ethereum JSON RPC endpoint.
+- `PRIVATE_KEY`: The private key of the Ethereum address you intend to use with the script.&#x20
+
+Here's a code snippet explaining how the `RPC_ENDPOINT` and `PRIVATE_KEY` should be configured:
+
+```
+RPC_ENDPOINT=<Your_RPC_Endpoint_URL> 
+PRIVATE_KEY=<Your__Private_Key>
+```
+
+Finally, run the FT Token Transfer script. This script is designed to interact with the OFT smart contract to facilitate token transfers using `estimateFees()` and `sendFrom()`. Here's a little more context on what these methods accomplish:
+
+- `estimateFees()`: This function provides an estimate of the fees required to send a certain amount of tokens.
+- `sendFrom()`: This function allows you to send tokens from one address on the source blockchain to another on the destination.
+
+Here's a code snippet showing how to transfer tokens with `sendFrom`:&#x20
+
+```
+npx hardhat sendFrom --qty 100000000000000 --network core
+```
+
+### Manual Transfers via Etherscan
+
+If your `ProxyOFT` contract is registered on Etherscan, you can use the Etherscan user interface to transfer your ERC20 tokens manually by calling the `sendFrom()` function with the following parameters:
+
+- `from`: This is the sender’s address on Ethereum.
+- `dstChainId`: LayerZero’s unique chain ID for the receiving chain (we’ll use [chainId 153](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) for Core chain).
+- `toAddress`: The intended recipient’s address on Core chain.
+- `amount`: The number of tokens **in wei units.**
+- `refundAddress`: This is the address where gas refunds will be sent if necessary. It's wise to use the sender’s address as the refund address.
+- `zroAddress`: On Etherscan, the "zero address" is `0x0000000000000000000000000000000000000000`.
+- `adapterParams`: 0x
+- `nativeFee`: you can calculate the native fee by calling the `estimateSendFee` function on the same contract using the same `remoteChainId`, `toAddress`, `amount`, `useZro`, and `adapterParams` above.
+
+## LayerZero Integration Checklist
+
+Please refer to the[ checklist](https://layerzero.gitbook.io/docs/evm-guides/layerzero-integration-checklist) to prepare for a Mainnet deployment.

docs_es/Dev-Guide/contract-verify.md

@@ -0,0 +1,145 @@
+---
+sidebar_label: Contract Verification
+hide_table_of_contents: false
+sidebar_position: 2
+---
+
+# Contract Verification
+
+---
+
+In the interest of transparency, we recommend verifying all contracts on [Core Scan](https://scan.coredao.org/). Let’s check out a few of the common methods for verifying contracts, via the web, API, and Hardhat.
+
+:::note
+Make sure that your smart contract follows the [Solidity Support Guidelines by Core Chain](./smart-contract-guidelines.md), to do so ensure that the `evmVersion` parameter is set to `paris` under the solidity compiler settings.
+:::
+
+## Web Verification via Core Scan
+
+Web verification is the most commonly used smart contract verification strategy. After deploying your smart contract to Core, you can use its source code to verify it on Core Scan.
+
+1. Search for the contract by address on [Core Scan](https://scan.test.btcs.network).
+2. After locating the contract, select the **Contract** tab and click **Verify and Publish**_._
+
+![verify-core-scan](../../static/img/contract-verification/contract-verify-1.avif)
+
+3\. Fill in the required verification information on the page, specifically:
+
+- Contract address;
+- Compiler type: for simple contracts, select the `Single File` compiler type. For more complex contracts, such as contracts with external imports, select the `Standard Json` compiler type;
+- Compiler version;
+- Open-source license type;
+
+![verify-core-scan](../../static/img/contract-verification/contract-verify-2.avif)
+
+4\. On the next page, fill in the contract's Solidity source code.
+
+If your contract has constructor parameters, we recommend adding them in the `Constructor Arguments` field, although it’s not mandatory. The constructor parameters should be formatted as ABI-encoded bytes. Remix and other tools can generate these for you.
+
+If you enabled optimization during contract compilation, select "Yes" for the `Optimization` field.
+
+![verify-contract](../../static/img/contract-verification/contract-verify-3.avif)
+
+5\. Click on **Verify and Publish** to finish the process.
+
+![verify-contract](../../static/img/contract-verification/contract-verify-4.avif)
+
+Now your verified contract on Core Scan should look like this:
+
+![verify-contract](../../static/img/contract-verification/contract-verify-5.avif)
+
+## API Verification
+
+You can find the guide to using the Core API to verify contracts [here](https://docs.coredao.org/docs/api/api-documents/contracts). Please note that to make API calls you must register on Core Scan and generate an API key.
+
+If you're familiar with the Etherscan API, you're in luck! The API calls on Core are 100% compatible with the Etherscan API. You just need to replace the API key and endpoint URL and everything should work properly.
+
+## HardHat Verification
+
+HardHat verification is the most convenient way for developers to verify smart contracts. For more information on Hardhat verification, refer to the official Hardhat verification guide located [here](https://hardhat.org/hardhat-runner/plugins/nomicfoundation-hardhat-verify).
+
+Please note that you’ll need to add Core networks as custom chains, as seen below in a sample HardHat config:
+
+```javascript
+/**
+* @type import('hardhat/config').HardhatUserConfig
+*/
+
+
+const { PrivateKey } = require('./secret.json');
+require('@nomiclabs/hardhat-ethers');
+require("@nomiclabs/hardhat-waffle");
+require("@nomicfoundation/hardhat-verify");
+
+module.exports = {
+  defaultNetwork: 'testnet',
+
+  networks: {
+     hardhat: {
+     },
+     testnet: {
+        url: 'https://rpc.test.btcs.network',
+        accounts: [PrivateKey],
+        chainId: 1115,
+     },
+     mainnet: {
+       url: 'https://rpc.coredao.org',
+       accounts: [PrivateKey],
+       chainId: 1116,
+    },
+  },
+  etherscan: {
+   apiKey: {
+     testnet: "api key",
+     mainnet: "api key"
+   },
+   customChains: [
+     {
+       network: "testnet",
+       chainId: 1115,
+       urls: {
+         apiURL: "https://api.test.btcs.network/api",
+         browserURL: "https://scan.test.btcs.network/"
+       }
+     },
+     {
+       network: "mainnet",
+       chainId: 1116,
+       urls: {
+         apiURL: "https://openapi.coredao.org/api",
+         browserURL: "https://scan.coredao.org/"
+       }
+     }
+   ]
+ },
+
+  solidity: {
+     compilers: [
+       {
+          version: '0.8.9',
+          settings: {
+             optimizer: {
+                enabled: false,
+                runs: 200,
+             },
+          },
+       }
+     ],
+  },
+  paths: {
+     sources: './contracts',
+     cache: './cache',
+     artifacts: './artifacts',
+  },
+  mocha: {
+     timeout: 20000,
+  },
+};
+
+```
+
+## Known Limitations
+
+- Currently Core only supports solc compiler versions up to 0.8.19.
+- Libraries are not supported using API verifications.
+- If you run into issues verifying very large (1000+ lines) single file contracts, we recommend switching to `Standard JSON` format for verification.