Added Fantom connectors

contracts/fantom/common/basic.sol

@@ -0,0 +1,54 @@
+pragma solidity ^0.7.0;
+
+import { TokenInterface } from "./interfaces.sol";
+import { Stores } from "./stores.sol";
+import { DSMath } from "./math.sol";
+
+abstract contract Basic is DSMath, Stores {
+
+    function convert18ToDec(uint _dec, uint256 _amt) internal pure returns (uint256 amt) {
+        amt = (_amt / 10 ** (18 - _dec));
+    }
+
+    function convertTo18(uint _dec, uint256 _amt) internal pure returns (uint256 amt) {
+        amt = mul(_amt, 10 ** (18 - _dec));
+    }
+
+    function getTokenBal(TokenInterface token) internal view returns(uint _amt) {
+        _amt = address(token) == ftmAddr ? address(this).balance : token.balanceOf(address(this));
+    }
+
+    function getTokensDec(TokenInterface buyAddr, TokenInterface sellAddr) internal view returns(uint buyDec, uint sellDec) {
+        buyDec = address(buyAddr) == ftmAddr ?  18 : buyAddr.decimals();
+        sellDec = address(sellAddr) == ftmAddr ?  18 : sellAddr.decimals();
+    }
+
+    function encodeEvent(string memory eventName, bytes memory eventParam) internal pure returns (bytes memory) {
+        return abi.encode(eventName, eventParam);
+    }
+
+    function approve(TokenInterface token, address spender, uint256 amount) internal {
+        try token.approve(spender, amount) {
+
+        } catch {
+            token.approve(spender, 0);
+            token.approve(spender, amount);
+        }
+    }
+
+    function changeftmAddress(address buy, address sell) internal pure returns(TokenInterface _buy, TokenInterface _sell){
+        _buy = buy == ftmAddr ? TokenInterface(wftmAddr) : TokenInterface(buy);
+        _sell = sell == ftmAddr ? TokenInterface(wftmAddr) : TokenInterface(sell);
+    }
+
+    function convertEthToWeth(bool isEth, TokenInterface token, uint amount) internal {
+        if(isEth) token.deposit{value: amount}();
+    }
+
+    function convertWethToEth(bool isEth, TokenInterface token, uint amount) internal {
+       if(isEth) {
+            approve(token, address(token), amount);
+            token.withdraw(amount);
+        }
+    }
+} 

contracts/fantom/common/interfaces.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.7.0;
+
+interface TokenInterface {
+    function approve(address, uint256) external;
+    function transfer(address, uint) external;
+    function transferFrom(address, address, uint) external;
+    function deposit() external payable;
+    function withdraw(uint) external;
+    function balanceOf(address) external view returns (uint);
+    function decimals() external view returns (uint);
+}
+
+interface MemoryInterface {
+    function getUint(uint id) external returns (uint num);
+    function setUint(uint id, uint val) external;
+}
+
+interface AccountInterface {
+    function enable(address) external;
+    function disable(address) external;
+    function isAuth(address) external view returns (bool);
+}

contracts/fantom/common/math.sol

@@ -0,0 +1,50 @@
+pragma solidity ^0.7.0;
+
+import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
+
+contract DSMath {
+  uint constant WAD = 10 ** 18;
+  uint constant RAY = 10 ** 27;
+
+  function add(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.add(x, y);
+  }
+
+  function sub(uint x, uint y) internal virtual pure returns (uint z) {
+    z = SafeMath.sub(x, y);
+  }
+
+  function mul(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.mul(x, y);
+  }
+
+  function div(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.div(x, y);
+  }
+
+  function wmul(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD;
+  }
+
+  function wdiv(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y;
+  }
+
+  function rdiv(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y;
+  }
+
+  function rmul(uint x, uint y) internal pure returns (uint z) {
+    z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY;
+  }
+
+  function toInt(uint x) internal pure returns (int y) {
+    y = int(x);
+    require(y >= 0, "int-overflow");
+  }
+
+  function toRad(uint wad) internal pure returns (uint rad) {
+    rad = mul(wad, 10 ** 27);
+  }
+
+}

