Mientras nos embarcamos en este segmento avanzado de nuestro curso, tomemos un momento para revisar el contrato de activos sintéticos que desarrollamos en la primera parte. Este contrato sirve como base sobre la cual desarrollaremos nuestra comprensión de la gestión y actualización de contratos inteligentes.

Resumen del contrato de activos sintéticos

A continuación se muestra el contrato de activos sintéticos que implementamos anteriormente. Este contrato facilita la creación, gestión e interacción con activos sintéticos en blockchain.

Solidez 
 // Identificador de licencia SPDX: solidez pragma del MIT 
 ^0.8.0; 

 contrato SyntheticAsset { 
 uint256 público subyacenteAssetPrice; 
 uint256 garantía pública; 
 dirección pública titular; 
 mapeo (dirección => uint256) balance sintético público; 
 uint256 público totalSyntheticSupply; 

 constructor() {
        owner = msg.sender;
    }

    modificador onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    función updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    función depositColateral(uint256 _amount) public {
        collateral += _amount;
    }

    función retiroColateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    función getSyntheticAssetPrice() vista pública devuelve (uint256) {
        return underlyingAssetPrice;
    }

    función mintSyntheticAsset(uint256 _amount) pública {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    función canjearSyntheticAsset(uint256 _amount) pública {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

Ahora, con una comprensión renovada de nuestro contrato fundamental, profundicemos en los aspectos de la gestión y actualización de los contratos de activos sintéticos.

Propiedad del contrato

• Establecer la propiedad del contrato garantiza que sólo las entidades autorizadas puedan modificar el contrato.

• Implementar un modificador como onlyOwner para restringir el acceso a ciertas funciones es una práctica común.

Patrones de actualización

• Comprender diferentes patrones de actualización como Proxy, Eternal Storage y DelegateCall.

• Explorando los pros y los contras de cada patrón para elegir el más adecuado para su contrato.

Contratos de representación

• Profundizando en los contratos Proxy que permiten actualizar la lógica de un contrato manteniendo los datos intactos.

• Implementar un contrato de proxy simple para demostrar el proceso de actualización.

Solidity 
 contrato Proxy { 
 dirección de implementación pública; 

 función updateImplementation(dirección _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() externo pagadero { 
 dirección impl = implementación; 
 ensamblaje { 
 let ptr := mload(0x40) 
 calldatacopy(ptr, 0, calldatasize()) 
 let resultado := delegadocall(gas(), impl, ptr, calldatasize(), 0, 0) 
 let tamaño := returndatasize() 
 returndatacopy(ptr, 0, tamaño) 
 cambiar resultado 
 caso 0 { revert(ptr, size) }
            predeterminado { return(ptr, size) }
        }
    }
}

Versionado

• Implementar control de versiones para realizar un seguimiento de las actualizaciones del contrato.

• Utilizar versiones semánticas para indicar el tipo de cambios en cada actualización.

Actualizaciones de prueba

• Garantizar que las actualizaciones no introduzcan errores ni alteren la funcionalidad prevista.

• Probar las actualizaciones en un entorno controlado antes de implementarlas en la red principal.
  A continuación se muestra cómo se vería nuestro sistema después de incorporar un contrato de proxy para actualizaciones:

Solidez 
 // Identificador de licencia SPDX: solidez pragma del MIT 
 ^0.8.0; 

 contrato Proxy { 
 dirección de implementación pública; 
 dirección pública titular; 

 constructor() {
        owner = msg.sender;
    }

    modificador onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    función updateImplementation(dirección _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() externo pagadero { 
 dirección impl = implementación; 
 ensamblaje { 
 let ptr := mload(0x40) 
 calldatacopy(ptr, 0, calldatasize()) 
 let resultado := delegadocall(gas(), impl, ptr, calldatasize(), 0, 0) 
 let tamaño := returndatasize() 
 returndatacopy(ptr, 0, size) 
 cambiar resultado 
 caso 0 { revert(ptr, size) }
            predeterminado { return(ptr, size) }
        }
    }
}

contrato SyntheticAsset { 
 uint256 public subyacenteAssetPrice; 
 uint256 garantía pública; 
 dirección de propietario público; 
 mapeo (dirección => uint256) balance sintético público; 
 uint256 público totalSyntheticSupply; 

 constructor() {
        owner = msg.sender;
    }

    modificador onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    función updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    función depositColateral(uint256 _amount) public {
        collateral += _amount;
    }

    función retiroColateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    función getSyntheticAssetPrice() vista pública devuelve (uint256) {
        return underlyingAssetPrice;
    }

    función mintSyntheticAsset(uint256 _amount) pública {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    función canjearSyntheticAsset(uint256 _amount) pública {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

En esta configuración, el contrato Proxy actúa como puerta de enlace para el contrato SyntheticAsset , lo que permite actualizar la implementación (es decir, la lógica) de SyntheticAsset sin perder el estado (es decir, los datos) del contrato. Esto se logra mediante la función fallback en Proxy, que delega llamadas a la implementación actual de SyntheticAsset, y la función upgradeImplementation , que permite al propietario cambiar la dirección de implementación para que apunte a una nueva versión de SyntheticAsset.

A través de esta lección, obtendrá la experiencia necesaria para gestionar y actualizar contratos de activos sintéticos, garantizando que sigan siendo adaptables a los requisitos cambiantes y al mismo tiempo manteniendo la integridad y seguridad del contrato. Este conocimiento fundamental será fundamental a medida que profundicemos en aspectos más avanzados de la gestión de activos sintéticos en las lecciones posteriores. ¡Manténganse al tanto!