Integrated LBC with bridge mock

contracts/Bridge.sol

@@ -8,8 +8,8 @@ interface Bridge {
         bytes calldata pmtSerialized, 
         bytes32 derivationArgumentsHash, 
         bytes calldata userRefundBtcAddress, 
-        address liquidityBridgeContractAddress,
+        address payable liquidityBridgeContractAddress,
         bytes calldata liquidityProviderBtcAddress, 
         bool shouldTransferToContract
-    ) external returns (int256 executionStatus);
+    ) external returns (int256);
 }

contracts/BridgeMock.sol

@@ -5,22 +5,29 @@ import "./Bridge.sol";
 
 contract BridgeMock is Bridge {
 
-    mapping(bytes32 => int256) private returnStatus;
+    mapping(bytes32 => uint256) private amounts;
 
     function registerFastBridgeBtcTransaction(
         bytes calldata btcTxSerialized, 
         uint256 height, 
         bytes calldata pmtSerialized, 
         bytes32 derivationArgumentsHash, 
         bytes calldata userRefundBtcAddress, 
-        address liquidityBridgeContractAddress,
+        address payable liquidityBridgeContractAddress,
         bytes calldata liquidityProviderBtcAddress, 
         bool shouldTransferToContract
-    ) external override returns (int256 executionStatus) {
-        return returnStatus[derivationArgumentsHash];
+    ) external override returns (int256) {
+        uint256 amount = amounts[derivationArgumentsHash];
+        amounts[derivationArgumentsHash] = 0;
+        (bool success, ) = liquidityBridgeContractAddress.call{value: amount}("");
+        return int(amount);
     }
 
-    function setReturnStatus(bytes32 derivationArgumentsHash, int256 status) public {
-        returnStatus[derivationArgumentsHash] = status;
+    function setPegin(bytes32 derivationArgumentsHash) public payable {
+        amounts[derivationArgumentsHash] = msg.value;
+    }
+
+    function getPegin(bytes32 hashe) external view returns (uint256) {
+        return amounts[hashe];
     }
 }

contracts/LiquidityBridgeContract.sol

@@ -9,11 +9,14 @@ contract LiquidityBridgeContract {
     mapping(address => uint256) private balances;
     mapping(address => uint256) private deposits;
     mapping(bytes32 => address) private callRegistry;
+    mapping(bytes32 => bool) private callSuccess;
 
     constructor(address bridgeAddress) {
         bridge = Bridge(bridgeAddress);
     }
 
+    receive() external payable { }
+
     function register() external payable {
         deposits[msg.sender] += msg.value;
     }
@@ -22,17 +25,18 @@ contract LiquidityBridgeContract {
         balances[msg.sender] += msg.value;
     }
 
-    function getDeposit(address lp) external view returns (uint256 qty) {
+    function getDeposit(address lp) external view returns (uint256) {
         return deposits[lp];
     }
 
-    function getBalance(address lp) external view returns (uint256 qty) {
+    function getBalance(address lp) external view returns (uint256) {
         return balances[lp];
     }
 
     function callForUser(
         bytes memory fedBtcAddress,
         address liquidityProviderRskAddress,
+        address payable rskRefundAddress,
         address contractAddress,
         bytes memory data,
         uint penaltyFee,
@@ -42,13 +46,16 @@ contract LiquidityBridgeContract {
         uint value
     ) external payable {
         require(msg.sender == liquidityProviderRskAddress, "Unauthorized");
+        require(deposits[liquidityProviderRskAddress] >= penaltyFee, "Insufficient collateral");
 
         balances[liquidityProviderRskAddress] += msg.value;
+
         require(balances[liquidityProviderRskAddress] >= value, "Insufficient funds");
 
         bytes32 derivationHash = hash(
             fedBtcAddress,
             liquidityProviderRskAddress,
+            rskRefundAddress,
             contractAddress,
             data,
             penaltyFee,
@@ -63,6 +70,7 @@ contract LiquidityBridgeContract {
 
         if (success) {
             balances[liquidityProviderRskAddress] -= value;
+            callSuccess[derivationHash] = true;
         }
     }
 
@@ -71,15 +79,13 @@ contract LiquidityBridgeContract {
         bytes memory partialMerkleTree, 
         uint256 height, 
         bytes memory userBtcRefundAddress, 
-        bytes memory liquidityProviderBtcAddress, 
-        bytes32 preHash
-    ) public returns (int256 result) {
+        bytes memory liquidityProviderBtcAddress,
+        address payable rskRefundAddress,
+        bytes32 preHash,
+        uint256 successFee,
+        uint256 penaltyFee
+    ) public returns (int256) {
         address liquidityProviderRskAddress = callRegistry[preHash];
-        bool callPerformed = false;
-
-        if (liquidityProviderRskAddress != address(0x0)) {
-            callPerformed = true;
-        }
 
         int256 transferredAmount = bridge.registerFastBridgeBtcTransaction(
             btcRawTransaction, 
@@ -88,32 +94,43 @@ contract LiquidityBridgeContract {
             preHash, 
             userBtcRefundAddress, 
             address(this),
-            liquidityProviderBtcAddress, 
-            callPerformed
+            liquidityProviderBtcAddress,
+            liquidityProviderRskAddress != address(0x0)
         );
 
-        if (transferredAmount >= 0 && callPerformed) {
-            balances[liquidityProviderRskAddress] += uint256(transferredAmount);
+        if (transferredAmount > 0 && liquidityProviderRskAddress != address(0x0)) {
+            if (callSuccess[preHash]) {
+                balances[liquidityProviderRskAddress] += uint256(transferredAmount);
+                callSuccess[preHash] = false;
+            } else {
+                balances[liquidityProviderRskAddress] += successFee;
+                (bool success, ) = rskRefundAddress.call{value : uint256(transferredAmount) - successFee}("");
+            }
             callRegistry[preHash] = address(0x0);
+        } else if (transferredAmount > 0) {
+            deposits[liquidityProviderRskAddress] -= penaltyFee;
+            (bool success, ) = rskRefundAddress.call{value : uint256(transferredAmount) + penaltyFee}("");
         }
         return transferredAmount;
     }
 
     function hash(
         bytes memory fedBtcAddress, 
         address liquidityProviderRskAddress,
+        address rskRefundAddress,
         address callContract, 
         bytes memory callContractArguments, 
         uint penaltyFee,
         uint successFee,
         uint gasLimit,
         uint nonce ,
         uint valueToTransfer
-    ) public pure returns (bytes32 derivationHash) {
+    ) public pure returns (bytes32) {
 
         return keccak256(abi.encode(
             fedBtcAddress, 
-            liquidityProviderRskAddress, 
+            liquidityProviderRskAddress,
+            rskRefundAddress,
             callContract, 
             callContractArguments, 
             penaltyFee, 
@@ -123,17 +140,4 @@ contract LiquidityBridgeContract {
             valueToTransfer
         ));
     }
-
-    function hash(
-        bytes32 preHash,
-        bytes memory userBtcRefundAddress, 
-        bytes memory liquidityProviderBtcAddress
-    ) internal view returns (bytes32 derivationHash) {
-        return keccak256(abi.encodePacked(
-            preHash,
-            userBtcRefundAddress,
-            address(this),
-            liquidityProviderBtcAddress
-        ));
-    }
 }

contracts/Mock.sol

@@ -10,7 +10,7 @@ contract Mock {
         status = s;
     }
 
-    function check() external view returns (int s){
+    function check() external view returns (int){
         return status;
     }
 }

migrations/2_deploy_contracts.js

@@ -1,16 +1,20 @@
 var LiquidityBridgeContract = artifacts.require('LiquidityBridgeContract');
 var Mock = artifacts.require('Mock')
-//var BridgeMock = artifacts.require('BridgeMock');
+var BridgeMock = artifacts.require('BridgeMock');
 
 module.exports = function(deployer, network) {
-   /* if (network == 'test') { //used for running truffle tests
+   /*if (network == 'test') { //used for running truffle tests
         deployer.deploy(BridgeMock).then((mockInstance) => {
             let bridgeAddress = mockInstance.address;
-            return deployer.deploy(LiquidityBridgeContract, bridgeAddress);
+            deployer.deploy(LiquidityBridgeContract, bridgeAddress);
         });
     } else {
         deployer.deploy(LiquidityBridgeContract, '0x0000000000000000000000000000000001000006');
     }*/
-    deployer.deploy(LiquidityBridgeContract, '0x0000000000000000000000000000000001000006');
+
+    deployer.deploy(BridgeMock).then((mockInstance) => {
+                let bridgeAddress = mockInstance.address;
+                deployer.deploy(LiquidityBridgeContract, bridgeAddress);
+    });
     deployer.deploy(Mock);
 };