AssetManager Contract

chaincode/.env.example

@@ -0,0 +1,3 @@
+ETHERSCAN_API_KEY=ABC123ABC123ABC123ABC123ABC123ABC1
+ROPSTEN_URL=https://eth-ropsten.alchemyapi.io/v2/<YOUR ALCHEMY KEY>
+PRIVATE_KEY=0xabc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1

chaincode/.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+artifacts
+cache
+coverage

chaincode/.eslintrc.js

@@ -0,0 +1,24 @@
+module.exports = {
+  env: {
+    browser: false,
+    es2021: true,
+    mocha: true,
+    node: true,
+  },
+  plugins: ["@typescript-eslint"],
+  extends: [
+    "standard",
+    "plugin:prettier/recommended",
+    "plugin:node/recommended",
+  ],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 12,
+  },
+  rules: {
+    "node/no-unsupported-features/es-syntax": [
+      "error",
+      { ignores: ["modules"] },
+    ],
+  },
+};

chaincode/.gitignore

@@ -0,0 +1,13 @@
+node_modules
+.env
+coverage
+coverage.json
+typechain
+
+#Hardhat files
+cache
+artifacts
+
+# Additional files
+docs
+data

chaincode/.npmignore

@@ -0,0 +1,3 @@
+hardhat.config.ts
+scripts
+test

chaincode/.prettierignore

@@ -0,0 +1,5 @@
+node_modules
+artifacts
+cache
+coverage*
+gasReporterOutput.json

chaincode/.prettierrc

@@ -0,0 +1 @@
+{}

chaincode/.solhint.json

@@ -0,0 +1,7 @@
+{
+  "extends": "solhint:recommended",
+  "rules": {
+    "compiler-version": ["error", "^0.8.0"],
+    "func-visibility": ["warn", { "ignoreConstructors": true }]
+  }
+}

chaincode/.solhintignore

@@ -0,0 +1 @@
+node_modules

chaincode/README.md

