diff --git a/docs_es/Dev-Guide/bridge-with-layerzero.md b/docs_es/Dev-Guide/bridge-with-layerzero.md new file mode 100644 index 0000000000..6ec2fdfceb --- /dev/null +++ b/docs_es/Dev-Guide/bridge-with-layerzero.md @@ -0,0 +1,162 @@ +--- +sidebar_label: Puentear Tokens a Core con una Layer zero +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Puentear Tokens a Core con una Layer zero + +--- + +Esta guia alinea los pasos para puentear tu token ERC-20 a Core utilizando Omnichains Tokens Fungibles mediante una Layer Zero. El protocolo LayerZero empodera comunicaciones sin ficción cross-chain, así dejando a tus tokens operar a través múltiples cadenas. Por favor refiera a la LayerZero para ver todas las cacdenas de bloques soportadas (https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids). + +## Descripción general + +Antes de continuar, debes saber qué son los tokens fungibles omnichain y el protocolo LayerZero + +**Omnichain Fungible Token (OFT)**: permite la creación de tokens nativos de múltiples cadenas, simplificando la gestión de tokens y mejorando la interoperabilidad. + +**Protocolo LayerZero**: sirve como tecnología fundamental para interacciones entre cadenas, proporcionando un método confiable para que diferentes cadenas de bloques se comuniquen, garantizando transacciones seguras y eficientes. + +## Puentiando los tokens ERC-20 existentes a Core + +### Implementar el contrato LayerZero ProxyOFTV2 en la cadena de origen + +Primero, **acceda al contrato ProxyOFTV2** recuperando el código del contrato `ProxyOFTV2` del[repositorio oficial](https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft /v2/ProxyOFTV2.sol). + +Luego\*\*, ajuste el contrato ProxyOFTV2 para la cadena de bloques de origen\*\*, así: + +``` +constructor( + address _token, + uint8 _sharedDecimals, + address _lzEndpoint +``` + +Aquí hay algo de contexto sobre lo que está presente en este fragmento de código: + +- **Dirección del contrato del token** (`_token`): proporcione la dirección del contrato del token ERC-20 para un contrato que ya se ha implementado en la cadena de origen. Si su token fuera USDC en Ethereum, por ejemplo, usaría la dirección del contrato [0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48](https://etherscan.io/address/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) +- **Decimals compartidos** (`_sharedDecimals`): establece el número de decimales para el token en el entorno LayerZero. Los decimales compartidos normalizan las diferencias entre los tipos de datos entre cadenas EVM y no EVM. Es una buena práctica utilizar un punto decimal compartido más pequeño en todas las cadenas para que su token pueda tener un saldo mayor. + - Si su token se implementa en cadenas que no son EVM, debe configurarse con los decimales más bajos en todas las cadenas. + - Si sus tokens solo se implementan en cadenas EVM y todos tienen decimales mayores que ocho, este valor debe establecerse como "8". + - Consulte este [documento LayerZero](https://layerzero.gitbook.io/docs/evm-guides/layerzero-omnichain-contracts/oft/oftv2#what-should-i-set-as-shared-decimals) para más información. +- **Dirección de punto final de LayerZero para la cadena de origen** (`_lzEndpoint`): esta dirección de punto final es necesaria para que el contrato interactúe con el protocolo LayerZero. Por ejemplo, punto final de Ethereum: 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675. +- Consulte la [documentación de LayerZero] (https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) para conocer los puntos finales de las cadenas de bloques compatibles. + +Finalmente, **implemente el contrato `ProxyOFTV2`** en la cadena de bloques de origen elegida. + +### Implementar el contrato OFTV2 LayerZero en la cadena central + +Primero, **acceda al contrato OFTV2** recuperando el código del contrato `ProxyOFTV2` del[repositorio oficial](https://github.com/LayerZero-Labs/solidity-examples/blob/main/contracts/token/oft /v2/OFTV2.sol). + +Luego, **prepare los parámetros para la implementación del contrato OFTV2 en Core Chain**, así: + +``` +constructor( + string memory _name, + string memory _symbol, + uint8 _sharedDecimals, + address _lzEndpoint +``` + +Aquí hay algo de contexto sobre lo que está sucediendo en este fragmento de código: + +- **Nombre del token** (`_name`): especifique el nombre de su token (por ejemplo, moneda USD) +- **Símbolo de token** (`_symbol`): especifique su símbolo de token (por ejemplo, USDC) +- **Decimals compartidos** (`_sharedDecimals`): haga coincidir los decimales compartidos en `ProxyOFTV2` en la cadena de origen. +- **Dirección de punto final LayerZero para Core Chain** (`_lzEndpoint`): La dirección de punto final para Core Chain es `0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4`. +- Consulte la [documentación de LayerZero](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) para conocer los puntos finales de las cadenas de bloques compatibles. + +Finalmente, **implemente el contrato en CoreDAO:** implemente este contrato OFTV2 en la cadena de bloques Core. + +### Vincular contratos a través de controles remotos confiables + +El término "remoto confiable" proviene de la mensajería de EVM a EVM y se refiere a los 40 bytes que identifican el contrato del cual recibirá mensajes en su contrato de aplicación de usuario LayerZero. El objeto de 40 bytes son los bytes empaquetados de `remoteAddress` y `localAddress`. + +Puede generar `TrustedRemote` usando `ethers.js`: + +``` +// el control remoto confiable (o a veces denominado ruta o pathData) +// es el objeto empaquetado de 40 bytes de las direcciones del contrato de aplicación de usuario REMOTA + LOCAL + +let trustedRemote = hre.ethers.utils.solidityPack( + ['address','address'], + [remoteContract.address, localContract.address] +) +``` + +En la cadena de bloques de origen, llame a la función `setTrustedRemoteAddress` del contrato `ProxyOFTV2` con los siguientes parámetros: + +- `trustedRemote`: Estos son los 40 bytes generados por el control remoto confiable en el paso anterior +- `localContract`: esta es la dirección del contrato `ProxyOFTV2` de la cadena de origen. +- `remoteContract`: esta es la dirección del contrato `OFTV2` de la cadena Core + +En la cadena de bloques Core, llame a la función `setTrustedRemoteAddress` del contrato `OFTV2` con los siguientes parámetros: + +- `trustedRemote`: Estos son los 40 bytes generados por el control remoto confiable en el paso anterior. +- `localContract`: esta es la dirección del contrato `OFTV2` de la cadena Core. +- `remoteContract`: esta es la dirección del contrato `ProxyOFTV2` de la cadena de origen + +Para obtener más información, consulte la [guía LayerZero para configurar controles remotos confiables](https://layerzero.gitbook.io/docs/evm-guides/master/set-trusted-remotes) para vincular sus contratos entre las dos redes. + +### Establecer límite mínimo de gas para cada cadena + +Deberá establecer el límite mínimo de gas para cada cadena. Es recomendable utilizar un mínimo de 200k para todas las cadenas EVM; la única excepción importante es Arbitrum, donde el límite de gas debería ser 2M. Aquí están los pasos. + +Primero, llame a `setMinDstGas` en la cadena de origen (Core [chainId es 153] (https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids)). Asegúrese de incluir el tipo de paquete ("0" significa enviar, "1" significa enviar y llamar) y la cantidad límite de gasolina. + +Luego, llame a `setMinDstGas` en Core Chain con el [chainId de la cadena de origen] (https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids). Asegúrese de incluir el tipo de paquete ("0" significa enviar, "1" significa enviar y llamar) y la cantidad límite de gasolina. + +Finalmente, asegúrese de que su límite de gas `AdapterParams` sea mayor que `setMinDstGas`. + +Para obtener más información, consulte la [guía LayerZero](https://layerzero.gitbook.io/docs/evm-guides/layerzero-omnichain-contracts/oft/oftv2). + +### Transferir tokens entre cadenas + +Aquí, cubriremos los pasos básicos involucrados en la transferencia de tokens entre cadenas. + +Primero, asegúrese de tener [Node.js](https://nodejs.org/) y [npm](https://www.npmjs.com/) instalados. + +Luego, clone el repositorio `oft-transfer-script` que se encuentra [aquí](https://github.com/LayerZero-Labs/oft-transfer-script/tree/main). + +Una vez hecho esto, navegue hasta la carpeta `hardhat` en el repositorio clonado y ejecute `npm install` para instalar los paquetes npm requeridos. + +A continuación, cree un archivo `.env` en el directorio raíz del repositorio y agregue las siguientes variables: + +- `RPC_ENDPOINT`: esta debe ser la URL de su punto final Ethereum JSON RPC. +- `PRIVATE_KEY`: la clave privada de la dirección de Ethereum que desea utilizar con el script. + +Aquí hay un fragmento de código que explica cómo se deben configurar `RPC_ENDPOINT` y `PRIVATE_KEY`: + +``` +RPC_ENDPOINT= +PRIVATE_KEY= +``` + +Finalmente, ejecute el script FT Token Transfer. Este script está diseñado para interactuar con el contrato inteligente OFT para facilitar las transferencias de tokens usando `estimateFees()` y `sendFrom()`. Aquí hay un poco más de contexto sobre lo que logran estos métodos: + +- `estimateFees()`: Esta función proporciona una estimación de las tarifas requeridas para enviar una determinada cantidad de tokens. +- `sendFrom()`: Esta función le permite enviar tokens desde una dirección en la cadena de bloques de origen a otra en el destino. + +Aquí hay un fragmento de código que muestra cómo transferir tokens con `sendFrom`: + +``` +npx hardhat sendFrom --qty 100000000000000 --network core +``` + +### Transferencias manuales a través de Etherscan + +Si su contrato `ProxyOFT` está registrado en Etherscan, puede usar la interfaz de usuario de Etherscan para transferir sus tokens ERC20 manualmente llamando a la función `sendFrom()` con los siguientes parámetros: + +- `de`: esta es la dirección del remitente en Ethereum. +- `dstChainId`: ID de cadena único de LayerZero para la cadena receptora (usaremos [chainId 153](https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids) para la cadena Core). +- `toAddress`: la dirección del destinatario previsto en la cadena Core. +- `cantidad`: El número de tokens **en unidades wei.** +- `refundAddress`: Esta es la dirección donde se enviarán los reembolsos de gasolina si es necesario. Es aconsejable utilizar la dirección del remitente como dirección de reembolso. +- `zroAddress`: en Etherscan, la "dirección cero" es `0x00000000000000000000000000000000000000000`. +- `adapterParams`: 0x +- `nativeFee`: puede calcular la tarifa nativa llamando a la función `estimateSendFee` en el mismo contrato usando los mismos `remoteChainId`, `toAddress`, `amount`, `useZro` y `adapterParams` anteriores. + +## Lista de verificación de integración LayerZero + +Consulte la [lista de verificación] (https://layerzero.gitbook.io/docs/evm-guides/layerzero-integration-checklist) para prepararse para una implementación de Mainnet. diff --git a/docs_es/Dev-Guide/contract-verify.md b/docs_es/Dev-Guide/contract-verify.md new file mode 100644 index 0000000000..e403a409e2 --- /dev/null +++ b/docs_es/Dev-Guide/contract-verify.md @@ -0,0 +1,145 @@ +--- +sidebar_label: Verificación de Contrato +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Verificación de Contrato + +--- + +En el interés de la transparencia, nosotros recomendamos verificar todos los contratos en [Core Scan](https://scan.coredao.org/). Veamos algunos de los métodos comunes para verificar contratos, a través de la web, API y Hardhat. + +:::note +Asegúrese de que su contrato inteligente siga las [Pautas de soporte de solidez de Core Chain] (./smart-contract-guidelines.md). Para ello, asegúrese de que el parámetro `evmVersion` esté establecido en `paris` en la configuración del compilador de solidity. +::: + +## Verificación web mediante Core Scan + +La verificación web es la estrategia de verificación de contratos inteligentes más utilizada. Después de implementar su contrato inteligente en Core, puede usar su código fuente para verificarlo en Core Scan. + +1. Busque el contrato por dirección en [Core Scan](https://scan.test.btcs.network). +2. Después de ubicar el contrato, seleccione la pestaña **Contrato** y haga clic en **Verificar y publicar**_._ + +![verify-core-scan](../../static/img/contract-verification/contract-verify-1.avif) + +3\. Complete la información de verificación requerida en la página, específicamente: + +- Dirección del contrato; +- Tipo de compilador: para contratos simples, seleccione el tipo de compilador "Archivo único". Para contratos más complejos, como contratos con importaciones externas, seleccione el tipo de compilador "Standard Json"; +- Versión del compilador; +- Tipo de licencia de código abierto; + +![verify-core-scan](../../static/img/contract-verification/contract-verify-2.avif) + +4\. En la página siguiente, complete el código fuente de Solidity del contrato. + +Si su contrato tiene parámetros de constructor, le recomendamos agregarlos en el campo "Argumentos del constructor", aunque no es obligatorio. Los parámetros del constructor deben tener el formato de bytes codificados en ABI. Remix y otras herramientas pueden generarlos por usted. + +Si habilitó la optimización durante la compilación del contrato, seleccione "Sí" para el campo "Optimización". + +![verify-contract](../../static/img/contract-verification/contract-verify-3.avif) + +5\. Haga clic en **Verificar y publicar** para finalizar el proceso. + +![verify-contract](../../static/img/contract-verification/contract-verify-4.avif) + +Ahora su contrato verificado en Core Scan debería verse así: + +![verify-contract](../../static/img/contract-verification/contract-verify-5.avif) + +## Verificación API + +Puede encontrar la guía sobre el uso de Core API para verificar contratos [aquí](https://docs.coredao.org/docs/api/api-documents/contracts). Tenga en cuenta que para realizar llamadas API debe registrarse en Core Scan y generar una clave API. + +Si estás familiarizado con la API de Etherscan, ¡estás de suerte! Las llamadas API en Core son 100% compatibles con la API de Etherscan. Solo necesita reemplazar la clave API y la URL del punto final y todo debería funcionar correctamente. + +## Verificación de HardHat + +La verificación HardHat es la forma más conveniente para que los desarrolladores verifiquen contratos inteligentes. Para obtener más información sobre la verificación de Hardhat, consulte la guía oficial de verificación de Hardhat que se encuentra [aquí](https://hardhat.org/hardhat-runner/plugins/nomicfoundation-hardhat-verify). + +Tenga en cuenta que deberá agregar redes Core como cadenas personalizadas, como se ve a continuación en una configuración de ejemplo de HardHat: + +```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, + }, +}; + +``` + +## Limitaciones conocidas + +- Actualmente, Core solo admite versiones del compilador solc hasta 0.8.19. +- Las bibliotecas no son compatibles con las verificaciones API. +- Si tiene problemas al verificar contratos de un solo archivo muy grandes (más de 1000 líneas), le recomendamos cambiar al formato "JSON estándar" para la verificación. diff --git a/docs_es/Dev-Guide/core-bridge-resources.md b/docs_es/Dev-Guide/core-bridge-resources.md new file mode 100644 index 0000000000..d7af8fb8f5 --- /dev/null +++ b/docs_es/Dev-Guide/core-bridge-resources.md @@ -0,0 +1,80 @@ +--- +sidebar_label: Recursos del puente Core +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Recursos del puente Core + +--- + +El [Core Bridge](https://bridge.coredao.org/) funciona con LayerZero y permite transferencias de activos fluidas entre Core y el mundo blockchain en general. Core Bridge consta de dos partes: contratos LayerZero en Core que facilitan las transferencias entre cadenas y un conjunto de contratos puente o token implementados tanto en Core como en cada blockchain a la que está conectado. El código base del puente auditado se puede encontrar [aquí](https://github.com/LayerZero-Labs/wrapped-asset-bridge), y la lista completa de direcciones de contrato de tokens de puente se puede encontrar [aquí](./core- bridge-resources.md). + +### LayerZero + +| Contratos LayerZero en Core | +| ------------------------------------------------------------------------------------------------- | +| [LayerZero Endpoint](https://scan.coredao.org/address/0x9740ff91f1985d8d2b71494ae1a2f723bb3ed9e4) | +| [UltraLightNodeV2](https://scan.coredao.org/address/0x66a71dcef29a0ffbdbe3c6a460a3b5bc225cd675) | +| [NonceContract](https://scan.coredao.org/address/0x2d61dcdd36f10b22176e0433b86f74567d529aaa) | +| [FPValidator](https://scan.coredao.org/address/0x3c2269811836af69497e5f486a85d7316753cf62) | +| [MPTValidatorV1](https://scan.coredao.org/address/0xb6319cc6c8c27a8f5daf0dd3df91ea35c4720dd7) | +| [TreasuryV2](https://scan.coredao.org/address/0x5b19bd330a84c049b62d5b0fc2ba120217a18c1c) | + +### Bridges y Tokens + +| CORE | Direcciones | +| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | +| WrappedTokenBridge | https://scan.coredao.org/address/0xa4218e1f39da4aadac971066458db56e901bcbde | +| WETH | https://scan.coredao.org/address/0xeab3ac417c4d6df6b143346a46fee1b847b50296 | +| USDC | https://scan.coredao.org/address/0xa4151b2b3e269645181dccf2d426ce75fcbdeca9 | +| USDT | https://scan.coredao.org/address/0x900101d06a7426441ae63e9ab3b9b0f63be145f1 | +| WBTC | https://scan.coredao.org/address/0x5832f53d147b3d6Cd4578B9CBD62425C7ea9d0Bd | +| Bitcoin BEP2 (BTCB) | https://scan.coredao.org/address/0x7A6888c85eDBA8E38F6C7E0485212da602761C08 | +| WBNB | https://scan.coredao.org/address/0xdFBc618d3c48e553Cb197F42482A0795bef7fe28 | +| stCORE | https://scan.coredao.org/token/0xb3a8f0f0da9ffc65318aa39e55079796093029ad | + +| ETHEREUM | Direcciones | +| ------------------- | ------------------------------------------------------------------------------------------------------- | +| OriginalTokenBridge | https://etherscan.io/address/0x52e75d318cfb31f9a2edfa2dfee26b161255b233 | +| WETH | https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 | +| USDC | https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 | +| USDT | https://etherscan.io/address/0xdac17f958d2ee523a2206206994597c13d831ec7 | +| WBTC | https://etherscan.io/address/0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599 | + +| BNB Smart Chain (BSC) | Direcciones | +| ---------------------------------------- | ------------------------------------------------------------------------------------------------------ | +| OriginalTokenBridge | https://bscscan.com/address/0x52e75d318cfb31f9a2edfa2dfee26b161255b233 | +| USDC | https://bscscan.com/address/0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d | +| USDT | https://bscscan.com/address/0x55d398326f99059ff775485246999027b3197955 | +| BTCB | 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c | +| WBNB | 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c | + +| Polygon | Direcciones | +| ------------------- | ---------------------------------------------------------------------------------------------------------- | +| OriginalTokenBridge | https://polygonscan.com/address/0x52e75d318cfb31f9a2edfa2dfee26b161255b233 | +| USDC | https://polygonscan.com/address/0x2791bca1f2de4661ed88a30c99a7a9449aa84174 | +| USDT | https://polygonscan.com/address/0xc2132d05d31c914a87c6611c10748aeb04b58e8f | +| WBTC | https://polygonscan.com/address/0xc2132d05d31c914a87c6611c10748aeb04b58e8f | + +| BNB Smart Chain (BSC) | Direcciones | +| ---------------------------------------- | ------------------------------------------ | +| Puente | 0x29d096cD18C0dA7500295f082da73316d704031A | +| USDC | 0xaf88d065e77c8cC2239327C5EDb3A432268e5831 | +| USDT | 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9 | +| WBTC | 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f | + +| OPTIMISM | Direcciones | +| -------- | ------------------------------------------ | +| Puente | 0x29d096cD18C0dA7500295f082da73316d704031A | +| USDC | 0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85 | +| USDT | 0x94b008aA00579c1307B0EF2c499aD98a8ce58e58 | +| WBTC | 0x68f180fcCe6836688e9084f035309E29Bf0A2095 | + +| AVALANCHE | Direcciones | +| -------------------------------------------------------------------- | ------------------------------------------ | +| Puente | 0x29d096cD18C0dA7500295f082da73316d704031A | +| Bitcoin Avalanche Bridged (BTC.b) | 0x2297aEbD383787A160DD0d9F71508148769342E3 | +| USDC | 0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E | +| USDT | 0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7 | +| WBTC | 0x50b7545627a5162F82A992c33b87aDc75187B218 | diff --git a/docs_es/Dev-Guide/core-explorer.md b/docs_es/Dev-Guide/core-explorer.md new file mode 100644 index 0000000000..f42996d7d8 --- /dev/null +++ b/docs_es/Dev-Guide/core-explorer.md @@ -0,0 +1,28 @@ +--- +sidebar_label: Explorador Core +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Explorador de cadena de bloques de Core Scan + +--- + +Core Explorer es una interfaz gráfica de usuario diseñada para permitir a los usuarios interactuar con la cadena de bloques CORE. A través de esta interfaz, un usuario puede buscar información sobre los bloques que se han agregado a la cadena de bloques, las transacciones que se han producido en la cadena de bloques, los saldos de la billetera y la información sobre tCORE y los tokens CORE. Core Network proporciona exploradores tanto para su red principal como para su red de prueba. + +### Exploradores para Red de Prueba + +- https://scan.test.btcs.network + +### Exploradores para Red Principal + +- https://scan.coredao.org/ + +### Usando el Explorador + +Puede utilizar el explorador de cadena de bloques Testnet Core Scan para buscar y revisar transacciones. Copie la dirección de su cuenta de MetaMask y búsquela en el explorador. En la siguiente imagen podemos ver dos transacciones relacionadas con nuestra cuenta: + +- Aquel en el que obtuvimos tCORE de Faucet; +- Aquel en el que enviamos tCORE a otra dirección; + +![núcleo-explorador](../../static/img/core-explorer.png) diff --git a/docs_es/Dev-Guide/core-faucet.md b/docs_es/Dev-Guide/core-faucet.md new file mode 100644 index 0000000000..fd686bf8d6 --- /dev/null +++ b/docs_es/Dev-Guide/core-faucet.md @@ -0,0 +1,27 @@ +--- +sidebar_label: Core Testnet Faucet +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Core Testnet Faucet + +--- + +Para ayudar a los usuarios a comenzar y permitir a los desarrolladores crear rápidamente prototipos de sus dApps, Core ha lanzado el [Core Testnet Faucet] público (https://scan.test.btcs.network/faucet) para distribuir tokens de Core testnet, **tCORE**. + +## Pasos para obtener tCORE de Core Testnet Faucet + +1. Navegue hasta el sitio web [faucet](https://scan.test.btcs.network/faucet). +2. Pegue su dirección en el cuadro de texto proporcionado. Asegúrese de proporcionar la dirección Core Testnet de su billetera que desea recibir fondos con tCore. +3. Completa el CAPTCHA +4. Haga clic en el botón "Get tCORE". Después de solicitar tCORE desde el faucet, verá aumentar su saldo de MetaMask. + +![usando-grifo](../../static/img/faucet/faucet.png) +:::precaución +Cada dirección puede solicitar **sólo un tCORE por día**. Si te quedaste sin tCORE y el grifo no te envía más debido al límite diario de un tCORE, ¡vuelve mañana e inténtalo de nuevo! +::: + +:::note +tCORE solo se usa para pruebas y no tiene ningún valor. No lo utilice para transacciones financieras reales. +::: diff --git a/docs_es/Dev-Guide/core-mainnet-wallet-config.md b/docs_es/Dev-Guide/core-mainnet-wallet-config.md new file mode 100644 index 0000000000..7fd5f33007 --- /dev/null +++ b/docs_es/Dev-Guide/core-mainnet-wallet-config.md @@ -0,0 +1,117 @@ +--- +sidebar_label: Core Chain Mainnet +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Conectarse a Core Chain Mainnet + +--- + +:::note +Esta es una guía detallada para conectarse a Core Mainnet utilizando la billetera MetaMask. +::: + +## Requisitos previos del software + +1. [Extensión del navegador MetaMask Wallet](https://metamask.io/) + +## Configuración de la billetera MetaMask + +Recomendamos utilizar la [billetera web MetaMask](https://metamask.io/) para conectarse a Core Mainnet. Deberá instalar MetaMask y configurar su cuenta antes de poder usarla para conectarse a Core Mainnet. Puede encontrar las instrucciones de configuración de MetaMask aquí. + +## Agregar Core Mainnet a MetaMask + +Hay varias formas de agregar configuraciones de Core Mainnet a su MetaMask Wallet; a continuación, enumeramos las formas más confiables y probadas. + +### Agregar red manualmente + +1. Haga clic en el botón selector de red (la flecha hacia abajo al lado de la red actual). Esto mostrará una lista de redes a las que ya estás conectado. + + + +2. Haga clic en "Agregar red" en la parte inferior de la lista de redes + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-2.webp) + +3. Luego se abrirá una nueva pestaña del navegador, mostrando varios campos para completar: + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-3.webp) + +Complete la siguiente información de la red y haga clic en "guardar" para agregar la red. + +- **Nombre de la red:** Core Blockchain +- **Nueva URL de RPC:** https://rpc.ankr.com/core +- **ID de cadena:** 1116 (**Nota**: 0x45c es lo mismo que 1116. La nueva versión de MetaMask convierte el ID de cadena al formato hexadecimal). +- **Símbolo de moneda:** CORE +- **URL del Explorador de bloques:** https://scan.coredao.org + +4. Después de realizar los pasos anteriores, podrás ver la red Core la próxima vez que accedas al selector de redes. + +### Agregar la red central a través de Chainlist.org + +1. Vaya a chainlist.org y busque '_Core_' + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-4.webp) + +2. Verifique dos veces para asegurarse de elegir la red correcta. Verifique los detalles en las siguientes instantáneas: ID de cadena, moneda, etc. para asegurarse de agregar la correcta. + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-6.webp) + +3. Haga clic en el botón '_Agregar a MetaMask_'. + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-7.webp) + +4. Apruebe la acción en su MetaMask haciendo clic en el botón _'Aprobar'_. + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-8.webp) + +La red Core ahora está agregada a su MetaMask. + +### Agregar la red Core a través de Core Explorer + +1. Vaya a https://scan.coredao.org/ y desplácese hacia abajo en la página + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-9.webp) + +2. Haga clic en el botón '_Agregar red principal_' + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-10.webp) + +3. Aprobar en tu MetaMask + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-11.webp) + +4. Después de realizar los pasos anteriores, podrás ver la red principal la próxima vez que accedas al selector de red. + +### Agregar la red Core a la billetera móvil MetaMask: + +1. Toca las tres líneas en la esquina superior izquierda: + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-12.webp) + +2. Seleccione _'Configuración'_: + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-13.webp) + +3. Seleccionar redes: + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-14.webp) + +4. Toque '_Agregar red_': + +![metmask-mainnet](../../static/img/miannet-wallet-config/mainnet-wallet-config-15.webp) + +5. Complete los detalles de la red RPC personalizada y haga clic en _guardar_ para agregar la red. + +- **Nombre de la red:** Core Blockchain +- **Nueva URL de RPC:** https://rpc.ankr.com/core +- **ID de cadena:** 1116 (**Nota**: 0x45c es lo mismo que 1116. La nueva versión de MetaMask convierte el ID de cadena al formato hexadecimal). +- **Símbolo de moneda:** CORE +- **URL del Explorador de bloques:** https://scan.coredao.org + +4. Después de realizar los pasos anteriores, podrás ver la red Core la próxima vez que accedas al selector de redes. + +:::info +Si tiene un error o tiene dificultades para agregar la red, solicite ayuda en el canal de "soporte" en [Core Discord] (https://discord.gg/coredao), siempre estamos disponibles para ayudarlo. +::: diff --git a/docs_es/Dev-Guide/core-subgraph.md b/docs_es/Dev-Guide/core-subgraph.md new file mode 100644 index 0000000000..95ed778756 --- /dev/null +++ b/docs_es/Dev-Guide/core-subgraph.md @@ -0,0 +1,88 @@ +--- +sidebar_label: Subgrafo Core +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Subgrafo Core usando GraphQL + +--- + +Los desarrolladores pueden utilizar un subgrafo autohospedado para extraer datos de la cadena de bloques Core, procesarlos y almacenarlos para su consumo a través de GraphQL. Echemos un vistazo a cómo podemos crear e implementar esta poderosa herramienta. + +### URL importantes + +Usaremos algunas URL estándar a lo largo de esta guía, que será útil revisar antes de comenzar. + +#### Red principal + +
URLUso
URL de administración: https://thegraph.coredao.org/deploy/Se utiliza para crear/implementar subgrafos.
IPFS URL: https://thegraph.coredao.org/ipfs/Se utiliza para implementar subgrafos.
HTTP query URL: https://thegraph.coredao.orgSe utiliza para consultar datos de subgrafos.
URL de control de estado
>https://thegraph-is.coredao.org		Se utiliza para comprobar el estado del subgrafo.
+ +#### Red de prueba + +
URLUso
URL de administración:
https://thegraph-node.test.btcs.network		Se utiliza para crear/implementar subgrafos (--node o -g).
URL de IPFS:
https://thegraph-ipfs.test.btcs.network		Se utiliza para implementar subgrafos.
URL de consulta HTTP:
https://thegraph.test.btcs.network		Se utiliza para consultar datos de subgrafos.
URL de control de estado
>https://thegraph-sub.test.btcs.network		Se utiliza para comprobar el estado del subgrafo.
+ +### Pasos generales de configuración del subgrafo + +#### Crear repositorio + +Para crear su repositorio de subgrafos, siga la [guía oficial de The Graph](https://thegraph.com/docs/en/developing/creating-a-subgraph/). Para implementar en la red Core Graph, asegúrese de configurar el nombre de su red en `subgraph.yaml` como núcleo. Dependiendo de su subgrafo, es posible que haya algunos cambios más que realizar Encontrará detalles adicionales en la sección de ejemplos completa a continuación. + +#### Crear e implementar + +Para crear e implementar su subgrafo, ejecute los siguientes comandos en el repositorio de su proyecto de subgrafo. + +```bash +# Crear subgraph +graph create your-subgraph-name --node https://thegraph.coredao.org/deploy/ + +# Deployar subgraph +graph deploy your-subgraph-name --node https://thegraph.coredao.org/deploy/ --ipfs https://thegraph.coredao.org/ipfs/ +``` + +El comando `graph depoy` debería devolver la URL de consulta HTTP para su subgrafo, que puede integrar en su aplicación según corresponda. + +### Ejemplo: implementación de un subgrafo Uniswap V2 + +Ahora que entendemos el proceso, veamos un ejemplo completo configurando un subgrafo Uniswap V2 en Core. + +Primero, clone el [repositorio de subgrafos] de Uniswap V2 (https://github.com/Uniswap/v2-subgraph), navegue hasta la carpeta del proyecto y luego ejecute los siguientes comandos desde ese directorio: + +``` +# Instalar dependencias con npm (o hilo) +npm install + +# Generar código de subgrafo +npm run codegen +``` + +Ahora haremos algunos cambios necesarios en el +_subgraph.yaml_ and _helpers.ts_ files: + +- _subgraph.yaml_: + - Cambie el nombre de la red a "core" en las líneas 9 y 37. + - Actualice la dirección de fábrica en la línea 11. + - Actualice `startBlock` en la línea 13 a una altura de bloque razonable (la altura del bloque actual está disponible [aquí](https://scan.coredao.org/)). +- _src/mappings/helpers.ts_: + - Actualice la dirección de fábrica en la línea 11. + +Finalmente, ejecutaremos los comandos de creación e implementación. Para evitar problemas de compatibilidad, usemos el graph-cli instalado en el proyecto (en lugar de la versión global) anteponiendo el comando `graph` con `./node_modules/.bin/`. + +```bash +# Crea un nuevo subgrafo llamado uniswap-4-test +./node_modules/.bin/graph create uniswap-4-test --node https://thegraph.coredao.org/deploy/ + +# Implementar el subgrafo uniswap-4-test +./node_modules/.bin/graph deploy uniswap-4-test --node https://thegraph.coredao.org/deploy/ --ipfs https://thegraph.coredao.org/ipfs/ + +# El comando de implementación debería imprimir una URL de consulta HTTP similar a: +# https://thegraph.coredao.org/subgraphs/name/uniswap-4-test +``` + +¡Bien hecho, tu subgrafo está implementado! Ahora puede integrar la URL de consulta HTTP impresa por el comando de implementación en su sitio web y utilizarla para consultar datos. + +### Authorization + +Para evitar que otros sobrescriban su subgrafo, contáctenos en [discord](https://discord.com/invite/coredaoofficial) para obtener una clave de autorización.\ +\ +Si está realizando pruebas con TestNet Graph, aquí hay un token de acceso para fines de prueba generales: **a9a79c2aea604bfaa861ff93d46d0d11**. diff --git a/docs_es/Dev-Guide/core-testnet-wallet-config.md b/docs_es/Dev-Guide/core-testnet-wallet-config.md new file mode 100644 index 0000000000..ee3ecfb560 --- /dev/null +++ b/docs_es/Dev-Guide/core-testnet-wallet-config.md @@ -0,0 +1,87 @@ +--- +sidebar_label: Red de prueba de Core +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Conéctese a la red de prueba de Core + +--- + +:::note +Esta es una guía detallada para conectarse a Core Testnet utilizando la billetera MetaMask. +::: + +### Requisitos previos del software + +1. [Extensión del navegador MetaMask Wallet](https://metamask.io/) + +### Configuración de la billetera MetaMask + +Recomendamos utilizar la [billetera web MetaMask](https://metamask.io/) para conectarse a Core Testnet. Deberá instalar MetaMask y configurar su cuenta antes de poder usarla para conectarse a Core Testnet. Puede encontrar las instrucciones de configuración de MetaMask aquí. + +### Agregar Core Testnet a MetaMask + +Hay varias formas de agregar configuraciones de Core Testnet a su MetaMask Wallet; a continuación, enumeramos las formas más confiables y de prueba. + +#### Agregar red manualmente + +Una vez que haya configurado su billetera MetaMask, puede usarla para conectarse a Core Testnet agregando los detalles de la cadena de Core Testnet en la configuración de red de MetaMask. Navegue hasta `Configuración->Redes` en MetaMask y haga clic en el botón `Agregar red`. Introduzca la siguiente información: + +- **Nombre de la red:** Core Blockchain TestNet +- **Nueva URL de RPC:** https://rpc.test.btcs.network +- **Chain ID:** 1115 +- **Símbolo de moneda:** tCORE +- **Block Explorer URL:** https://scan.test.btcs.network + +![add-network-metamask](../../static/img/testnet-wallet-config/testnet-config-wallet-1.png) + +#### Agregar la red Core a través de Chainlist.org + +1. Vaya a chainlist.org y busque '_core blockchain_', asegúrese de marcar la opción _Incluir Testnets_. + +![chainlist-testnet-connect-metmask](../../static/img/testnet-wallet-config/chainlist-testnet-connect-1.png) + +2. Verifique dos veces para asegurarse de elegir la red correcta. Verifique los detalles en las siguientes instantáneas: ID de cadena, moneda, etc. para asegurarse de agregar la correcta. + +![chainlist-testnet-connect-metmask](../../static/img/testnet-wallet-config/chainlist-testnet-connect-2.png) + +3. Haga clic en _Connect Wallet_ y luego elija MetaMask. Permita conectarse a la billetera MetaMask confirmando las notificaciones de MetaMask. + +![chainlist-testnet-connect-metmask](../../static/img/testnet-wallet-config/chainlist-testnet-connect-3.png) + +4. Cambie a Core testnet haciendo clic en el botón _'Cambiar red'_. + +![chainlist-testnet-connect-metmask](../../static/img/testnet-wallet-config/chainlist-testnet-connect-4.png) + +El Core Testnet ahora está agregado a su MetaMask. + +#### Agregar red a través de Core Testnet Explorer + +Si usa la extensión Chrome MetaMask, puede usar un atajo rápido para agregar Core Testnet a MetaMask. Visite [Core Testnet Explorer] (https://scan.test.btcs.network/), desplácese hacia abajo y seleccione el botón "Agregar red central". Esto abrirá una ventana emergente con toda la información de red necesaria cargada; solo necesita confirmar y aprobar. + +![agregar-metamask-de-red](../../static/img/testnet-wallet-config/testnet-wallet-config-2.png) + +:::info + +#### Actualizaciones de cambio de marca + +Satoshi Chain/BTC ha sido rebautizado como “Core Chain/CORE”, respectivamente. Si agregó Testnet antes del cambio de marca, deberá actualizar manualmente el nombre de la red y el símbolo de moneda en la configuración de MetaMask; de lo contrario, no podrá utilizar la versión actual de Core Testnet. Vaya a `Configuración->Red` y seleccione `Core Testnet` para abrir la configuración de red. Actualice el nombre de la red y el símbolo de moneda a los valores indicados en la [sección anterior] (#adding-network-manualmente) y haga clic en el botón Guardar. Estas listo +::: + +### Monedero de financiación con tokens tCORE + +Para ayudar a los usuarios a comenzar y permitir a los desarrolladores crear rápidamente prototipos de sus dApps, Core ha lanzado el [Core Testnet Faucet] público (https://scan.test.btcs.network/faucet) para distribuir tokens de Core testnet, **tCORE** . Siga la [guía] detallada (./core-faucet.md) para financiar su cuenta de metamask con tokens tCORE. + +### Envío de tokens tCORE + +Puede utilizar MetaMask para enviar tCORE a otras direcciones. + +1. Navegue a la billetera metamask, asegúrese de estar conectado a Core Testnet +2. Haga clic en el botón `Enviar` + +![send-metmask](../../static/img/testnet-wallet-config/send-tcore-1.png) + +3. Ingrese la cantidad de tokens tCORE que desea enviar y la dirección a la que desea enviar los tokens tCORE; asegúrese de que sea una dirección Core Testnet. Luego haga clic en siguiente y confirme la transacción. + +![send-metmask](../../static/img/testnet-wallet-config/send-tcore-2.png) diff --git a/docs_es/Dev-Guide/dapp-on-core.md b/docs_es/Dev-Guide/dapp-on-core.md new file mode 100644 index 0000000000..9ffab1d4bb --- /dev/null +++ b/docs_es/Dev-Guide/dapp-on-core.md @@ -0,0 +1,353 @@ +--- +sidebar_label: Construya dApp en Core +hide_table_of_contents: false +sidebar_position: 2 +description: Cree una dApp de Fullstack en Core Chain +--- + +# Construyendo dApp en Core + +--- + +Las aplicaciones descentralizadas (dApps) utilizan una cadena de bloques o contratos inteligentes en cadena para almacenar y hacer referencia a datos, en lugar de depender de bases de datos centralizadas tradicionales. Una estructura de dApp simple y común generalmente consiste en una interfaz de usuario de React.js o Vue.js que utiliza Web3.js o Ethers.js para interactuar con contratos inteligentes implementados en una cadena de bloques compatible con EVM. + +## ¿Qué estamos construyendo? + +En este tutorial, desarrollaremos una dApp simple usando React.js y Ethers.js que almacena datos en un contrato inteligente en Core blockchain y los muestra a los usuarios. El código completo de la dApp está disponible en GitHub en el [dApp-tutorial](https://github.com/coredao-org/dapp-tutorial/tree/master/01-Basic%20Full%20Stack%20Dapp%20on%20Core# building-a-dapp-on-core) repositorio. + +## Conclusiones del aprendizaje + +Este tutorial le ayudará a adquirir conocimientos sobre los siguientes puntos de aprendizaje: + +- Conectividad de MetaMask Wallet a Core Testnet; +- Desarrollo e implementación de contratos inteligentes en Core Testnet; +- Integración front-end con el contrato inteligente utilizando la biblioteca Ethers.js; +- Leer datos de un contrato inteligente; +- Escribir datos en un contrato inteligente; + +## Requisitos previos del software + +- [Git](https://git-scm.com/) v2.44.0 +- [Node.js](https://nodejs.org/en) v20.11.1 +- [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) v10.2.4 +- [Hardhat](https://hardhat.org/hardhat-runner/docs/getting-started#installation) v10.2.4 +- [MetaMask Web Wallet Extension](https://metamask.io/download/) + +## Configurar el entorno de desarrollo + +1. Cree un nuevo directorio para el proyecto y navegue hasta él. + +```bash +mkdir dapp-tutorial +cd dapp-tutorial +``` + +2. Install [Hardhat](https://hardhat.org/) and [Waffle](https://getwaffle.io/) + +```bash +npm init --yes +npm install --save-dev hardhat +npm install --save-dev chai @nomiclabs/hardhat-waffle +``` + +3. Inicialice el proyecto Hardhat ejecutando el siguiente comando + +```bash +npx hardhat +``` + +![harhat-project-initialize](../../static/img/hardhat/dapp-tutorial-1.png) + +:::note +Como usaremos Waffle para este proyecto y nos aseguraremos de seleccionar **No** para la opción "_¿Desea instalar las dependencias de este proyecto de muestra con npm (@nomicfoundation/hardhat-toolbox)? (Y/n)_" +::: + +4. Una vez que se inicializa este proyecto, encontrará la siguiente estructura de proyecto: + +```bash +dapp-tutorial. +| .gitignore +| hardhat-config.js (HardHat configuration file.) +| package-lock.json +| package.json +| README.md +| ++---contracts (Para Solidity Smart Contracts) +| Lock.sol +| ++---ignition (Scripts en versiones anteriores, esta carpeta contiene archivos de configuración que especifican cómo se deben implementar los contratos inteligentes.) +| \---modules +| Lock.js +| ++---node_modules +| ++---test (Para escribir y ejecutar pruebas) +| Lock.js +| +``` + +5. Instale y configure MetaMask Chrome Extension para usar con Core Testnet. Consulte [aquí](./core-testnet-wallet-config.md) para obtener una guía detallada. + +6. Cree un archivo secret.json en la carpeta raíz y almacene en él la clave privada de su billetera MetaMask. Consulte [aquí](https://metamask.zendesk.com/hc/en-us/articles/360015290032-How-to-reveal-your-Secret-Recovery-Phrase) para obtener detalles sobre cómo obtener la clave privada de la cuenta MetaMask. + +```json +{"PrivateKey":"you private key, do not leak this file, do keep it absolutely safe"} +``` + +:::caution +No olvide agregar este archivo al archivo `.gitignore` en la carpeta raíz de su proyecto para no verificar accidentalmente sus claves privadas/frases secretas en un repositorio público. ¡Asegúrese de guardar este archivo en un lugar absolutamente seguro! +::: + +7. Copie lo siguiente en su archivo `hardhat.config.js` + +```js +/** + * @type import('hardhat/config').HardhatUserConfig + */ + + +require('@nomiclabs/hardhat-ethers'); +require("@nomiclabs/hardhat-waffle"); + + +const { PrivateKey } = require('./secret.json'); + + +module.exports = { + defaultNetwork: 'testnet', + + + networks: { + hardhat: { + }, + testnet: { + url: 'https://rpc.test.btcs.network', + accounts: [PrivateKey], + chainId: 1115, + } + }, + solidity: { + compilers: [ + { + version: '0.8.19', + settings: { + evmVersion: 'paris', + optimizer: { + enabled: true, + runs: 200, + }, + }, + }, + ], + }, + paths: { + sources: './contracts', + cache: './cache', + artifacts: './artifacts', + }, + mocha: { + timeout: 20000, + }, +}; + +``` + +## Redacción de contratos inteligentes + +1. Navegue a la carpeta `contratos` en el directorio raíz de su proyecto. +2. Elimine el archivo `Lock.sol`; cree un nuevo archivo `Storage.sol` y pegue el siguiente contenido en él. + +```javascript +// SPDX-License-Identifier: GPL-3.0 + + +pragma solidity >=0.7.0 <0.9.0; + + +/** + * @title Storage + * @dev Store & retrieve value in a variable + */ +contract Storage { + + + uint256 number; + + + /** + * @dev Store value in variable + * @param num value to store + */ + function store(uint256 num) public { + number = num; + } + + + /** + * @dev Return value + * @return value of 'number' + */ + function retrieve() public view returns (uint256){ + return number; + } +} +``` + +### Explicación + +El contrato de "Almacenamiento" es un ejemplo simple que demuestra cómo almacenar y recuperar un valor usando un contrato inteligente de Solidity. Consiste en una variable de estado para contener el valor y dos funciones para actualizar y leer este valor. La función "almacenar" permite a cualquier usuario establecer el valor, mientras que la función "recuperar" permite a cualquier usuario leer el valor actual. Este contrato puede resultar útil para comprender los conceptos básicos de las variables de estado y la visibilidad de funciones en Solidity. Este contrato inteligente de Solidity, denominado "Almacenamiento", es un contrato simple que permite almacenar y recuperar un único valor "uint256". Aquí hay un desglose detallado de sus componentes y funcionalidad: + +#### Componentes del contrato + +1. **Variable de estado**: + - `number`: una variable `uint256` que se utiliza para almacenar el valor. + +#### Funciones del contrato + +1. **Función de tienda**: + - `store(uint256 num) public`: una función que permite a los usuarios almacenar un nuevo valor en la variable `number`. Esta función toma un solo parámetro, "num", que es el valor que se almacenará. La función actualiza la variable `número` con el valor proporcionado. + - **Visibilidad**: la función está marcada como "pública", lo que significa que cualquier usuario o contrato puede llamarla. + - **Cambio de estado**: Esta función modifica el estado del contrato actualizando la variable `número`. + +2. **Función de recuperación**: + - `retrieve() public view return (uint256)`: una función que devuelve el valor actual almacenado en la variable `number`. Esta función no toma ningún parámetro y devuelve un valor `uint256`. + - **Visibilidad**: la función está marcada como "pública", lo que significa que cualquier usuario o contrato puede llamarla. + - **Ver**: La función está marcada como `ver`, lo que indica que no modifica el estado del contrato. Sólo lee el estado. + - **Valor de retorno**: La función devuelve el valor de la variable "número". + +## Compilación de contrato inteligente + +1. Para compilar el contrato inteligente `Storage` definido en `Storage.sol`, desde el directorio raíz ejecute el siguiente comando + +```bash +npx hardhat compile +``` + +## Implementar e interactuar con contratos inteligentes + +1. Antes de implementar su contrato inteligente en Core Chain, es mejor ejecutar primero una serie de pruebas para asegurarse de que el contrato inteligente esté funcionando como se desea. Consulte la guía detallada [aquí](https://docs.coredao.org/developer/develop-on-core/building-on-core/using-hardhat#contract-testing) para obtener más detalles. + +2. Cree una carpeta `scripts` en el directorio raíz de su proyecto. Dentro de esta carpeta, cree un archivo `deploy-and-call.js`; pegue el siguiente script en él. + +```javascript +const hre = require("hardhat"); + + +async function main() { + const Storage = await hre.ethers.getContractFactory("Storage"); + const storage = await Storage.deploy(); + + + await storage.deployed(); + console.log("Storage contract deployed to:", storage.address); + + + console.log("call retrieve():", await storage.retrieve()) + + + console.log("call store(), set value to 100") + const tx = await storage.store(100) + await tx.wait() + + console.log("call retrieve() again:", await storage.retrieve()) +} + + +// We recommend this pattern to be able to use async/await everywhere +// and properly handle errors. +main().catch((error) => { + console.error(error); + process.exitCode = 1; +}); +``` + +3. Asegúrese de que su billetera MetaMask tenga tokens de prueba tCORE para Core Testnet. Consulte [aquí](https://docs.coredao.org/developer/develop-on-core/using-core-testnet/connect-to-core-testnet#testnet-facuet-tcore-account-funding) para obtener detalles sobre cómo obtener tokens tCORE de Core Faucet. + +4. Ejecute el siguiente comando desde el directorio raíz de su proyecto para implementar su contrato inteligente en Core Chain. + +```bash +npx hardhat run scripts/deploy-and-call.js +``` + +Si se implementa correctamente, obtendrá el siguiente resultado + +```bash +>npx hardhat run scripts/deploy-and-call.js +Storage contract deployed to: 0x48F68BF4A1b1fE6589B9D0a5ad0dF0520582edA2 +call retrieve(): BigNumber { value: "0" } +call store(), set value to 100 +call retrieve() again: BigNumber { value: "100" } +``` + +5. Asegúrese de guardar la dirección del contrato de almacenamiento en el que se implementa, como se obtuvo anteriormente, esto se usará para interactuar con el contrato inteligente desde la interfaz de la dApp. + +Felicidades Ha aprendido con éxito cómo crear, compilar e implementar un contrato inteligente en Core Chain Testnet utilizando Hardhat. + +## Interactuar con Smart Contract a través del Frontend + +Creemos una interfaz frontal para interactuar con el contrato inteligente. + +### Configurando la interfaz + +1. Clona el repositorio `dApp-tutorial` de GitHub usando el siguiente comando. + +```bash +git clone https://github.com/coredao-org/dapp-tutorial.git +``` + +2. Navegue a la carpeta `01-Basic Full Stack Dapp on Core` en el repositorio clonado `dapp-tutorial`. + +```bash +cd dapp-tutorial +cd "01-Basic Full Stack Dapp on Core" +``` + +3. Instale todas las dependencias, es decir, módulos de nodo. + +```bash +npm install +``` + +4. Para probar si todo funciona bien, ejecute la aplicación usando el siguiente comando. Esto servirá a la aplicación con función de recarga en caliente en [http://localhost:5173](http://localhost:5173/) + +```bash +npm run dev +``` + +### Implementaciones clave + +La lógica clave de blockchain de la aplicación se implementa en [App.tsx](https://github.com/coredao-org/dapp-tutorial/blob/master/01-Simple%20Storage%20Full%20Stack%20Dapp/src/components/ aplicación.tsx) + +1. [App.tsx (Cartera)](https://github.com/coredao-org/dapp-tutorial/blob/master/01-Simple%20Storage%20Full%20Stack%20Dapp/src/components/App.tsx#L20): lógica para conectar la aplicación a la billetera MetaMask. +2. [App.tsx (Tienda)](https://github.com/coredao-org/dapp-tutorial/blob/master/01-Simple%20Storage%20Full%20Stack%20Dapp/src/components/App.tsx#L58): lógica para escribir datos en el contrato inteligente de almacenamiento. +3. [App.tsx (Recuperar)](https://github.com/coredao-org/dapp-tutorial/blob/master/01-Simple%20Storage%20Full%20Stack%20Dapp/src/components/App.tsx#L87): lógica para leer datos del contrato inteligente de almacenamiento. + +### Agregar detalles de contrato inteligente + +1. Copie el archivo `Storage.sol` de la carpeta `contracts` en la raíz de su proyecto y péguelo en la carpeta `frontend/src/contracts`. +2. Copie la dirección del contrato inteligente de almacenamiento obtenida en la sección [arriba](#deploy-and-interact-with-smart-contract). +3. Pegue esto en la [Línea 10 de App.tsx](https://github.com/coredao-org/dapp-tutorial/blob/master/01-Simple%20Storage%20Full%20Stack%20Dapp/src/components/App. tsx#L10). + +```javascript +const contractAddress = '0x48F68BF4A1b1fE6589B9D0a5ad0dF0520582edA2' +``` + +4. Además, necesitaremos los metadatos de ABI para interactuar con el contrato desde nuestra dApp. Desde la carpeta `artifacts/contracts` en la raíz de su proyecto. Copie el archivo `Storage.json` y guárdelo en la carpeta `/src/contracts`. + +## Pruebe localmente usando MetaMask + +1. Ejecute el comando `npm run dev` desde la raíz del proyecto para iniciar la aplicación. Esto servirá para la aplicación en [http://localhost:5173](http://localhost:5173/) + +2. Asegúrese de que su billetera MetaMask esté correctamente instalada y cambiada a Core Testnet como se describe en nuestra [guía del usuario de Core Testnet] (./core-testnet-wallet-config.md). También deberá conectar su billetera MetaMask al sitio local. + +![dapp-on-core](../../static/img/dapp/dapp-1.png) + +3. Ingrese un número en el campo de entrada y haga clic en el botón **almacenar** para guardarlo en el contrato. Una acción de escritura en el contrato inteligente invoca la billetera MetaMask. Haga clic en el botón **Confirmar** para firmar la transacción y espere la confirmación en la cadena de bloques. + +![dapp-on-core](../../static/img/dapp/dapp-2.avif) + +4. Una vez confirmada la transacción en la cadena de bloques, haga clic en el botón **recuperar** para leer el valor del contrato inteligente. Notarás que el valor se ha actualizado. + +![dapp-on-core](../../static/img/dapp/dapp-3.avif) + +🎉 ¡Felicidades! ¡Acaba de interactuar con su contrato recién implementado utilizando la interfaz de su dApp! Puede aprovechar el código base implementando e interactuando con diferentes contratos y agregando nuevos componentes de interfaz de usuario al sitio web para sus usuarios. diff --git a/docs_es/Dev-Guide/dev-tools.md b/docs_es/Dev-Guide/dev-tools.md new file mode 100644 index 0000000000..a275b465c3 --- /dev/null +++ b/docs_es/Dev-Guide/dev-tools.md @@ -0,0 +1,45 @@ +--- +sidebar_label: Herramientas para desarrolladores +hide_table_of_contents: false +sidebar_position: 2 +--- + +# Panorama de herramientas para desarrolladores + +--- + +#### _Acceda a las herramientas y recursos de Core_ + +### Recursos principales de Testnet de Blockchain + +- **[Block Explorer](https://scan.test.btcs.network/):** busque y revise transacciones, cuentas, bloques y más. + +- **[Puntos finales RPC](https://chainlist.org/chain/1115):** Puntos finales RPC para el servicio RPC de Core Testnet. + +- **[Core Faucet](https://scan.test.btcs.network/faucet):** financie su dirección de testnet con tCORE. + +- **[Core Stake](https://stake.test.btcs.network/):** sitio web de tCORE stake. + +- **[Gnosis Safe](https://safe.test.btcs.network/welcome):** gestión segura multifirma de activos digitales. + +### Recursos generales + +- **[Core DAO GitHub](https://github.com/coredao-org):** la página oficial de GitHub, que incluye el código base de Core blockchain y más. + +### Recursos de la red principal de Core Blockchain + +- **[Block Explorer](https://scan.coredao.org/):** busque y revise transacciones, cuentas, bloques y más. + +- **[Puntos finales RPC](https://chainlist.org/chain/1116):** Puntos finales RPC para el servicio RPC de Core Mainnet. + +- **[Core Bridge](https://bridge.coredao.org/):** puente oficial para el ecosistema Core (más detalles en Core Bridge Resources) + +- **[Core Stake](https://stake.coredao.org/):** sitio web oficial de CORE Stake. + +- **[Proveedor Web3](https://cloud.infstones.com/login):** infraestructura API escalable proporcionada por InfStones. + +- **[Core Scan Contract Verifier](https://scan.coredao.org/verifyContract):** herramienta web para verificación de contratos (guía aquí). + +- **[Gnosis Safe](https://safe.coredao.org/welcome):** gestión segura multifirma de activos digitales. + +- **[wCORE](https://scan.coredao.org/address/0x191e94fa59739e188dce837f7f6978d84727ad01):** contrato inteligente de token CORE envuelto oficial. diff --git a/docs_es/Dev-Guide/erc20-tokens.md b/docs_es/Dev-Guide/erc20-tokens.md new file mode 100644 index 0000000000..4e2b8ca94e --- /dev/null +++ b/docs_es/Dev-Guide/erc20-tokens.md @@ -0,0 +1,69 @@ +--- +sidebar_label: ERC-20 Tokens +hide_table_of_contents: false +sidebar_position: 2 +description: ERC-20 en Core Chain +--- + +# ERC20 Tokens + +--- + +ERC20 es actualmente el enfoque dominante para implementar tokens fungibles basados ​​en blockchain. Cada token ERC20 se basa en la interfaz del token ERC20 original, lo que significa que todos comparten un conjunto común de funciones, que incluyen (entre otras): + +- Transferir tokens de una cuenta a otra; +- Obtener el saldo actual de tokens de una cuenta; +- Obtener el suministro total del token disponible en la red; +- Aprobar una cantidad de tokens para ser gastados por una cuenta de terceros; + +Para ser compatible con ERC-20, un token debe implementar todas las funciones y eventos siguientes: + +```javascript +function name() public view returns (string) +function symbol() public view returns (string) +function decimals() public view returns (uint8) +function totalSupply() public view returns (uint256) +function balanceOf(address _owner) public view returns (uint256 balance) +function transfer(address _to, uint256 _value) public returns (bool success) +function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) +function approve(address _spender, uint256 _value) public returns (bool success) +function allowance(address _owner, address _spender) public view returns (uint256 remaining) +``` + +```javascript +event Transfer(address indexed _from, address indexed _to, uint256 _value) +event Approval(address indexed _owner, address indexed _spender, uint256 _value) +``` + +## Mejores prácticas + +ERC20 es un estándar simple y seguro. Pero debemos tener cuidado en nuestra implementación; Muchos tokens ERC20 han sido explotados a lo largo de los años debido a la inclusión de código adicional con errores. + +Por motivos de seguridad, recomendamos utilizar la implementación OpenZeppelin ERC20 para su proyecto, cuyo código fuente se puede encontrar en[ERC20.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts /token/ERC20/ERC20.sol). Puedes hacer esto con los siguientes pasos: + +1\. Instale los contratos inteligentes de OpenZeppelin en su proyecto ejecutando el siguiente comando: + +`npm install @openzeppelin/contracts` + +2\. Luego, puedes importar los contratos en la biblioteca con esto: + +```javascript +// contracts/GLDToken.sol +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract GLDToken is ERC20 { + constructor(uint256 initialSupply) ERC20("Gold", "GLD") { + _mint(msg.sender, initialSupply); + } +} +``` + +Puede encontrar más información sobre la implementación de OpenZeppelin ERC-20 [aquí](https://docs.openzeppelin.com/contracts/4.x/erc20). + +#### References + +- [https://ethereum.org/en/developers/docs/standards/tokens/erc-20/](https://ethereum.org/en/developers/docs/standards/tokens/erc-20/) +- [https://docs.openzeppelin.com/contracts/4.x/erc20](https://docs.openzeppelin.com/contracts/4.x/erc20) diff --git a/docs_es/Dev-Guide/erc721-tokens.md b/docs_es/Dev-Guide/erc721-tokens.md new file mode 100644 index 0000000000..907003e329 --- /dev/null +++ b/docs_es/Dev-Guide/erc721-tokens.md @@ -0,0 +1,77 @@ +--- +sidebar_label: ERC-721 Tokens +hide_table_of_contents: false +sidebar_position: 2 +description: ERC-721 en Core Chain +--- + +# ERC721 Tokens + +--- + +ERC721 es un estándar para tokens no fungibles, lo que significa que cada token es verificablemente único de todos los demás tokens y se ha convertido en el estándar dominante para las NFT en cadena. Todos los ERC721 tienen un "tokenId" único que los diferencia de todos los demás tokens del conjunto. + +Un token compatible con ERC721 debe implementar todas las funciones y eventos siguientes: + +```javascript + function balanceOf(address _owner) external view returns (uint256); + function ownerOf(uint256 _tokenId) external view returns (address); + function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable; + function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable; + function transferFrom(address _from, address _to, uint256 _tokenId) external payable; + function approve(address _approved, uint256 _tokenId) external payable; + function setApprovalForAll(address _operator, bool _approved) external; + function getApproved(uint256 _tokenId) external view returns (address); + function isApprovedForAll(address _owner, address _operator) external view returns (bool); +``` + +```javascript + event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); + event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); + event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); +``` + +## Mejores prácticas + +Recomendamos utilizar la popular y confiable implementación ERC721 de OpenZeppelin en su proyecto. El código fuente se puede encontrar en[ERC721.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol). Puede utilizar la implementación ERC721 de OpenZeppelin en su proyecto mediante los siguientes pasos: + +1\. Instale la biblioteca OpenZeppelin en su proyecto ejecutando el comando: + +`npm install @openzeppelin/contracts` + +2\. Una vez instalada, puede usar la implementación ERC721 en la biblioteca importándola así: + +```javascript +// contracts/GameItem.sol +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; +import "@openzeppelin/contracts/utils/Counters.sol"; + +contract GameItem is ERC721URIStorage { + using Counters for Counters.Counter; + Counters.Counter private _tokenIds; + + constructor() ERC721("GameItem", "ITM") {} + + function awardItem(address player, string memory tokenURI) + public + returns (uint256) + { + uint256 newItemId = _tokenIds.current(); + _mint(player, newItemId); + _setTokenURI(newItemId, tokenURI); + + _tokenIds.increment(); + return newItemId; + } +} +``` + +Para obtener más información sobre la implementación de OpenZeppelin ERC-20, lea [ERC721](https://docs.openzeppelin.com/contracts/4.x/erc721). + +#### Referencias + +- [https://ethereum.org/en/developers/docs/standards/tokens/erc-721/](https://ethereum.org/en/developers/docs/standards/tokens/erc-721/) +- [https://docs.openzeppelin.com/contracts/4.x/erc721](https://docs.openzeppelin.com/contracts/4.x/erc721) diff --git a/docs_es/Dev-Guide/hardhat.md b/docs_es/Dev-Guide/hardhat.md new file mode 100644 index 0000000000..25c484dffb --- /dev/null +++ b/docs_es/Dev-Guide/hardhat.md @@ -0,0 +1,267 @@ +--- +sidebar_label: Usando Hardhat +hide_table_of_contents: false +sidebar_position: 2 +description: Implementar contratos en Core Chain usando Hardhat +--- + +# Usando Hardhat + +--- + +Hardhat es un entorno de desarrollo popular para cadenas de bloques compatibles con EVM, que consta de múltiples componentes para escribir, compilar, depurar e implementar contratos inteligentes. + +En este tutorial, aprenda cómo compilar, implementar y llamar contratos inteligentes en Core TestNet usando HardHatcheck. Obtenga el código base para este tutorial desde [aquí](https://github.com/coredao-org/hardhat-tutorial). + +## Instalacion + +Navegue a su carpeta de perfil y siga los pasos a continuación para instalar HardHat (se requiere npm/node [v8.9.4 LTS o posterior] (https://nodejs.org/en/)): + +1. `npm init --yes` +2. `npm install --save-dev hardhat` +3. `npm install --save-dev chai @nomiclabs/hardhat-waffle` + +## Inicialización del proyecto + +Después de la instalación, podemos inicializar HardHat ejecutando el comando `npx hardhat`: + +```javascript +$ npx hardhat +888 888 888 888 888 +888 888 888 888 888 +888 888 888 888 888 +8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888 +888 888 "88b 888P" d88" 888 888 "88b "88b 888 +888 888 .d888888 888 888 888 888 888 .d888888 888 +888 888 888 888 888 Y88b 888 888 888 888 888 Y88b. +888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888 + +👷 Welcome to Hardhat v2.10.1 👷‍ + +? What do you want to do? … +❯ Create a JavaScript project + Create a TypeScript project + Create an empty hardhat.config.js + Quit +``` + +Una vez que se inicializa este proyecto, encontrará la siguiente estructura de proyecto: + +- `contracts`: para contratos inteligentes de Solidity. +- `scripts`: para scripts JavaScript/TypeScript para interacción de contratos y otras utilidades. +- `test`: para escribir y ejecutar pruebas. +- `hardhat.config.js`: archivo de configuración de HardHat. + +## Configurar HardHat para Core Testnet + +Copie lo siguiente en su archivo `hardhat.config.js`: + +```javascript +/** + * @type import('hardhat/config').HardhatUserConfig + */ + + require('@nomiclabs/hardhat-ethers'); + require("@nomiclabs/hardhat-waffle"); + + const { PrivateKey } = require('./secret.json'); + + module.exports = { + defaultNetwork: 'testnet', + + networks: { + hardhat: { + }, + testnet: { + url: 'https://rpc.test.btcs.network', + accounts: [PrivateKey], + chainId: 1115, + } + }, + solidity: { + compilers: [ + { + version: '0.8.9', + settings: { + evmVersion: 'paris', + optimizer: { + enabled: true, + runs: 200, + }, + }, + }, + ], + }, + paths: { + sources: './contracts', + cache: './cache', + artifacts: './artifacts', + }, + mocha: { + timeout: 20000, + }, + }; + +``` + +**Asegúrese de que su contrato inteligente siga las [Pautas de soporte de solidez de Core Chain](./smart-contract-guidelines.md)**. Para ello, asegúrese de que el parámetro `evmVersion` esté establecido en `paris` bajo el configuración del compilador de solidez en el archivo `hardhat.config.js`. + +> Tenga en cuenta que debemos pasar claves privadas/mnemónicos para el Proveedor. Puede crear un `secret.json` para almacenarlos. No olvide agregar este archivo al `.gitignore` de su proyecto para no registrar accidentalmente sus claves privadas en un repositorio público. ¡Y asegúrese de guardar este archivo en un lugar absolutamente seguro! + +## Escribir contratos inteligentes + +En aras de la simplicidad, usemos el archivo `1_Storage.sol` con el que ya estamos familiarizados en el tutorial de Remix. Copie el siguiente código en un nuevo archivo llamado `Storage.sol` y guárdelo en la carpeta `contracts`. + +```solidity +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity >=0.7.0 <0.9.0; + +/** + * @title Storage + * @dev Store & retrieve value in a variable + */ +contract Storage { + + uint256 number; + + /** + * @dev Store value in variable + * @param num value to store + */ + function store(uint256 num) public { + number = num; + } + + /** + * @dev Return value + * @return value of 'number' + */ + function retrieve() public view returns (uint256){ + return number; + } +} +``` + +## Compilación de contratos + +Ejecute el siguiente comando para compilar el contrato: + +`npx hardhat compile` + +## Pruebas de contrato + +Cree un nuevo archivo llamado `storage-test.js` que contenga el siguiente código y guárdelo en la carpeta `test`: + +```javascript +const { expect } = require("chai") +const { ethers } = require("hardhat") + +describe("Storage", function () { + let storage; + + beforeEach(async function(){ + Storage = await ethers.getContractFactory("Storage"); + [operator] = await ethers.getSigners(); + storage = await Storage.connect(operator).deploy(); + await storage.deployed() + expect(await storage.retrieve()).to.equal(0n); + }) + describe("Test store function", function(){ + it("should work properly", async function(){ + let tx = await storage.store(100); + await tx.wait(); + expect(await storage.retrieve()).to.equal(100n); + }) + it("should throw", async function(){ + await expect( + storage.store(-1) + ).to.be.throws + }) + }) +}) +``` + +Para probar nuestro contrato `Storage.sol` en la red HardHat incorporada, ejecute el siguiente comando: + +`npx hardhat test --network hardhat` + +```javascript +$ npx hardhat test --network hardhat + + + Storage + Test store function + ✔ should work properly + ✔ should throw + + + 2 passing (1s) +``` + +## Implementación e interacción del contrato + +HardHat facilita el uso de la biblioteca `ethers.js` para implementar e interactuar con nuestros contratos inteligentes. Cree un nuevo archivo llamado `deploy-and-call.js` en la carpeta `scripts` que contiene el siguiente código: + +```javascript +// Requerimos explícitamente el Hardhat Runtime Environment aquí. esto es opcional +// pero útil para ejecutar el script de forma independiente a través del `nodo