# Lock & Unlock Connector Scheme

Create contract with name `UTSConnectorLockUnlockShowcase` . 

You need to import:

```solidity
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@entangle-labs/uts-contracts/contracts/ERC20/UTSBase";
```

`UTSBase` is our main contract that should be inherited by any Token or Connector.

In this implementation we also used `Ownable`, `Pausable` and `IERC20Metadata`

```solidity
contract UTSConnectorLockUnlockShowcase is UTSBase, Ownable {}
```

We are starting with defining contract and dependencies. As access control we are choosing `Ownable`.

```solidity
constructor(
    address underlyingToken_,
    address _router,  
    uint256[] memory _allowedChainIds,
    ChainConfig[] memory _chainConfigs
) Ownable(msg.sender) {
    __UTSBase_init(underlyingToken_, IERC20Metadata(underlyingToken_).decimals());

    _setRouter(_router);
    _setChainConfig(_allowedChainIds, _chainConfigs);
}
```

Then we need do define constructor. Since it is connector, we need `underlyingToken_`(the token that will be bridged through UTS protocol). We need also setup `_router` address, that can be found [here](https://docs.entangle.fi/universal-token-standard/contract-addresses). 

`_allowedChainIds` are simply whitelist of chain id's, where you are allowing to bridge tokens. 

`_chainConfigs` is array of settings responsible for bridge settings. We described this config [here](https://docs.entangle.fi/universal-token-standard/developer-guides/manual-deploy/factory-blueprint-deployment).

In constructor we need to call `__UTSBase_init` function to initialize UTS Base contract. Also we need to set router and chain config.

{% hint style="info" %}
We can skip setting router and chain configs in constructor, but before starting bridging we need to do it with relevant public functions.
{% endhint %}

After this step we need to override 3 functions: `_mintTo`*,* `_burnFrom` and `_authorizeCall`. 

{% hint style="info" %}
Since this connector is working via lock/unlock scheme, you need to fulfill it, to start bridging to this connector. This can be done or via just transferring underlying token to connector, or  you can initially bridge your tokens from this connector to any chain where you have uts token or connector with non zero balance and initial money will be locked in connector.
{% endhint %}

```solidity
function _authorizeCall() internal override onlyOwner() {}
```

```solidity
function _burnFrom(
    address spender,
    address /* from */, 
    bytes memory /* to */, 
    uint256 amount, 
    uint256 /* dstChainId */, 
    bytes memory /* customPayload */
) internal override returns(uint256 bridgedAmount) {
    IERC20(_underlyingToken).safeTransferFrom(spender, address(this), amount);

    return amount;
}
```

```solidity
function _mintTo(    
    address to,
    uint256 amount,
    bytes memory /* customPayload */,
    Origin memory /* origin */
) internal override returns(uint256 receivedAmount) {
    IERC20(_underlyingToken).safeTransfer(to, amount);

    return amount;
}
```

So, here is very simple logic, in the outbounding `bridge` transaction, we need to transfer tokens from `spender` to connector address, in the inbounding `redeem` transaction, we need to transfer tokens from connector to receiver `to` address. 

Also we will implement one more function: getter for underlying token decimals.

```solidity
function underlyingDecimals() external view returns(uint8) {
    return _decimals;
}

```

Also we need to use `SafeERC20` library by OpenZeppelin.

```solidity
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

using SafeERC20 for IERC20;
```

So, our contract is ready, now it can be deployed on networks and we can start bridging tokens between each chain.

{% hint style="info" %}
You can find full code [here](https://github.com/Entangle-Protocol/uts-sc-v1/blob/main/contracts/ERC20/showcases/UTSConnectorLockUnlockShowcase.sol)
{% endhint %}