À medida que embarcamos neste segmento avançado do nosso curso, vamos tirar um momento para revisitar o contrato de ativos sintéticos que desenvolvemos na primeira parte. Este contrato serve como a base sobre a qual construiremos a nossa compreensão de gestão e actualização de contratos inteligentes.

Recapitulação do Contrato de Ativos Sintéticos

Abaixo está o contrato de ativos sintéticos que implementamos anteriormente. Este contrato facilita a criação, gestão e interação com ativos sintéticos na cadeia de blocos.

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

contrato SyntheticAsset {
 uint256 público subjacente preço do ativo;
 uint256 garantia pública;
 endereço proprietário público;
 mapeamento (endereço = > uint256) balanço sintético público;
 uint256 fornecimento sintético total público;

 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 vista pública (uint256) {
        return underlyingAssetPrice;
    }

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

    função redeemSyntheticAsset (uint256 _amount) public {
        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 da gestão e atualização de contratos de ativos sintéticos.

Propriedade do contrato

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

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

Padrões de atualização

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

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

Contratos de Proxy

• Medição de contratos de proxy que permitem que a lógica de um contrato seja atualizada, mantendo os dados intactos.

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

Solidez
contrato Proxy {
 abordar a implementação pública;

 função upgradeImplementation (endereço _NewImplementation) public OnlyOwner {
        implementation = _newImplementation;
    }

    fallback () pagável externo {
 endereço impl = implementação;
 assembléia {
 let ptr: = mload (0x40)
 calldatacopy (ptr, 0, calldatasize ())
 deixar resultado: = delegatecall (gas (), impl, ptr, calldatasize (), 0, 0)
 tamanho do tamanho: = returndatasize ()
 devolver cópia de dados (ptr, 0, tamanho)
 mudar o resultado
 caso 0 { revert(ptr, size) }
            padrão { return(ptr, size) }
        }
    }
}

Versionamento

• Implementar o controlo de versão para acompanhar as actualizações do contrato.

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

Testar upgrades

• Garantir que as actualizações não introduzam erros ou alteram a funcionalidade pretendida.

• Testar actualizações num ambiente controlado antes de as implementar na rede principal.
  Abaixo está como o nosso sistema ficaria depois de incorporar um contrato de proxy para upgrades:

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

contrato Proxy {
 abordar a implementação pública;
 endereço proprietário público;

 construtor () {
        owner = msg.sender;
    }

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

    função upgradeImplementation (endereço _NewImplementation) public OnlyOwner {
        implementation = _newImplementation;
    }

    fallback () pagável externo {
 endereço impl = implementação;
 assembléia {
 let ptr: = mload (0x40)
 calldatacopy (ptr, 0, calldatasize ())
 deixar resultado: = delegatecall (gas (), impl, ptr, calldatasize (), 0, 0)
 tamanho do tamanho: = returndatasize ()
 devolver cópia de dados (ptr, 0, tamanho)
 mudar o resultado
 caso 0 { revert(ptr, size) }
            padrão { return(ptr, size) }
        }
    }
}

contrato SyntheticAsset {
 uint256 público subjacente preço do ativo;
 uint256 garantia pública;
 endereço proprietário público;
 mapeamento (endereço = > uint256) balanço sintético público;
 uint256 fornecimento sintético total público;

 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 retiraCollateral (uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

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

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

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

Nesta configuração, o contrato Proxy atua como uma porta de entrada 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 no Proxy, que delega chamadas para a implementação atual do SyntheticAsset, e da função Upgrade Implementation, que permite ao proprietário alterar o endereço de implementação para apontar para uma nova versão do SyntheticAsset.

Através desta lição, obterá a experiência necessária para gerir e atualizar contratos de ativos sintéticos, garantindo que permaneçam adaptáveis aos requisitos em evolução, mantendo a integridade e a segurança do contrato. Este conhecimento fundamental será fundamental à medida que nos aprofundamos em aspectos mais avançados da gestão de ativos sintéticos nas lições subsequentes. Fiquem atentos!