contracts/fantom/common/stores.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.7.0;
+
+import { MemoryInterface } from "./interfaces.sol";
+
+
+abstract contract Stores {
+
+  /**
+   * @dev Return FTM address
+   */
+  address constant internal ftmAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+  /**
+   * @dev Return Wrapped FTM address
+   */
+  address constant internal wftmAddr = 0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83;
+
+  /**
+   * @dev Return memory variable address
+   */
+  MemoryInterface constant internal instaMemory = MemoryInterface(0x56439117379A53bE3CC2C55217251e2481B7a1C8);
+
+  /**
+   * @dev Get Uint value from InstaMemory Contract.
+   */
+  function getUint(uint getId, uint val) internal returns (uint returnVal) {
+    returnVal = getId == 0 ? val : instaMemory.getUint(getId);
+  }
+
+  /**
+  * @dev Set Uint value in InstaMemory Contract.
+  */
+  function setUint(uint setId, uint val) virtual internal {
+    if (setId != 0) instaMemory.setUint(setId, val);
+  }
+
+}

contracts/fantom/connectors/authority/events.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogAddAuth(address indexed _msgSender, address indexed _authority);
+    event LogRemoveAuth(address indexed _msgSender, address indexed _authority);
+}

contracts/fantom/connectors/authority/helpers.sol

@@ -0,0 +1,15 @@
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { ListInterface } from "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+    ListInterface internal constant listContract = ListInterface(0x3565F6057b7fFE36984779A507fC87b31EFb0f09);
+
+    function checkAuthCount() internal view returns (uint count) {
+        uint64 accountId = listContract.accountID(address(this));
+        count = listContract.accountLink(accountId).count;
+    }
+}

contracts/fantom/connectors/authority/interface.sol

@@ -0,0 +1,13 @@
+pragma solidity ^0.7.0;
+pragma experimental ABIEncoderV2;
+
+interface ListInterface {
+    struct AccountLink {
+        address first;
+        address last;
+        uint64 count;
+    }
+
+    function accountID(address) external view returns (uint64);
+    function accountLink(uint64) external view returns (AccountLink memory);
+}

contracts/fantom/connectors/authority/main.sol

@@ -0,0 +1,45 @@
+pragma solidity ^0.7.0;
+
+/**
+ * @title Authority.
+ * @dev Manage Authorities to DSA.
+ */
+ 
+import { AccountInterface } from "../../common/interfaces.sol";
+import { Helpers } from "./helpers.sol";
+import { Events } from "./events.sol";
+
+abstract contract AuthorityResolver is Events, Helpers {
+    /**
+     * @dev Add New authority
+     * @notice Add an address as account authority
+     * @param authority The authority Address.
+     */
+    function add(
+        address authority
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        AccountInterface(address(this)).enable(authority);
+
+        _eventName = "LogAddAuth(address,address)";
+        _eventParam = abi.encode(msg.sender, authority);
+    }
+
+    /**
+     * @dev Remove authority
+     * @notice Remove an address as account authority
+     * @param authority The authority Address.
+     */
+    function remove(
+        address authority
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        require(checkAuthCount() > 1, "Removing-all-authorities");
+        AccountInterface(address(this)).disable(authority);
+
+        _eventName = "LogRemoveAuth(address,address)";
+        _eventParam = abi.encode(msg.sender, authority);
+    }
+}
+
+contract ConnectV2AuthFantom is AuthorityResolver {
+    string public constant name = "Auth-v1";
+}

contracts/fantom/connectors/basic/events.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogDeposit(address indexed erc20, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogWithdraw(address indexed erc20, uint256 tokenAmt, address indexed to, uint256 getId, uint256 setId);
+}

contracts/fantom/connectors/basic/main.sol

