Instadapp/dsa-connectors
1
0
Fork 0
mirror of https://github.com/Instadapp/dsa-connectors.git synced 2024-07-29 22:37:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10 from InstaDApp/mapping-updates

Browse Source 
Add Compound Mapping
This commit is contained in:
Thrilok kumar 2021-03-19 21:55:03 +05:30 committed by GitHub
commit 3b01a50fd3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 371 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -4,7 +4,7 @@ Connectors are standard proxy logics contract that let DeFi Smart Account (DSA)
DSAs are powerful because they can easily be extended with connectors. Every new connector that is added is immediately usable by any developer building on top of DSAs. Connectors can either be base connectors to protocols, auth connectors, higher level connectors with more specific use cases like optimized lending, or connectors to native liquidity pools.
You can create a PR to request a support for specific protocol or external contracts. Following is the list of all the supported connectors. Following is the list of all the primary connectors used to cast spells:
You can create a PR to request a support for specific protocol or external contracts. The process to add a new connector is explained [here](docs/how-to-add-new-connector.md). Following is the list of all the supported connectors. Following is the list of all the primary connectors used to cast spells:
[Read this post to learn about getId and setId used in the connectors](https://discuss.instadapp.io/t/how-to-use-getid-setid/104)

41
contracts/connectors/compound/events.sol
View File

@ -1,13 +1,45 @@
pragma solidity ^0.7.0;
contract Events {
event LogDeposit(address indexed token, address cToken, uint256 tokenAmt, uint256 getId, uint256 setId);
event LogWithdraw(address indexed token, address cToken, uint256 tokenAmt, uint256 getId, uint256 setId);
event LogBorrow(address indexed token, address cToken, uint256 tokenAmt, uint256 getId, uint256 setId);
event LogPayback(address indexed token, address cToken, uint256 tokenAmt, uint256 getId, uint256 setId);
event LogDeposit(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 getId,
uint256 setId
);
event LogWithdraw(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 getId,
uint256 setId
);
event LogBorrow(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 getId,
uint256 setId
);
event LogPayback(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 getId,
uint256 setId
);
event LogDepositCToken(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 cTokenAmt,
@ -17,6 +49,7 @@ contract Events {
event LogWithdrawCToken(
address indexed token,
string tokenId,
address cToken,
uint256 tokenAmt,
uint256 cTokenAmt,

7
contracts/connectors/compound/helpers.sol
View File

@ -2,7 +2,7 @@ pragma solidity ^0.7.0;
import { DSMath } from "../../common/math.sol";
import { Basic } from "../../common/basic.sol";
import { ComptrollerInterface } from "./interface.sol";
import { ComptrollerInterface, CompoundMappingInterface } from "./interface.sol";
abstract contract Helpers is DSMath, Basic {
/**
@ -10,6 +10,11 @@ abstract contract Helpers is DSMath, Basic {
*/
ComptrollerInterface internal constant troller = ComptrollerInterface(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
/**
* @dev Compound Mapping
*/
CompoundMappingInterface internal constant compMapping = CompoundMappingInterface(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); // Update the address
/**
* @dev enter compound market
*/

13
contracts/connectors/compound/interface.sol
View File

@ -29,3 +29,16 @@ interface ComptrollerInterface {
function getAccountLiquidity(address account) external view returns (uint, uint, uint);
function claimComp(address) external;
}
interface CompoundMappingInterface {
function cTokenMapping(string calldata tokenId) external view returns (address);
function getMapping(string calldata tokenId) external view returns (address, address);
}
struct LiquidateData {
address tokenToPay;
address tokenInReturn;
address cTokenPay;
address cTokenColl;
CTokenInterface cTokenContract;
}

118
contracts/connectors/compound/main.sol
View File

@ -1,27 +1,28 @@
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import { TokenInterface } from "../../common/interfaces.sol";
import { Stores } from "../../common/stores.sol";
import { Helpers } from "./helpers.sol";
import { Events } from "./events.sol";
import { CETHInterface, CTokenInterface } from "./interface.sol";
import { CETHInterface, CTokenInterface, LiquidateData } from "./interface.sol";
abstract contract CompoundResolver is Events, Helpers {
/**
* @dev Deposit ETH/ERC20_Token.
* @param token token address to deposit.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to deposit.(For eg: ETH-A)
* @param amt token amount to deposit.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function deposit(
address token,
string calldata tokenId,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
enterMarket(cToken);
if (token == ethAddr) {
_amt = _amt == uint(-1) ? address(this).balance : _amt;
@ -34,25 +35,25 @@ abstract contract CompoundResolver is Events, Helpers {
}
setUint(setId, _amt);
_eventName = "LogDeposit(address,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, _amt, getId, setId);
_eventName = "LogDeposit(address,string,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, _amt, getId, setId);
}
/**
* @dev Withdraw ETH/ERC20_Token.
* @param token token address to withdraw.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to withdraw.(For eg: ETH-A)
* @param amt token amount to withdraw.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function withdraw(
address token,
string calldata tokenId,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
CTokenInterface cTokenContract = CTokenInterface(cToken);
if (_amt == uint(-1)) {
TokenInterface tokenContract = TokenInterface(token);
@ -65,48 +66,48 @@ abstract contract CompoundResolver is Events, Helpers {
}
setUint(setId, _amt);
_eventName = "LogWithdraw(address,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, _amt, getId, setId);
_eventName = "LogWithdraw(address,string,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, _amt, getId, setId);
}
/**
* @dev Borrow ETH/ERC20_Token.
* @param token token address to borrow.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to borrow.(For eg: DAI-A)
* @param amt token amount to borrow.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function borrow(
address token,
string calldata tokenId,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
enterMarket(cToken);
require(CTokenInterface(cToken).borrow(_amt) == 0, "borrow-failed");
setUint(setId, _amt);
_eventName = "LogBorrow(address,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, _amt, getId, setId);
_eventName = "LogBorrow(address,string,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, _amt, getId, setId);
}
/**
* @dev Payback borrowed ETH/ERC20_Token.
* @param token token address to payback.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to payback.(For eg: COMP-A)
* @param amt token amount to payback.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function payback(
address token,
string calldata tokenId,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
CTokenInterface cTokenContract = CTokenInterface(cToken);
_amt = _amt == uint(-1) ? cTokenContract.borrowBalanceCurrent(address(this)) : _amt;
@ -121,25 +122,25 @@ abstract contract CompoundResolver is Events, Helpers {
}
setUint(setId, _amt);
_eventName = "LogPayback(address,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, _amt, getId, setId);
_eventName = "LogPayback(address,string,address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, _amt, getId, setId);
}
/**
* @dev Deposit ETH/ERC20_Token.
* @param token token address to depositCToken.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to depositCToken.(For eg: DAI-A)
* @param amt token amount to depositCToken.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set ctoken amount at this ID in `InstaMemory` Contract.
*/
function depositCToken(
address token,
string calldata tokenId,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
enterMarket(cToken);
CTokenInterface ctokenContract = CTokenInterface(cToken);
@ -155,80 +156,91 @@ abstract contract CompoundResolver is Events, Helpers {
require(ctokenContract.mint(_amt) == 0, "deposit-ctoken-failed.");
}
uint finalBal = ctokenContract.balanceOf(address(this));
uint _cAmt = finalBal - initialBal;
setUint(setId, _cAmt);
uint _cAmt;
_eventName = "LogDepositCToken(address,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, _amt, _cAmt, getId, setId);
{
uint finalBal = ctokenContract.balanceOf(address(this));
finalBal - initialBal;
setUint(setId, _cAmt);
}
_eventName = "LogDepositCToken(address,string,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, _amt, _cAmt, getId, setId);
}
/**
* @dev Withdraw CETH/CERC20_Token using cToken Amt.
* @param token token address to withdraw CToken.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenId token id of the token to withdraw CToken.(For eg: ETH-A)
* @param cTokenAmt ctoken amount to withdrawCToken.
* @param getId Get ctoken amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function withdrawCToken(
address token,
string calldata tokenId,
uint cTokenAmt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _cAmt = getUint(getId, cTokenAmt);
address cToken = instaMapping.cTokenMapping(token);
(address token, address cToken) = compMapping.getMapping(tokenId);
CTokenInterface cTokenContract = CTokenInterface(cToken);
TokenInterface tokenContract = TokenInterface(token);
_cAmt = _cAmt == uint(-1) ? cTokenContract.balanceOf(address(this)) : _cAmt;
uint initialBal = token != ethAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
require(cTokenContract.redeem(_cAmt) == 0, "redeem-failed");
uint finalBal = token != ethAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
uint withdrawAmt;
{
uint initialBal = token != ethAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
require(cTokenContract.redeem(_cAmt) == 0, "redeem-failed");
uint finalBal = token != ethAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
withdrawAmt = sub(finalBal, initialBal);
}
uint withdrawAmt = sub(finalBal, initialBal);
setUint(setId, withdrawAmt);
_eventName = "LogWithdrawCToken(address,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode(token, cToken, withdrawAmt, _cAmt, getId, setId);
_eventName = "LogWithdrawCToken(address,string,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode(token, tokenId, cToken, withdrawAmt, _cAmt, getId, setId);
}
/**
* @dev Liquidate a position.
* @param borrower Borrower's Address.
* @param tokenToPay token address to pay for liquidation.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenInReturn token address to return for liquidation.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenIdToPay token id of the token to pay for liquidation.(For eg: ETH-A)
* @param tokenIdInReturn token id of the token to return for liquidation.(For eg: USDC-A)
* @param amt token amount to pay for liquidation.
* @param getId Get token amount at this ID from `InstaMemory` Contract.
* @param setId Set token amount at this ID in `InstaMemory` Contract.
*/
function liquidate(
address borrower,
address tokenToPay,
address tokenInReturn,
string calldata tokenIdToPay,
string calldata tokenIdInReturn,
uint amt,
uint getId,
uint setId
) external payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
address cTokenPay = instaMapping.cTokenMapping(tokenToPay);
address cTokenColl = instaMapping.cTokenMapping(tokenInReturn);
CTokenInterface cTokenContract = CTokenInterface(cTokenPay);
LiquidateData memory data;
(data.tokenToPay, data.cTokenPay) = compMapping.getMapping(tokenIdToPay);
(data.tokenInReturn, data.cTokenColl) = compMapping.getMapping(tokenIdInReturn);
data.cTokenContract = CTokenInterface(data.cTokenPay);
{
(,, uint shortfal) = troller.getAccountLiquidity(borrower);
require(shortfal != 0, "account-cannot-be-liquidated");
_amt = _amt == uint(-1) ? data.cTokenContract.borrowBalanceCurrent(borrower) : _amt;
}
_amt = _amt == uint(-1) ? cTokenContract.borrowBalanceCurrent(borrower) : _amt;
if (tokenToPay == ethAddr) {
if (data.tokenToPay == ethAddr) {
require(address(this).balance >= _amt, "not-enought-eth");
CETHInterface(cTokenPay).liquidateBorrow{value: _amt}(borrower, cTokenColl);
CETHInterface(data.cTokenPay).liquidateBorrow{value: _amt}(borrower, data.cTokenColl);
} else {
TokenInterface tokenContract = TokenInterface(tokenToPay);
TokenInterface tokenContract = TokenInterface(data.tokenToPay);
require(tokenContract.balanceOf(address(this)) >= _amt, "not-enough-token");
tokenContract.approve(cTokenPay, _amt);
require(cTokenContract.liquidateBorrow(borrower, _amt, cTokenColl) == 0, "liquidate-failed");
tokenContract.approve(data.cTokenPay, _amt);
require(data.cTokenContract.liquidateBorrow(borrower, _amt, data.cTokenColl) == 0, "liquidate-failed");
}
setUint(setId, _amt);
@ -236,8 +248,8 @@ abstract contract CompoundResolver is Events, Helpers {
_eventName = "LogLiquidate(address,address,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode(
address(this),
tokenToPay,
tokenInReturn,
data.tokenToPay,
data.tokenInReturn,
_amt,
getId,
setId

137
contracts/mapping/compound.sol Normal file
View File

@ -0,0 +1,137 @@
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
interface IndexInterface {
function master() external view returns (address);
}
interface ConnectorsInterface {
function chief(address) external view returns (bool);
}
interface CTokenInterface {
function isCToken() external view returns (bool);
function underlying() external view returns (address);
}
abstract contract Helpers {
struct TokenMap {
address ctoken;
address token;
}
event LogCTokensAdded(string[] names, address[] tokens, address[] ctokens);
event LogCTokensUpdated(string[] names, address[] tokens, address[] ctokens);
ConnectorsInterface public immutable connectors;
// InstaIndex Address.
IndexInterface public constant instaIndex = IndexInterface(0x2971AdFa57b20E5a416aE5a708A8655A9c74f723);
address public constant ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
mapping (string => TokenMap) public cTokenMapping;
modifier isChief {
require(msg.sender == instaIndex.master() || connectors.chief(msg.sender), "not-an-chief");
_;
}
constructor(address _connectors) {
connectors = ConnectorsInterface(_connectors);
}
function _addCtokenMapping(
string[] memory _names,
address[] memory _tokens,
address[] memory _ctokens
) internal {
require(_names.length == _tokens.length, "addCtokenMapping: not same length");
require(_names.length == _ctokens.length, "addCtokenMapping: not same length");
for (uint i = 0; i < _ctokens.length; i++) {
TokenMap memory _data = cTokenMapping[_names[i]];
require(_data.ctoken == address(0), "addCtokenMapping: mapping added already");
require(_data.token == address(0), "addCtokenMapping: mapping added already");
require(_tokens[i] != address(0), "addCtokenMapping: _tokens address not vaild");
require(_ctokens[i] != address(0), "addCtokenMapping: _ctokens address not vaild");
CTokenInterface _ctokenContract = CTokenInterface(_ctokens[i]);
require(_ctokenContract.isCToken(), "addCtokenMapping: not a cToken");
if (_tokens[i] != ethAddr) {
require(_ctokenContract.underlying() == _tokens[i], "addCtokenMapping: mapping mismatch");
}
cTokenMapping[_names[i]] = TokenMap(
_ctokens[i],
_tokens[i]
);
}
emit LogCTokensAdded(_names, _tokens, _ctokens);
}
function updateCtokenMapping(
string[] calldata _names,
address[] memory _tokens,
address[] calldata _ctokens
) external {
require(msg.sender == instaIndex.master(), "not-master");
require(_names.length == _tokens.length, "updateCtokenMapping: not same length");
require(_names.length == _ctokens.length, "updateCtokenMapping: not same length");
for (uint i = 0; i < _ctokens.length; i++) {
TokenMap memory _data = cTokenMapping[_names[i]];
require(_data.ctoken != address(0), "updateCtokenMapping: mapping does not exist");
require(_data.token != address(0), "updateCtokenMapping: mapping does not exist");
require(_tokens[i] != address(0), "updateCtokenMapping: _tokens address not vaild");
require(_ctokens[i] != address(0), "updateCtokenMapping: _ctokens address not vaild");
CTokenInterface _ctokenContract = CTokenInterface(_ctokens[i]);
require(_ctokenContract.isCToken(), "updateCtokenMapping: not a cToken");
if (_tokens[i] != ethAddr) {
require(_ctokenContract.underlying() == _tokens[i], "addCtokenMapping: mapping mismatch");
}
cTokenMapping[_names[i]] = TokenMap(
_ctokens[i],
_tokens[i]
);
}
emit LogCTokensUpdated(_names, _tokens, _ctokens);
}
function addCtokenMapping(
string[] memory _names,
address[] memory _tokens,
address[] memory _ctokens
) external isChief {
_addCtokenMapping(_names, _tokens, _ctokens);
}
function getMapping(string memory _tokenId) external view returns (address, address) {
TokenMap memory _data = cTokenMapping[_tokenId];
return (_data.token, _data.ctoken);
}
}
contract InstaCompoundMapping is Helpers {
string constant public name = "Compound-Mapping-v1";
constructor(
address _connectors,
string[] memory _ctokenNames,
address[] memory _tokens,
address[] memory _ctokens
) Helpers(_connectors) {
_addCtokenMapping(_ctokenNames, _tokens, _ctokens);
}
}

43
docs/how-to-add-new-connector.md Normal file
View File

@ -0,0 +1,43 @@
## How to add a new connector
You can create a new PR to add a new connector. To get the PR merged, certain requirements needs to be met which will be explained here.
### New connector should follow the current directory structure
Common files for all connectors are in `contracts/common` directory.
* `math.sol` has methods for mathematical operations (`DSMath`)
* `interfaces.sol` contains the common interfaces
* `TokenInterface` for ERC-20 interface including WETH
* `stores.sol` contains the global constants as well as methods `getId` & `setId` (`Stores`)
* `basic.sol` inherits `DSMath` & `Stores` contracts. This contains few details explained below
* Wrapping & unwrapping ETH (`convertEthToWeth` & `convertWethToEth`)
* Getting token & ETH balance of DSA
Connectors are under `contracts/connectors` directory, and should be formatted as follows:
* Connector events should be in a separate contract: `events.sol`
* Interfaces should be defined in a seperate file: `interface.sol`
* If the connector has helper methods & constants (including interface instances), this should be defined in a separate file: `helpers.sol`
* `Helpers` contract should inherit `Basic` contract from common directory
* If the connector doesn't have any helper methods, the main contract should inherit `Basic` contract
* The main logic of the contract should be under `main.sol`, and the contract should inherit `Helpers` (if exists, otherwise `Basic`) & `Events`
Few things to consider while writing the connector:
* Connector should have a public string declared `name`, which will be the name of the connector. This will be versioned. Ex: `Compound-v1`
* User interacting methods (`external` methods) will not be emitting events, rather the methods will be returning 2 variables:
* `_eventName` of `string` type: This will be the event signture defined in the `Events` contract. Ex: `LogDeposit(address,address,uint256,uint256,uint256)`
* `_eventParam` of `bytes` type: This will be the abi encoded event parameters
* The contracts should not have `selfdestruct()`
* The contracts should not have `delegatecall()`
* Use `uint(-1)` for maximum amount everywhere
* Use `ethAddr` (declared in `Stores`) to denote Ethereum (non-ERC20)
* Use `address(this)` instead of `msg.sender` for fetching balance on-chain, etc
* Only `approve()` limited amount while giving ERC20 allowance, which strictly needs to be 0 by the end of the spell.
* Use `getUint()` (declared in `Stores`) for getting value that saved from previous spell
* Use `setUint()` (declared in `Stores`) for setting value to save for the future spell
### Support
If you can't find something you're looking for or have any questions, ask them at our developers community on [Discord](https://discord.gg/83vvrnY) or simply send an [Email](mailto:info@instadapp.io).

69
scripts/deployCompoundMapping.js Normal file
View File

@ -0,0 +1,69 @@
const hre = require("hardhat");
const { ethers } = hre;
async function main() {
// TODO - Replace with actual contract address after deployment
const CONNECTORS_V2 = "0x2971AdFa57b20E5a416aE5a708A8655A9c74f723";
const ctokenMapping = {
"ETH-A": "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5",
"BAT-A": "0x6c8c6b02e7b2be14d4fa6022dfd6d75921d90e4e",
"COMP-A": "0x70e36f6bf80a52b3b46b3af8e106cc0ed743e8e4",
"DAI-A": "0x5d3a536e4d6dbd6114cc1ead35777bab948e3643",
"REP-A": "0x158079ee67fce2f58472a96584a73c7ab9ac95c1",
"UNI-A": "0x35a18000230da775cac24873d00ff85bccded550",
"USDC-A": "0x39aa39c021dfbae8fac545936693ac917d5e7563",
"USDT-A": "0xf650c3d88d12db855b8bf7d11be6c55a4e07dcc9",
"WBTC-A": "0xc11b1268c1a384e55c48c2391d8d480264a3a7f4",
"ZRX-A": "0xb3319f5d18bc0d84dd1b4825dcde5d5f7266d407"
}
const tokenMapping = {
"ETH-A": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"BAT-A": "0x0D8775F648430679A709E98d2b0Cb6250d2887EF",
"COMP-A": "0xc00e94cb662c3520282e6f5717214004a7f26888",
"DAI-A": "0x6b175474e89094c44da98b954eedeac495271d0f",
"REP-A": "0x1985365e9f78359a9B6AD760e32412f4a445E862",
"UNI-A": "0x221657776846890989a759ba2973e427dff5c9bb",
"USDC-A": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"USDT-A": "0xdac17f958d2ee523a2206206994597c13d831ec7",
"WBTC-A": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
"ZRX-A": "0xe41d2489571d322189246dafa5ebde1f4699f498"
}
const Mapping = await ethers.getContractFactory("InstaCompoundMapping");
const mapping = await Mapping.deploy(
CONNECTORS_V2,
Object.keys(ctokenMapping),
Object.values(tokenMapping),
Object.values(ctokenMapping)
);
await mapping.deployed();
console.log(`InstaCompoundMapping Deployed: ${mapping.address}`);
try {
await hre.run("verify:verify", {
address: mapping.address,
constructorArguments: [
CONNECTORS_V2,
Object.keys(ctokenMapping),
Object.values(tokenMapping),
Object.values(ctokenMapping)
]
}
)
} catch (error) {
console.log(`Failed to verify: InstaCompoundMapping@${mapping.address}`)
console.log(error)
console.log()
}
}
main()
.then(() => process.exit(0))
.catch(error => {
console.error(error);
process.exit(1);
});