Merge pull request #151 from gulshanvasnani/executeRedeem

TH ExecuteRedemption

Author: benjaminbollen

lib/ContractInteract/TokenHolder.js

@@ -139,6 +139,66 @@ class TokenHolder {
     return executeRuleCallPrefix;
   }
 
+  /**
+   * It is used to get call prefix of executeRedeem method in TokenHolder contract.
+   *
+   * @returns {string} Encoded signature of executeRedeem method.
+   */
+  getTokenHolderExecuteRedemptionCallPrefix() {
+    const executeRedeemHash = this.auxiliaryWeb3.utils.soliditySha3(
+      'executeRedemption(address,bytes,uint256,bytes32,bytes32,uint8)'
+    );
+    const executeRedeemCallPrefix = executeRedeemHash.substring(0, 10);
+    return executeRedeemCallPrefix;
+  }
+
+  /**
+   * Executable data for co-gateway redeem.
+   *
+   * @param amount Redeem amount that will be transferred from redeemer account.
+   * @param beneficiary The address in the origin chain where the value tokens will be released.
+   * @param gasPrice Gas price that redeemer is ready to pay to get the redeem process done.
+   * @param gasLimit Gas limit that redeemer is ready to pay.
+   * @param nonce Nonce of the redeemer address.
+   * @param hashLock Hash Lock provided by the facilitator.
+   * @returns {*}
+   */
+  getCoGatewayRedeemExecutableData(amount, beneficiary, gasPrice, gasLimit, nonce, hashLock) {
+    return this.auxiliaryWeb3.eth.abi.encodeFunctionCall(
+      {
+        name: 'redeem',
+        type: 'function',
+        inputs: [
+          {
+            type: 'uint256',
+            name: 'amount'
+          },
+          {
+            type: 'address',
+            name: 'beneficiary'
+          },
+          {
+            type: 'uint256',
+            name: 'gasPrice'
+          },
+          {
+            type: 'uint256',
+            name: 'gasLimit'
+          },
+          {
+            type: 'uint256',
+            name: 'nonce'
+          },
+          {
+            type: 'bytes32',
+            name: 'hashlock'
+          }
+        ]
+      },
+      [amount, beneficiary, gasPrice, gasLimit, nonce, hashLock]
+    );
+  }
+
   /**
    * It is used to execute executable data signed by a session key.
    *
@@ -193,6 +253,60 @@ class TokenHolder {
     return Promise.resolve(this.contract.methods.executeRule(to, data, nonce, r, s, v));
   }
 
+  /**
+   * It is used to execute redeem data signed by a session key.
+   *
+   * @param {string} to The target contract address the transaction will be executed upon.
+   * @param {string} data The payload of a function to be executed in the target contract.
+   * @param {string} nonce The nonce of an session key that was used to sign the transaction.
+   * @param {string} r `r` part of the signature.
+   * @param {string} s `s` part of the signature.
+   * @param {string} v `v` part of the signature.
+   * @param {Object} txOptions Tx options.
+   *
+   * @returns {Promise<Object>} Promise that resolves to transaction receipt.
+   */
+  async executeRedemption(to, data, nonce, r, s, v, txOptions) {
+    if (!txOptions) {
+      const err = new TypeError('Invalid transaction options.');
+      return Promise.reject(err);
+    }
+    if (!Web3.utils.isAddress(txOptions.from)) {
+      const err = new TypeError(`Invalid from address: ${txOptions.from}.`);
+      return Promise.reject(err);
+    }
+    const txObject = await this.executeRedemptionRawTx(to, data, nonce, r, s, v);
+    return Utils.sendTransaction(txObject, txOptions);
+  }
+
+  /**
+   * Private method which is used to execute redeem data signed by a session key.
+   *
+   * @param {string} to The target contract address the transaction will be executed upon.
+   * @param {string} data The payload of a function to be executed in the target contract.
+   * @param {string} nonce The nonce of an session key that was used to sign the transaction.
+   * @param {string} r `r` part of the signature signed by sessionKey.
+   * @param {string} s `s` part of the signature signed by sessionKey.
+   * @param {string} v `v` part of the signature signed by sessionKey.
+   *
+   * @returns {Promise<Object>} Promise that resolves to raw transaction object.
+   */
+  executeRedemptionRawTx(to, data, nonce, r, s, v) {
+    if (!Web3.utils.isAddress(to)) {
+      const err = new TypeError(`Invalid to address: ${to}.`);
+      return Promise.reject(err);
+    }
+    if (!data) {
+      const err = new TypeError(`Invalid data: ${data}.`);
+      return Promise.reject(err);
+    }
+    if (!nonce) {
+      const err = new TypeError(`Invalid nonce: ${nonce}.`);
+      return Promise.reject(err);
+    }
+    return Promise.resolve(this.contract.methods.executeRedemption(to, data, nonce, r, s, v));
+  }
+
   /**
    * It returns the session key data object.
    *

test/unit/TokenHolder/executeRedeem.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const Web3 = require('web3');
+const sinon = require('sinon');
+const { assert } = require('chai');
+
+const Spy = require('../../../utils/Spy');
+const AssertAsync = require('../../../utils/AssertAsync');
+const TokenHolder = require('../../../lib/ContractInteract/TokenHolder');
+const Utils = require('../../../utils/Utils');
+
+describe('TokenHolder.executeRedemption()', () => {
+  let tokenHolder;
+
+  beforeEach(() => {
+    const web3 = new Web3();
+    const address = '0x0000000000000000000000000000000000000002';
+    tokenHolder = new TokenHolder(web3, address);
+  });
+
+  it('should construct with correct parameters', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = null;
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    const txOptions = {
+      from: '0x0000000000000000000000000000000000000006'
+    };
+
+    const mockRawTx = 'mockExecuteRedemptionRawTx';
+    const executeRedemptionRawTx = sinon.replace(tokenHolder, 'executeRedemptionRawTx', sinon.fake.resolves(mockRawTx));
+    const spySendTransaction = sinon.replace(Utils, 'sendTransaction', sinon.fake.resolves(true));
+    const response = await tokenHolder.executeRedemption(to, data, nonce, r, s, v, txOptions);
+
+    assert.isTrue(response, 'executeRedemption should return true');
+    Spy.assert(executeRedemptionRawTx, 1, [[to, data, nonce, r, s, v]]);
+    Spy.assert(spySendTransaction, 1, [[mockRawTx, txOptions]]);
+  });
+
+  it('should throw an error when txOptions is undefined', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = null;
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    await AssertAsync.reject(tokenHolder.executeRedemption(to, data, nonce, r, s, v), `Invalid transaction options.`);
+  });
+
+  it('should throw an error when txOptions.from is undefined', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = null;
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    await AssertAsync.reject(
+      tokenHolder.executeRedemption(to, data, nonce, r, s, v, {}),
+      `Invalid from address: undefined.`
+    );
+  });
+});

test/unit/TokenHolder/executeRedeemRawTx.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const Web3 = require('web3');
+const sinon = require('sinon');
+const { assert } = require('chai');
+
+const Spy = require('../../../utils/Spy');
+const AssertAsync = require('../../../utils/AssertAsync');
+const TokenHolder = require('../../../lib/ContractInteract/TokenHolder');
+
+describe('TokenHolder.executeRedemptionRawTx()', () => {
+  let tokenHolder;
+
+  beforeEach(() => {
+    const web3 = new Web3();
+    const tokenHolderAddress = '0x0000000000000000000000000000000000000002';
+    tokenHolder = new TokenHolder(web3, tokenHolderAddress);
+  });
+
+  it('should construct with correct parameters', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = 'cogatewayRedeem';
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    const mockExecuteRedeem = 'mockExecuteRedeem';
+    const executeRedeemSpy = sinon.replace(
+      tokenHolder.contract.methods,
+      'executeRedemption',
+      sinon.fake.resolves(mockExecuteRedeem)
+    );
+    const response = await tokenHolder.executeRedemptionRawTx(to, data, nonce, r, s, v);
+
+    assert.strictEqual(response, mockExecuteRedeem);
+    Spy.assert(executeRedeemSpy, 1, [[to, data, nonce, r, s, v]]);
+    sinon.restore();
+  });
+
+  it('should throw an error when to address is undefined', async () => {
+    const to = undefined;
+    const data = 'cogatewayRedeem';
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    await AssertAsync.reject(
+      tokenHolder.executeRedemptionRawTx(to, data, nonce, r, s, v),
+      `Invalid to address: undefined.`
+    );
+  });
+
+  it('should throw an error when data is undefined', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = undefined;
+    const nonce = 1;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    await AssertAsync.reject(tokenHolder.executeRedemptionRawTx(to, data, nonce, r, s, v), `Invalid data: undefined.`);
+  });
+
+  it('should throw an error when nonce is undefined', async () => {
+    const to = '0x0000000000000000000000000000000000000003';
+    const data = 'cogatewayRedeem';
+    const nonce = undefined;
+    const r = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1760';
+    const s = '0xdfc2f04f19e6d253cd3980e663f57600f33fc1a16697f5e9703e8dc23d2d1c1';
+    const v = 28;
+    await AssertAsync.reject(tokenHolder.executeRedemptionRawTx(to, data, nonce, r, s, v), `Invalid nonce: undefined.`);
+  });
+});

test/unit/TokenHolder/executeRuleRawTx.js

@@ -35,6 +35,7 @@ describe('TokenHolder.executeRuleRawTx()', () => {
 
     assert.strictEqual(response, mockExecuteRule);
     Spy.assert(executeRuleSpy, 1, [[to, data, nonce, r, s, v]]);
+    sinon.restore();
   });
 
   it('should throw an error when to address is undefined', async () => {

utils/AssertAsync.js

@@ -3,7 +3,7 @@
 const { assert } = require('chai');
 
 /**
- * This class includes the utitity assert function
+ * This class includes the utility assert function
  */
 class AssertAsync {
   static async reject(promise, message) {