Updated Smart Contract Logics.

contracts/MoatAddress.sol

@@ -1,6 +1,3 @@
-// Implement the proper governance mechanism to update the admin address like admin have rights to upgrade anything but not just "admin". Governance will be used to set admin address.
-// Or keep AllowedResolver also in MoatAddress contract
-
 pragma solidity ^0.4.24;
 
 
@@ -9,6 +6,9 @@ contract AddressRegistry {
     event AddressChanged(string name, address target);
     mapping(bytes32 => address) internal addressRegistry;
 
+    // Resolver Contract Addresses >> Asset Owner Address >> Bool
+    mapping(address => mapping(address => bool)) allowedResolver;
+
     modifier onlyAdmin() {
         require(
             msg.sender == getAddr("admin"),
@@ -31,14 +31,11 @@ contract AddressRegistry {
         require(addr != address(0), "Not a valid address.");
     }
 
-    // Contract Address >> Asset Owner Address >> Bool
+    function approveResolver() public {
-    mapping(address => mapping(address => bool)) allowedResolver;
-
-    function allowContract() public {
         allowedResolver[getAddr("resolver")][msg.sender] = true;
     }
 
-    function disallowContract() public {
+    function disapproveResolver() public {
         allowedResolver[getAddr("resolver")][msg.sender] = false;
     }
 

contracts/MoatAsset.sol

@@ -1,6 +1,6 @@
 // Allow ERC20 deposits
 // withdraw the extra assets other than global balance (in case anyone donated for free) and then no need for seperate brokerage calculation
-// how the balance of tokens with less than 18 decimals are stored
+// IMPORTANT CHECK - how the balance of tokens with less than 18 decimals are stored. Factor it.
 // update the balance along with "transferAssets" functions and also check the for onlyAllowedResolver
 
 pragma solidity ^0.4.24;
@@ -13,6 +13,7 @@ interface AddressRegistry {
 interface token {
     function approve(address spender, uint256 value) external returns (bool);
     function transfer(address receiver, uint amount) external returns (bool);
+    function transferFrom(address from, address to, uint amount) external returns (bool);
 }
 
 
@@ -53,14 +54,20 @@ contract AssetDB is Registry {
 
     function getBalance(
         address assetHolder,
-        address token
+        address tokenAddr
     ) public view returns (uint256 balance)
     {
-        balance = balances[assetHolder][token];
+        balance = balances[assetHolder][tokenAddr];
     }
 
-    function deposit() public payable {
+    function deposit(address tknAddr, uint amount) public payable {
-        balances[msg.sender][eth] += msg.value;
+        if (msg.value > 0) {
+            balances[msg.sender][eth] += msg.value;
+        } else {
+            token tokenFunctions = token(tknAddr);
+            tokenFunctions.transferFrom(msg.sender, address(this), amount);
+            balances[msg.sender][eth] += msg.value;
+        }
     }
 
     function withdraw(address addr, uint amt) public {
@@ -78,29 +85,29 @@ contract AssetDB is Registry {
         address tokenAddr,
         uint amt,
         bool add,
-        address target
+        address user
-    ) public onlyAllowedResolver(target)
+    ) public onlyAllowedResolver(user)
     {
         if (add) {
-            balances[target][tokenAddr] += amt;
+            balances[user][tokenAddr] += amt;
         } else {
-            balances[target][tokenAddr] -= amt;
+            balances[user][tokenAddr] -= amt;
         }
     }
 
-    // function transferAssets(
+    function transferAssets(
-    //     address tokenAddress,
+        address tokenAddress,
-    //     uint amount,
+        uint amount,
-    //     address sendTo
+        address sendTo
-    // ) public onlyAllowedResolver 
+    ) public onlyAllowedResolver 
-    // {
+    {
-    //     if (tokenAddress == eth) {
+        if (tokenAddress == eth) {
-    //         sendTo.transfer(amount);
+            sendTo.transfer(amount);
-    //     } else {
+        } else {
-    //         token tokenFunctions = token(tokenAddress);
+            token tokenFunctions = token(tokenAddress);
-    //         tokenFunctions.transfer(sendTo, amount);
+            tokenFunctions.transfer(sendTo, amount);
-    //     }
+        }
-    // }
+    }
 
 }
 
@@ -111,8 +118,9 @@ contract MoatAsset is AssetDB {
         registryAddress = rAddr;
     }
 
-    // received ether directly from protocols like Kyber Network
     // emit an event atleast
-    function () public payable {}
+    function () public payable {
+        deposit(eth);
+    }
 
 }

contracts/MoatResolver.sol

@@ -1,5 +1,121 @@
-// Global Freeze Varaible
+// Global Freeze Variable
-
+// no more than 10 ETH allowed as of now
 // withdraw store the 0.5% on the contract itself and can be withdrawn by admin addresses
-// this is the logic contract - stores nothing
+
-// https://bitbucket.org/Sowmay/resolver-dex/src/master/contracts/MoatResolver.sol
+pragma solidity ^0.4.24;
+
+interface token {
+    function approve(address spender, uint256 value) external returns (bool);
+    function transfer(address receiver, uint amount) external returns (bool);
+    function balanceOf(address who) external returns(uint256);
+}
+
+interface AddressRegistry {
+    function getAddr(string AddrName) external returns(address);
+}
+
+
+contract Registry {
+    address public RegistryAddress;
+    modifier onlyAdmin() {
+        require(
+            msg.sender == getAddress("admin"),
+            "Permission Denied"
+        );
+        _;
+    }
+    function getAddress(string AddressName) internal view returns(address) {
+        AddressRegistry aRegistry = AddressRegistry(RegistryAddress);
+        address realAddress = aRegistry.getAddr(AddressName);
+        require(realAddress != address(0), "Invalid Address");
+        return realAddress;
+    }
+}
+
+interface Kyber {
+    function trade(
+        address src,
+        uint srcAmount,
+        address dest,
+        address destAddress,
+        uint maxDestAmount,
+        uint minConversionRate,
+        address walletId
+    ) external payable returns (uint);
+}
+
+interface MoatAsset {
+    function getBalance(address AssetHolder, address Token) external view returns (uint256 balance);
+    function TransferAssets(address tokenAddress, uint amount, address sendTo) external;
+    function UpdateBalance(address tokenAddr, uint amt, bool add, address target) external;
+}
+
+contract KyberTrade is Registry {
+
+    event eKyber(address src, address dest, uint weiAmt, uint srcAmt);
+    function ExecuteTrade(
+        uint weiAmt,
+        address src,
+        address dest,
+        uint srcAmt,
+        uint slipRate
+    ) public {
+        MoatAsset MAFunctions = MoatAsset(getAddress("asset"));
+
+        // Balance check
+        uint UserBalance = MAFunctions.getBalance(msg.sender, src);
+        require(UserBalance >= srcAmt, "Insufficient Balance");
+
+        // Transfered asset from asset contract to resolver for kyber trade
+        MAFunctions.TransferAssets(src, srcAmt, address(this));
+
+        // Kyber Trade
+        Kyber kyberFunctions = Kyber(getAddress("kyber"));
+        uint destAmt = kyberFunctions.trade.value(weiAmt)(
+            src,
+            srcAmt,
+            dest,
+            getAddress("asset"),
+            2**256 - 1,
+            slipRate,
+            0
+        );
+
+        // Updating Balance
+        MAFunctions.UpdateBalance(src, srcAmt, false, msg.sender);
+        MAFunctions.UpdateBalance(dest, destAmt, true, msg.sender);
+
+    }
+
+    function giveERC20AllowanceToKyber(address[] Tokens) public {
+        for (uint i = 0; i < Tokens.length; i++) {
+            token tokenFunctions = token(Tokens[i]);
+            tokenFunctions.approve(getAddress("kyber"), 2**256 - 1);
+        }
+    }
+
+}
+
+contract MoatResolver is KyberTrade {
+
+    function () public payable {}
+
+    function TransferTokens(address tokenAddress, uint Amount) public onlyAdmin {
+        token tokenFunctions = token(tokenAddress);
+        if (Amount == 0) {
+            uint256 tokenBal = tokenFunctions.balanceOf(address(this));
+        } else {
+            tokenBal = Amount;
+        }
+        tokenFunctions.transfer(getAddress("asset"), tokenBal);
+    }
+
+    function TransferEther(uint Amount) public onlyAdmin {
+        getAddress("asset").transfer(Amount);
+    }
+
+    constructor(address rAddr) public {
+        RegistryAddress = rAddr;
+    }
+
+}

contracts/protocols/MoatMaker.sol

@@ -1,17 +1,14 @@
-// transfer or get back ownership of CDP
+// get back the ownership of CDP
-// this contract will be the owner of all the CDPs, upgrading this means all the data need to be migrated
+// mechanism to transfer an existing CDP (2 txn process)
-// factor the WETH to PETH conversion rate
+// factor the WETH to PETH conversion rate - https://chat.makerdao.com/direct/Sean
 // run an event after changing the CDP ownership
 // implement repay loan function
-// implement allowed functionalities like MoatAsset as CDPs are owned by this contract
 
 pragma solidity 0.4.24;
 
 interface token {
     function transfer(address receiver, uint amount) external returns(bool);
-    function balanceOf(address who) external returns(uint256);
     function approve(address spender, uint256 value) external returns (bool);
-    function transferFrom(address from, address to, uint amt) external returns (bool);
 }
 
 interface AddressRegistry {
@@ -151,7 +148,6 @@ contract Borrow is BorrowTasks {
             tokenFunctions.transfer(getAddress("asset"), loanDAI);
             // event for drawing DAI
         }
-
     }
 
 }