@@ -0,0 +1,18 @@
+# AssetManager 
+
+Smart contract functionality for managing assets for the sms-wallet.
+For an overview read the [wiki](https://github.com/polymorpher/sms-wallet/wiki#sms-controlled-mini-wallet).
+
+## Developers 
+
+Quickstart
+```
+git clone https://github.com/polymorpher/sms-wallet
+cd chaincode
+yarn 
+yarn test
+```
+
+
+
+

chaincode/contracts/AssetManager.sol

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+// import "hardhat/console.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import "./Enums.sol";
+
+contract AssetManager is Ownable {
+    event DepositSuccesful(address indexed user, uint256 amount, uint256 balance);
+    event WithdrawalSuccesful(address indexed user, uint256 amount, uint256 balance);
+    error WithdrawalFailed(
+        address user,
+        uint256 amount,
+        uint256 balance,
+        string reason
+    );
+    event AuthorizationSuccesful(address indexed user, uint256 newLimit, uint256 userBalance);
+    error AuthorizationFailed(
+        address depositor,
+        uint256 userBalance,
+        uint256 limit,
+        string reason
+    );
+    event SendSuccesful(address indexed from, address indexed to, uint256 amount, uint256 newBalance, uint256 newLimit);
+    error SendFailed(
+        address from,
+        address to,
+        uint256 amount,
+        uint256 balance,
+        uint256 limit,
+        string reason
+    );
+    event TransferSuccesful(uint256 amount,
+        Enums.TokenType tokenType,
+        uint256 tokenId, 
+        address tokenAddress, 
+        address indexed from, 
+        address indexed to);
+    error TransferFailed(
+        uint256 amount,
+        Enums.TokenType tokenType,
+        uint256 tokenId, 
+        address tokenAddress, 
+        address from, 
+        address to,
+        string reason
+    );
+
+    address private _operator;
+    mapping(address => uint256) public userBalances;
+    mapping(address => uint256) public userAuthorizations;
+
+    constructor(address operator_) {
+        setOperator(operator_);
+        }
+
+    modifier onlyOperator {
+        require(msg.sender == _operator, "Can only be called by Operator");
+        _;
+    }
+
+    modifier onlyOwnerOrOperator {
+        bool ownerOperator = ((msg.sender == owner()) || (msg.sender == operator()));
+        require(ownerOperator, "Can only be called by Owner or Operator");
+        _;
+    }
+
+    /**
+     * @dev Returns the address of the current operator.
+     */
+    function operator() public view virtual returns (address) {
+        return _operator;
+    }
+
+    function setOperator(address operator_) onlyOwnerOrOperator public {
+        _operator = operator_;
+    }
+
+    function deposit() public payable {
+        userBalances[address(msg.sender)] += msg.value;
+        // update the userBalance
+        emit DepositSuccesful(
+            msg.sender,
+            msg.value,
+            userBalances[address(msg.sender)]
+        );
+    }
+
+        function withdraw(uint256 amount) public payable {
+        uint256 balance =  userBalances[address(msg.sender)];
+        // if zero is passed withdraw all funds
+        if (amount == 0){ amount = balance; }
+        // check msg.senders balance
+        if (amount > balance) {
+            revert WithdrawalFailed(
+                msg.sender,
+                amount,
+                balance,
+                "Insufficient Locked Funds to Withdraw "
+            );
+        }
+
+        // withdraw funds from the contract (update userBalance before transfer to protect from reentracy attack)
+        uint256 newBalance = balance - amount;
+        userBalances[address(msg.sender)] = newBalance;
+        payable(msg.sender).transfer(amount);
+
+        // update the authorized amount.
+        uint256 currentLimit = this.userAuthorizations(address(msg.sender));
+        if (currentLimit > newBalance ) { authorize(newBalance); }
+
+        // update the userBalance
+        emit WithdrawalSuccesful(
+            msg.sender,
+            amount,
+            userBalances[address(msg.sender)]
+        );
+    }
+
+    function authorize(uint256 limit) public {
+        // check msg.senders balance
+        uint256 balance = this.userBalances(address(msg.sender));
+        // uint256 currentLimit = getUserAuthorization(msg.sender);
+        // uint256 newLimit = currentLimit + limit;
+        if (balance < limit) {
+            revert AuthorizationFailed(
+                msg.sender,
+                balance,
+                limit,
+                "New limt amount greater than users balance"
+            );
+        }
+
+        userAuthorizations[address(msg.sender)] = limit;
+
+        // update the userBalance
+        emit AuthorizationSuccesful(
+            msg.sender,
+            limit,
+            balance
+        );
+    }
+    function send(uint256 amount, address from, address to) public onlyOperator() {
+        uint256 balance =  userBalances[from];
+        uint256 limit = userAuthorizations[from];
+        if (amount == 0) {
+            revert SendFailed(
+                from,
+                to,
+                amount,
+                balance,
+                limit,
+                "Send amount cannot equal 0"
+            );
+        }
+        // check from balance
+        if (amount > balance) {
+            revert SendFailed(
+                from,
+                to,
+                amount,
+                balance,
+                limit,
+                "Insufficient Locked Funds to Send "
+            );
+        }
+        // check from balance
+        if (amount > limit) {
+            revert SendFailed(
+                from,
+                to,
+                amount,
+                balance,
+                limit,
+                "Insufficient Authorized Funds to Send "
+            );
+        }
+        // withdraw funds from the contract (update userBalance before transfer to protect from reentracy attack)
+        uint256 newBalance = balance - amount;
+        userBalances[address(from)] = newBalance;
+
+        // update the authorized amount.
+        uint256 newLimit = limit - amount;
+        userAuthorizations[address(from)] = newLimit;
+
+        payable(to).transfer(amount);
+
+        emit SendSuccesful(
+            from,
+            to,
+            amount,
+            newBalance,
+            newLimit
+        );
+    }
+    function transfer( uint256 amount, Enums.TokenType tokenType, uint256 tokenId, address tokenAddress, address from, address to) public onlyOperator {
+    if ( tokenType == Enums.TokenType.ERC20 ) {
+        bool success = ERC20(tokenAddress).transferFrom(from, to, amount);
+        if (success) {
+            emit TransferSuccesful(amount, tokenType, tokenId, tokenAddress, from, to);
+        } else {
+            revert TransferFailed(
+            amount,
+            tokenType,
+            tokenId,
+            tokenAddress,
+            from,
+            to,
+            "Invalid tokenType "
+            );
+        }
+    } else if ( tokenType == Enums.TokenType.ERC721 ) {
+       ERC721(tokenAddress).safeTransferFrom(from, to, tokenId);
+        emit TransferSuccesful(amount, tokenType, tokenId, tokenAddress, from, to);
+    } else if ( tokenType == Enums.TokenType.ERC1155 ) {
+        ERC1155(tokenAddress).safeTransferFrom(from, to, tokenId, amount, "");
+        emit TransferSuccesful(amount, tokenType, tokenId, tokenAddress, from, to);
+    } else { 
+        revert TransferFailed(
+            amount,
+            tokenType,
+            tokenId,
+            tokenAddress,
+            from,
+            to,
+            "Invalid tokenType "
+            );
+    }
+    }
+}

chaincode/contracts/Enums.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+library Enums {
+    enum TokenType{
+        ERC20, ERC721, ERC1155, NONE
+    }
+}