Merge pull request #183 from dhinakaran2705/main

Core network interop contracts for Besu for exchanging ERC20 tokens and a simpleasset application

Author: sandeepnRES

core/network/besu/contracts/interop/manageAsset.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.8;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+* Hashed Timelock Contract on Fungible Assets in an Ethereum network (Support only for ERC20 tokens right now)
+**/
+
+contract InteroperationBaseClassERC20 {
+
+	mapping (bytes32 => LockContract) public lockContracts;
+
+	struct LockContract {
+		address sender;
+		address receiver;
+		address assetContract;
+		uint256 amount;
+		bytes32 hashLock;
+		uint256 expirationTime;
+		uint8 status;
+	}
+
+	uint8 constant UNUSED = 0;
+	uint8 constant LOCKED = 1;
+
+	event Lock(
+		address indexed sender,
+		address indexed receiver,
+		address assetContract,
+		uint256 amount,
+		bytes32 hashLock,
+		uint256 expirationTime,
+		bytes32 lockContractId
+	);
+
+	event Claim(
+		address indexed sender,
+		address indexed receiver,
+		bytes32 indexed lockContractId,
+		bytes32 hashLock,
+		bytes32 preimage
+    	);
+
+	event Unlock(
+		address indexed sender,
+		address indexed receiver,
+		bytes32 indexed lockContractId
+	);
+
+
+	// The sender locks a fungible asset with a hash lock and an expiry time
+	function lockFungibleAsset(
+		address receiver,
+		address assetContract,
+		uint256 amount,
+		bytes32 hashLock,
+		uint256 expirationTime
+	)
+		external
+		returns (bytes32 lockContractId)
+	{
+		address sender = msg.sender;
+		
+		// Checking the validity of the input parameters
+		require(amount > 0, "Amount should be greater than zero");
+		require(ERC20(assetContract).allowance(sender, address(this)) >= amount, "Allowance of assets from the sender for the lock contract must be greater than the amount to be locked");
+		require(expirationTime > block.timestamp, "Expiration time should be in the future");
+
+		// The identity of the lock contract is a hash of all the relevant parameters that will uniquely identify the contract
+		lockContractId = sha256(
+			abi.encodePacked(
+				sender,
+				receiver,
+				assetContract,
+				amount,
+				hashLock,
+				expirationTime
+			)
+		);
+
+		require(lockContracts[lockContractId].status == UNUSED, "An active lock contract already exists with the same parameters");
+
+		// Locking amount by transfering them to the lockContract
+		bool transferStatus = ERC20(assetContract).transferFrom(sender, address(this), amount);
+		require(transferStatus == true, "ERC20 transferFrom failed from the sender to the lockContract");
+
+		lockContracts[lockContractId] = LockContract(
+			sender,
+			receiver,
+			assetContract,
+			amount,
+			hashLock,
+			expirationTime,
+			LOCKED
+		);
+
+		emit Lock(
+			sender,
+			receiver,
+			assetContract,
+			amount,
+			hashLock,
+			expirationTime,
+			lockContractId
+		);
+	}
+
+
+	// The receiver claims the ownership of an asset locked for them once they obtain the preimage of the hashlock
+	function claimFungibleAsset(bytes32 lockContractId, bytes32 preimage)
+		external
+		returns (bool)
+	{
+		LockContract storage c = lockContracts[lockContractId];
+		
+		// Check the validity of the claim
+		require(c.status == LOCKED, "lockContract is not active");
+		require(block.timestamp < c.expirationTime, "lockContract has expired");
+		require(c.hashLock == sha256(abi.encodePacked(preimage)),"Invalid preimage, its hash does not equal the hashLock");
+
+		bool transferStatus = ERC20(c.assetContract).transfer(c.receiver, c.amount);
+		require(transferStatus == true, "ERC20 transfer failed from the lockContract to the receiver");
+
+		emit Claim(
+			c.sender,
+			c.receiver,
+			lockContractId,
+			c.hashLock,
+			preimage
+		);
+
+		return true;
+	}
+
+
+	// Unlocking and reclaiming a locked asset for the sender after the expiration time. Can be called by anyone, not just the sender.
+	function unlockFungibleAsset(bytes32 lockContractId)
+		external
+		returns (bool)
+	{
+		LockContract storage c = lockContracts[lockContractId];
+
+		// Validation checks
+		require(c.status == LOCKED, "There is no active lockContract with the specified ID");
+		require(c.sender != address(0), "Sender address is invalid");
+		require(block.timestamp >= c.expirationTime, "Lock contract has expired");
+
+		bool transferStatus = ERC20(c.assetContract).transfer(c.sender, c.amount);
+		require(transferStatus == true, "ERC20 transfer failed from the lockContract back to the sender");
+		
+		emit Unlock(
+			c.sender,
+			c.receiver,
+			lockContractId
+		);
+
+		return true;
+	}
+
+
+	// Function to check if there is an active contract with the input lockContractId.
+	function isFungibleAssetLocked(bytes32 lockContractId)
+		external
+		returns (bool)
+	{
+		LockContract storage c = lockContracts[lockContractId];
+		
+		bool lockContractStatus;
+		if ( c.status == LOCKED ){
+			lockContractStatus = true;
+		} else {
+			lockContractStatus = false;
+		}
+
+		return lockContractStatus;
+	}
+}