@@ -0,0 +1,82 @@
+pragma solidity ^0.7.0;
+
+
+/**
+ * @title Basic.
+ * @dev Deposit & Withdraw from DSA.
+ */
+
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { Events } from "./events.sol";
+
+abstract contract BasicResolver is Events, DSMath, Basic {
+    using SafeERC20 for IERC20;
+
+    /**
+     * @dev Deposit Assets To Smart Account.
+     * @notice Deposit a token to DSA
+     * @param token The address of the token to deposit. (For MATIC: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param amt The amount of tokens to deposit. (For max: `uint256(-1)` (Not valid for MATIC))
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of tokens deposited.
+     */
+    function deposit(
+        address token,
+        uint256 amt,
+        uint256 getId,
+        uint256 setId
+    ) public payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        if (token != ftmAddr) {
+            IERC20 tokenContract = IERC20(token);
+            _amt = _amt == uint(-1) ? tokenContract.balanceOf(msg.sender) : _amt;
+            tokenContract.safeTransferFrom(msg.sender, address(this), _amt);
+        } else {
+            require(msg.value == _amt || _amt == uint(-1), "invalid-ether-amount");
+            _amt = msg.value;
+        }
+        setUint(setId, _amt);
+
+        _eventName = "LogDeposit(address,uint256,uint256,uint256)";
+        _eventParam = abi.encode(token, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw Assets from Smart  Account
+     * @notice Withdraw a token from DSA
+     * @param token The address of the token to withdraw. (For MATIC: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param amt The amount of tokens to withdraw. (For max: `uint256(-1)`)
+     * @param to The address to receive the token upon withdrawal
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of tokens withdrawn.
+     */
+    function withdraw(
+        address token,
+        uint amt,
+        address payable to,
+        uint getId,
+        uint setId
+    ) public payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        if (token == ftmAddr) {
+            _amt = _amt == uint(-1) ? address(this).balance : _amt;
+            to.call{value: _amt}("");
+        } else {
+            IERC20 tokenContract = IERC20(token);
+            _amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt;
+            tokenContract.safeTransfer(to, _amt);
+        }
+        setUint(setId, _amt);
+
+        _eventName = "LogWithdraw(address,uint256,address,uint256,uint256)";
+        _eventParam = abi.encode(token, _amt, to, getId, setId);
+    }
+}
+
+contract ConnectV2BasicFantom is BasicResolver {
+    string constant public name = "Basic-v1";
+}

contracts/fantom/connectors/wftm/events.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogDeposit(uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogWithdraw(uint256 tokenAmt, uint256 getId, uint256 setId);
+}

contracts/fantom/connectors/wftm/helpers.sol

@@ -0,0 +1,8 @@
+pragma solidity ^0.7.0;
+
+import { TokenInterface } from "../../common/interfaces.sol";
+
+
+abstract contract Helpers  {
+    TokenInterface constant internal wftmContract = TokenInterface(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
+}

contracts/fantom/connectors/wftm/main.sol

@@ -0,0 +1,65 @@
+pragma solidity ^0.7.0;
+
+/**
+ * @title WETH.
+ * @dev Wrap and Unwrap WETH.
+ */
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { Events } from "./events.sol";
+import { Helpers } from "./helpers.sol";
+
+abstract contract Resolver is Events, DSMath, Basic, Helpers {
+
+    /**
+     * @dev Deposit ETH into WETH.
+     * @notice Wrap ETH into WETH
+     * @param amt The amount of ETH to deposit. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of ETH deposited.
+     */
+    function deposit(
+        uint256 amt,
+        uint256 getId,
+        uint256 setId
+    ) public payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+
+        _amt = _amt == uint(-1) ? address(this).balance : _amt;
+        wftmContract.deposit{value: _amt}();
+        
+        setUint(setId, _amt);
+
+        _eventName = "LogDeposit(uint256,uint256,uint256)";
+        _eventParam = abi.encode(_amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw ETH from WETH from Smart  Account
+     * @notice Unwrap ETH from WETH
+     * @param amt The amount of weth to withdraw. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of ETH withdrawn.
+     */
+    function withdraw(
+        uint amt,
+        uint getId,
+        uint setId
+    ) public payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+
+        _amt = _amt == uint(-1) ? wftmContract.balanceOf(address(this)) : _amt;
+        approve(wftmContract, wftmAddr, _amt);
+        wftmContract.withdraw(_amt);
+
+        setUint(setId, _amt);
+
+        _eventName = "LogWithdraw(uint256,uint256,uint256)";
+        _eventParam = abi.encode(_amt, getId, setId);
+    }
+}
+
+contract ConnectV2WETHArbitrum is Resolver {
+    string constant public name = "WETH-v1.0";
+}

hardhat.config.js

@@ -74,6 +74,13 @@ module.exports = {
       timeout: 150000,
       gasPrice: parseInt(utils.parseUnits("2", "gwei")),
     },
+    fantom: {
+      chainId: 250,
+      url: `https://rpc.ftm.tools/`,
+      accounts: [`0x${PRIVATE_KEY}`],
+      timeout: 150000,
+      gasPrice: parseInt(utils.parseUnits("250", "gwei"))
+    }
   },
   etherscan: {
     apiKey: process.env.ETHERSCAN_API_KEY,

scripts/deploy.js

@@ -8,19 +8,19 @@ async function main() {
     const wallet = accounts[0]
     
     const connectMapping = {
-        '1INCH-A': 'ConnectV2OneInch',
-        '1INCH-B': 'ConnectV2OneProto',
-        'AAVE-V1-A': 'ConnectV2AaveV1',
-        'AAVE-V2-A': 'ConnectV2AaveV2',
-        'AUTHORITY-A': 'ConnectV2Auth',
-        'BASIC-A': 'ConnectV2Basic',
-        'COMP-A': 'ConnectV2COMP',
-        'COMPOUND-A': 'ConnectV2Compound',
-        'DYDX-A': 'ConnectV2Dydx',
-        'FEE-A': 'ConnectV2Fee',
-        'GELATO-A': 'ConnectV2Gelato',
-        'MAKERDAO-A': 'ConnectV2Maker',
-        'UNISWAP-A': 'ConnectV2UniswapV2'
+        // '1INCH-A': 'ConnectV2OneInch',
+        // '1INCH-B': 'ConnectV2OneProto',
+        // 'AAVE-V1-A': 'ConnectV2AaveV1',
+        // 'AAVE-V2-A': 'ConnectV2AaveV2',
+        'AUTHORITY-A': 'ConnectV2AuthFantom',
+        'BASIC-A': 'ConnectV2BasicFantom',
+        // 'COMP-A': 'ConnectV2COMP',
+        // 'COMPOUND-A': 'ConnectV2Compound',
+        // 'DYDX-A': 'ConnectV2Dydx',
+        // 'FEE-A': 'ConnectV2Fee',
+        // 'GELATO-A': 'ConnectV2Gelato',
+        // 'MAKERDAO-A': 'ConnectV2Maker',
+        // 'UNISWAP-A': 'ConnectV2UniswapV2'
     }
     
     const addressMapping = {}

scripts/deployConnector.js

@@ -2,20 +2,21 @@ const hre = require("hardhat");
 const { ethers } = hre;
 
 module.exports = async (connectorName) => {
-    const Connector = await ethers.getContractFactory(connectorName);
-    const connector = await Connector.deploy();
-    await connector.deployed();
+    // const Connector = await ethers.getContractFactory(connectorName);
+    // const connector = await Connector.deploy();
+    // await connector.deployed();
 
-    console.log(`${connectorName} Deployed: ${connector.address}`);
+    // console.log(`${connectorName} Deployed: ${connector.address}`);
 
     try {
         await hre.run("verify:verify", {
-            address: connector.address,
-            constructorArguments: []
+            address: "0x9926955e0dd681dc303370c52f4ad0a4dd061687",
+            constructorArguments: [],
+            contract: "contracts/fantom/connectors/basic/main.sol:ConnectV2BasicFantom"
           }
         )
     } catch (error) {
-        console.log(`Failed to verify: ${connectorName}@${connector.address}`)
+        // console.log(`Failed to verify: ${connectorName}@${connector.address}`)
         console.log(error)
         console.log()
     }