Ao embarcarmos neste segmento avançado do nosso curso, vamos revisitar o contrato de ativo sintético que desenvolvemos na primeira parte. Este contrato serve como base sobre a qual construiremos nosso entendimento de gerenciamento e atualização de contratos inteligentes.

Recapitulação do contrato de ativos sintéticos

Abaixo está o contrato de ativo sintético que implementamos anteriormente. Este contrato facilita a criação, gerenciamento e interação com ativos sintéticos no blockchain.

Solidez 
 // Identificador de licença SPDX: solidez do pragma MIT 
 ^0.8.0; 

 contrato SyntheticAsset { 
 uint256 public subjacenteAssetPrice; 
 uint256 garantias públicas; 
 endereço proprietário público; 
 mapeamento (endereço => uint256) público sintéticoBalance; 
 uint256 público totalSyntheticSupply; 

 construtor() {
        owner = msg.sender;
    }

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

    função updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    função depositCollateral(uint256 _amount) public {
        collateral += _amount;
    }

    função retirarCollateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    função getSyntheticAssetPrice() retornos de visualização pública (uint256) {
        return underlyingAssetPrice;
    }

    função mintSyntheticAsset (uint256 _amount) público {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    função redeemSyntheticAsset (uint256 _amount) público {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

Agora, com uma compreensão renovada do nosso contrato fundamental, vamos nos aprofundar nos aspectos de gerenciamento e atualização de contratos de ativos sintéticos.

Propriedade do Contrato

• O estabelecimento da propriedade do contrato garante que apenas entidades autorizadas possam modificar o contrato.

• Implementar um modificador como onlyOwner para restringir o acesso a determinadas funções é uma prática comum.

Padrões de atualização

• Compreender diferentes padrões de atualização, como Proxy, Eternal Storage e DelegateCall.

• Explorando os prós e os contras de cada padrão para escolher o mais adequado ao seu contrato.

Contratos de procuração

• Aprofundando-se em contratos proxy que permitem atualizar a lógica de um contrato enquanto mantêm os dados intactos.

• Implementar um contrato de proxy simples para demonstrar o processo de atualização.

Proxy de contrato Solidity 
 { 
 endereços de implementação pública; 

 função upgradeImplementation(address _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() pagamento externo { 
 endereço impl = implementação; 
 montagem { 
 let ptr := mload(0x40) 
 calldatacopy(ptr, 0, calldatasize()) 
 let result := delegadocall(gas(), impl, ptr, calldatasize(), 0, 0) 
 let size := returndatasize() 
 returndatacopy(ptr, 0, size) 
 resultado da troca 
 case 0 { revert(ptr, size) }
            padrão { return(ptr, size) }
        }
    }
}

Versionamento

• Implementar controle de versão para acompanhar atualizações de contrato.

• Uso de versionamento semântico para indicar o tipo de alterações em cada atualização.

Testando atualizações

• Garantir que as atualizações não introduzam bugs ou alterem a funcionalidade pretendida.

• Testar atualizações em um ambiente controlado antes de implantá-las na rede principal.
  Abaixo está como ficaria nosso sistema após incorporar um contrato de proxy para atualizações:

Solidez 
 // Identificador de licença SPDX: solidez do pragma MIT 
 ^0.8.0; 

 proxy de contrato { 
 endereços de implementação pública; 
 endereço proprietário público; 

 construtor() {
        owner = msg.sender;
    }

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

    function upgradeImplementation(address _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() pagamento externo { 
 endereço impl = implementação; 
 montagem { 
 let ptr := mload(0x40) 
 calldatacopy(ptr, 0, calldatasize()) 
 let result := delegadocall(gas(), impl, ptr, calldatasize(), 0, 0) 
 let size := returndatasize() 
 returndatacopy(ptr, 0, size) 
 switch result 
 case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

contrato SyntheticAsset { 
 uint256 public subjacenteAssetPrice; 
 uint256 garantias públicas; 
 endereços de proprietário público; 
 mapeamento (endereço => uint256) público sintéticoBalance; 
 uint256 público totalSyntheticSupply; 

 construtor() {
        owner = msg.sender;
    }

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

    função updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    função depositCollateral(uint256 _amount) public {
        collateral += _amount;
    }

    função retirarCollateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    função getSyntheticAssetPrice() retornos de visualização pública (uint256) {
        return underlyingAssetPrice;
    }

    função mintSyntheticAsset (uint256 _amount) público {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    função redeemSyntheticAsset (uint256 _amount) público {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

Nesta configuração, o contrato Proxy atua como um gateway para o contrato SyntheticAsset , permitindo que a implementação (ou seja, a lógica) do SyntheticAsset seja atualizada sem perder o estado (ou seja, dados) do contrato. Isto é conseguido através da função fallback em Proxy, que delega chamadas para a implementação atual de SyntheticAsset, e da função upgradeImplementation , que permite ao proprietário alterar o endereço de implementação para apontar para uma nova versão de SyntheticAsset.

Através desta lição, você obterá o conhecimento necessário para gerenciar e atualizar contratos de ativos sintéticos, garantindo que eles permaneçam adaptáveis à evolução dos requisitos, mantendo ao mesmo tempo a integridade e a segurança do contrato. Esse conhecimento fundamental será fundamental à medida que nos aprofundarmos nos aspectos mais avançados do gerenciamento de ativos sintéticos nas lições subsequentes. Fique atento!