Rename of SettableTransferXcert to PausableXcert.

contracts/mocks/XcertMock.sol

@@ -1,14 +1,14 @@
 pragma solidity ^0.4.19;
 
 import "../../contracts/tokens/BurnableXcert.sol";
-import "../../contracts/tokens/SettableTransferXcert.sol";
+import "../../contracts/tokens/PausableXcert.sol";
 import "../../contracts/tokens/ChainableXcert.sol";
 
-contract XcertMock is BurnableXcert, SettableTransferXcert, ChainableXcert {
+contract XcertMock is BurnableXcert, PausableXcert, ChainableXcert {
 
 function XcertMock(string _name, string _symbol)
     BurnableXcert(_name, _symbol)
-    SettableTransferXcert(_name, _symbol)
+    PausableXcert(_name, _symbol)
     ChainableXcert(_name, _symbol)
     public
   {

contracts/tokens/PausableXcert.sol

@@ -0,0 +1,53 @@
+pragma solidity ^0.4.19;
+
+import "./Xcert.sol";
+
+contract PausableXcert is Xcert {
+
+  /*
+   * @dev This emits when ability of beeing able to transfer NFTokens changes (paused/unpaused).
+   */
+  event IsPaused(bool _isPaused);
+
+  /*
+   * @dev Are NFTokens paused or not.
+   */
+  bool public isPaused;
+
+  function PausableXcert(string _name, string _symbol)
+    Xcert(_name, _symbol)
+    public
+  {
+    supportedInterfaces[0xbedb86fb] = true; // PausableXcert
+    isPaused = false;
+  }
+
+  /*
+   * @dev Guarantees that the msg.sender is allowed to transfer NFToken.
+   * @param _tokenId ID of the NFToken to transfer.
+   */
+  modifier canTransfer(uint256 _tokenId) {
+    address owner = idToOwner[_tokenId];
+    require(!isPaused && (
+      owner == msg.sender
+      || getApproved(_tokenId) == msg.sender
+      || ownerToOperators[owner][msg.sender])
+    );
+
+    _;
+  }
+
+  /*
+   * @dev Sets if NFTokens are paused or not.
+   * @param _isPaused Pause status.
+   */
+  function setPause(bool _isPaused)
+    external
+    onlyOwner
+  {
+    require(isPaused != _isPaused);
+    isPaused = _isPaused;
+    IsPaused(_isPaused);
+  }
+
+}

contracts/utils/Selector.sol

@@ -2,7 +2,7 @@ pragma solidity ^0.4.19;
 
 import "../tokens/Xcert.sol";
 import "../tokens/BurnableXcert.sol";
-import "../tokens/SettableTransferXcert.sol";
+import "../tokens/PausableXcert.sol";
 import "../tokens/ChainableXcert.sol";
 import "../protocol/Minter.sol";
 import "../protocol/Trader.sol";
@@ -23,9 +23,9 @@ contract Selector {
       return i.burn.selector;
     }
 
-    function calculateSettableTransferXcertSelector() public pure returns (bytes4) {
-      SettableTransferXcert i;
-      return i.setTransferable.selector;
+    function calculatePausableXcertSelector() public pure returns (bytes4) {
+      PausableXcert i;
+      return i.setPause.selector;
     }
 
     function calculateChainableXcertSelector() public pure returns (bytes4) {

test/tokens/PausableXcert.test.js

@@ -0,0 +1,45 @@
+const PausableXcert = artifacts.require('PausableXcert');
+const util = require('ethjs-util');
+const assertRevert = require('../helpers/assertRevert');
+
+contract('PausableXcert', (accounts) => {
+  let xcert;
+  let id1 = web3.sha3('test1');
+  let id2 = web3.sha3('test2');
+  let id3 = web3.sha3('test3');
+  let id4 = web3.sha3('test4');
+  let mockProof = "1e205550c271490347e5e2393a02e94d284bbe9903f023ba098355b8d75974c8";
+
+  beforeEach(async function () {
+    xcert = await PausableXcert.new('Foo', 'F');
+  });
+
+  it('correctly sets pause state', async () => {
+    var { logs } = await xcert.setPause(true);
+    let isPausedEvent = logs.find(e => e.event === 'IsPaused');
+    assert.notEqual(isPausedEvent, undefined);
+    var pauseState = await xcert.isPaused();
+    assert.equal(pauseState, true);
+  });
+
+  it('reverts trying to set the same pause state', async () => {
+    await assertRevert(xcert.setPause(false));
+  });
+
+  it('reverts when someone else then the owner tries to change pause state', async () => {
+    await assertRevert(xcert.setPause(true, {from: accounts[1]}));
+  });
+
+  it('succefully transfers when token is not paused', async () => {
+    await xcert.mint(accounts[0], id1, mockProof, 'url1');
+    await xcert.transferFrom(accounts[0], accounts[1], id1);
+    var owner = await xcert.ownerOf(id1);
+    assert.equal(owner, accounts[1]);
+  });
+
+  it('reverts trying to transfer when token is paused', async () => {
+    await xcert.mint(accounts[0], id1, mockProof, 'url1');
+    await xcert.setPause(true);
+    await assertRevert(xcert.transferFrom(accounts[0], accounts[1], id1));
+  });
+});

test/tokens/XcertMock.test.js

@@ -23,7 +23,7 @@ contract('XcertMock', (accounts) => {
   });
 
   it('reverts trying to transfer when transfers are disabled', async () => {
-    await xcert.setTransferable(false);
+    await xcert.setPause(true);
     await assertRevert(xcert.transferFrom(accounts[0], accounts[1], id1));
   });
 

test/utils/Selector.test.js

@@ -1,7 +1,7 @@
 const Xcert = artifacts.require('Xcert');
 const BurnableXcert = artifacts.require('BurnableXcert');
 const ChainableXcert = artifacts.require('ChainableXcert');
-const SettableTransferXcert = artifacts.require('SettableTransferXcert');
+const PausableXcert = artifacts.require('PausableXcert');
 const Minter = artifacts.require('Minter');
 const Trader = artifacts.require('Trader');
 const Swapper = artifacts.require('Swapper');
@@ -29,9 +29,9 @@ contract('Selector', (accounts) => {
     assert.equal(supports, true);
   });
 
-  it('Checks SettableTransferXcert selector', async () => {
-    var xcert = await SettableTransferXcert.new('Foo', 'F');
-    var bytes = await selector.calculateSettableTransferXcertSelector();
+  it('Checks PausableXcert selector', async () => {
+    var xcert = await PausableXcert.new('Foo', 'F');
+    var bytes = await selector.calculatePausableXcertSelector();
     var supports = await xcert.supportsInterface(bytes);
     assert.equal(supports, true);
   });