adi-deploy/src/templates/SimpleOneToManyAdapterUpdate.sol at main · aave-dao/adi-deploy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import './BaseAdaptersUpdate.sol';

/**
 * @title Base payload aDI and bridge adapters update
 * @author BGD Labs @bgdlabs
 * @dev This payload should be used when wanting to substitute an adapter that receives and also forwards
 */
abstract contract SimpleOneToManyAdapterUpdate is BaseAdaptersUpdate {
  struct ConstructorInput {
    address ccc;
    address adapterToRemove;
    address newAdapter;
  }

  struct DestinationAdaptersInput {
    address adapter;
    uint256 chainId;
  }

  address public immutable ADAPTER_TO_REMOVE;
  address public immutable NEW_ADAPTER;

  constructor(ConstructorInput memory constructorInput) BaseAdaptersUpdate(constructorInput.ccc) {
    ADAPTER_TO_REMOVE = constructorInput.adapterToRemove;
    NEW_ADAPTER = constructorInput.newAdapter;
  }

  /**
   * @notice method used to get the adapters for the destination chain ids
   * @return array of adapter - destination chain pairs
   */
  function getDestinationAdapters()
    public
    pure
    virtual
    returns (DestinationAdaptersInput[] memory)
  {
    return new DestinationAdaptersInput[](0);
  }

  /**
   * @notice method to get the chains that a new adapter will receive messages from
   * @return an array of chain ids
   */
  function getChainsToReceive() public pure virtual returns (uint256[] memory);

  /**
   * @notice method to get a list of chain ids that the new adapter will use to send messages to
   * @return an array of chain ids
   */
  function getChainsToSend() public pure virtual returns (uint256[] memory) {
    DestinationAdaptersInput[] memory destinationAdapters = getDestinationAdapters();
    uint256[] memory chainsToSend = new uint256[](destinationAdapters.length);
    for (uint256 i = 0; i < destinationAdapters.length; i++) {
      chainsToSend[i] = destinationAdapters[i].chainId;
    }
    return chainsToSend;
  }

  /// @inheritdoc IBaseReceiverAdaptersUpdate
  function getReceiverBridgeAdaptersToRemove()
    public
    view
    virtual
    override
    returns (ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[] memory)
  {
    if (ADAPTER_TO_REMOVE != address(0)) {
      // remove old Receiver bridge adapter
      ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[]
        memory bridgeAdaptersToRemove = new ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[](
          1
        );

      bridgeAdaptersToRemove[0] = ICrossChainReceiver.ReceiverBridgeAdapterConfigInput({
        bridgeAdapter: ADAPTER_TO_REMOVE,
        chainIds: getChainsToReceive()
      });

      return bridgeAdaptersToRemove;
    } else {
      return new ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[](0);
    }
  }

  /// @inheritdoc IBaseForwarderAdaptersUpdate
  function getForwarderBridgeAdaptersToRemove()
    public
    view
    virtual
    override
    returns (ICrossChainForwarder.BridgeAdapterToDisable[] memory)
  {
    if (ADAPTER_TO_REMOVE != address(0)) {
      ICrossChainForwarder.BridgeAdapterToDisable[]
        memory forwarderAdaptersToRemove = new ICrossChainForwarder.BridgeAdapterToDisable[](1);

      forwarderAdaptersToRemove[0] = ICrossChainForwarder.BridgeAdapterToDisable({
        bridgeAdapter: ADAPTER_TO_REMOVE,
        chainIds: getChainsToSend()
      });

      return forwarderAdaptersToRemove;
    } else {
      return new ICrossChainForwarder.BridgeAdapterToDisable[](0);
    }
  }

  /// @inheritdoc IBaseReceiverAdaptersUpdate
  function getReceiverBridgeAdaptersToAllow()
    public
    view
    virtual
    override
    returns (ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[] memory)
  {
    if (NEW_ADAPTER != address(0)) {
      ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[]
        memory bridgeAdapterConfig = new ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[](1);

      bridgeAdapterConfig[0] = ICrossChainReceiver.ReceiverBridgeAdapterConfigInput({
        bridgeAdapter: NEW_ADAPTER,
        chainIds: getChainsToReceive()
      });

      return bridgeAdapterConfig;
    } else {
      return new ICrossChainReceiver.ReceiverBridgeAdapterConfigInput[](0);
    }
  }

  /// @inheritdoc IBaseForwarderAdaptersUpdate
  function getForwarderBridgeAdaptersToEnable()
    public
    view
    virtual
    override
    returns (ICrossChainForwarder.ForwarderBridgeAdapterConfigInput[] memory)
  {
    DestinationAdaptersInput[] memory destinationAdapters = getDestinationAdapters();

    ICrossChainForwarder.ForwarderBridgeAdapterConfigInput[]
      memory bridgeAdaptersToEnable = new ICrossChainForwarder.ForwarderBridgeAdapterConfigInput[](
        destinationAdapters.length
      );

    for (uint256 i = 0; i < destinationAdapters.length; i++) {
      bridgeAdaptersToEnable[i] = ICrossChainForwarder.ForwarderBridgeAdapterConfigInput({
        currentChainBridgeAdapter: NEW_ADAPTER,
        destinationBridgeAdapter: destinationAdapters[i].adapter,
        destinationChainId: destinationAdapters[i].chainId
      });
    }

    return bridgeAdaptersToEnable;
  }
}