samples/besu/simpleasset/.gitignore

@@ -0,0 +1,4 @@
+build
+node_modules
+contracts/manageAsset.sol
+package-lock.json

samples/besu/simpleasset/Makefile

@@ -0,0 +1,18 @@
+.PHONY: deploy-contracts
+deploy-contracts: deploy-contract-network1 deploy-contract-network2
+
+.PHONY: deploy-contract-network1
+deploy-contract-network1:
+	BESU_NETWORK_HOST=localhost BESU_NETWORK_PORT=8545 npm run deploy-contract
+
+.PHONY: deploy-contract-network2
+deploy-contract-network2:
+	BESU_NETWORK_HOST=localhost BESU_NETWORK_PORT=9544 npm run deploy-contract
+
+.PHONY: clean-run
+clean-run:
+	npm run clean-run
+
+.PHONY: clean
+clean:
+	npm run clean

samples/besu/simpleasset/README.md

@@ -0,0 +1,30 @@
+<!--
+ Copyright IBM Corp. All Rights Reserved.
+
+ SPDX-License-Identifier: CC-BY-4.0
+ -->
+# A Sample Application for Asset Exchange across Two Besu Networks using HTLC
+
+## Deploy contracts
+The following command deploys the contracts on the two test networks:
+```
+make deploy-contracts
+```
+This internally does the following:
+- copies the core network contracts to the contracts folder in the truffle application. 
+	* In future, this should be replaced by exporting the core contracts as an npm or EthPM package and the app importing this package.
+	* The support is also only for ERC-20 tokens right now. This will be extended to ERC-721 soon. And in this future for any asset type.
+- updates truffle-config.js based on the environment variables BESU\_NETWORK\_HOST and BESU\_NETWORK\_PORT
+- installs the missing packages
+- compiles the contracts and migrates them to both the test networks
+
+## Run the asset exchange application
+The sample application will have Alice transfer AliceERC20 tokens in Network 1 to Bob atomically with Bob transfering an equivalent amount of BobERC20 tokens to Alice in Network 2.
+```
+node app/AssetExchangeERC20.js
+```
+
+## Troubleshoot
+- Check if truffle is installed: npm install -g truffle
+
+- Pay attention to the number of tokens initally owned by Alice and Bob in Networks 1 and 2 respectively, if there are other applications that use/spend their tokens in parallel to this app. Ensure that there are sufficient tokens in their accounts to lock.