# HRMP channel opening
The goal of this tutorial is to show and explain how parachains can open their bidirectional channels with Statemine on Kusama network.

## Part 1. Opening the channel from Statemine to your parachain.

Key points:
- Each chain needs to send or accept incoming requests to open a channel with their parachain origin. Because Statemine is a common goods parachain, its root origin is controlled by the Kusama Relay Chain governance.
- In this part we will construct an XCM message with necessary instructions to open a channel from Statemine to your parachain and encode it to pass as a motion through democracy.

### Steps:
1. Create an extrinsic to request a channel opening from Statemine to your parachain. Go to Extrinsics page in Developer tab. Select **hrmp.initOpenChannel** extrinsic and fill parameters:
* *recipient* field should contain your paraid,
* *proposedMaxCapacity* is the maximum number of messages that can be pending in the channel at once
* *proposedmaxMessageSize* is the maximum total size of the messages that can be pending in the channel at once.

2. This extrinsic should be submitted by Statemine, therefore we do not submit the transaction. Instead we copy the *encoded call data* to further include in the Transact Instruction within the XCM message.
3. Now we need to create an XCM message to be sent to the Relay Chain (from Statemine). We construct the message on Statemine (!). Go to Developer -> Extrinsics -> **polkadotXcm.send(dest, message)**
* As of writing of this tutorial the version of multilocation is V1
* Fill field parents with 1 and interior with Here.
* Choose V2 for message

4. Our XCM message will consist of some XCM Instructions we want the Relay chain to execute.
* *WithdrawAsset*. This instruction enables available funds to be used for various purposes in the future. We will use these funds in the next Instruction to pay fees for the execution of our XCM message. This is in the context of its execution, which is on the Relay Chain, so parents should be 0 and the location is Here. This particular XCM message uses 0.000107 KSM, but it is possible to withdraw more funds to be sure in field *Fungible*.


* *BuyExecution*. This instruction pays execution fees.

* *Transact*. This instruction contains necessary calls that are to be executed by the recipient of the message - in this case, by the Relay Chain. The Native type will take on the origin of the parachain, in this case Statemine. The encoded call should be the call constructed above in step 1. These are the instructions we want to execute on behalf of the parachain.

* *RefundSurplus* instruction, which refunds any unused weight from execution.
* *DepositAsset* instruction, which instructs the executor to deposit any KSM that wasn't used on transaction fees back into the Kusama Treasury. So rather than a bit extra being left over, it uses exactly what it needs and returns the rest.

5. Because this message can only be executed with the chain’s root - in this case this is Kusama governance, we cannot submit this extrinsic. We need to copy the encoded data call again and make a motion to the governance for the Kusama Relay Chain to send this message to Statemine.
Go to Democracy module on Kusama (governance -> democracy) and submit the preimage.
6. Statemine is a common goods parachain and therefore it doesn’t have necessary balances to pay for the channel opening and the deposit. Apart from executing our XCM message, we would need to propose to forcetransfer some funds from Kusama treasury to Statemine. This is why we propose batch of calls - **utility.batchAll(calls)**.
7. At this time (Kusama v9130), the deposit is 5 KSM per one-way channel (i.e. a bi-directional channel would require 10 KSM). Make sure to *force_transfer* a little more for the *WithdrawAsset*. It is more than enough to add 0.1 for fees.
> Kusama Treasury Account: F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg2

> Statemine Account: F7fq1jSNVTPfJmaHaXCMtatT1EZefCUsa7rRiQVNR5efcah

8. Second call in the batch is **xcmPallet.send(dest, message)**. Because the call is executed on the Relay Chain, we are sending a Transact message that contains our encoded call to Statemine.

9. After the proposal is submitted the destiny of the channel opening will be decided by democracy. If approved, one thing left is to accept the incoming request on your chain. For this you only need to submit a regular extrinsic on chain **hrmp.hrmpAcceptOpenChannel(sender)** and pass the Statemine’s ParaId (1000) as a parameter.

The channel is open!

## Part 2. Opening the channel from your parachaini to Statemine.

Here we follow the reverse procedure - first we submit a transaction that requests channel opening with Statemine and then have Statemine accept it via governance.

### Steps:
1. First we construct and submit an extrinsic that requests channel opening with Statemine. Go to Developers -> Extrinsics, select **hrmp.initOpenChannel** like previously. The recipient field should contain Statemine’s paraid (1000). Unlike in part 1 we need to submit this transaction onchain to execute.
2. Now we follow a similar procedure that we used in part one.
* Construct extrinsic that accepts the request to open a channel with your ParaId as a parameter. Copy the encoded data call.
* Construct an XCM message with *WithdrawAssets*, *BuyExecution* and *Transact* Instructions.
* Create a proposal with a batch of calls (**balances.ForceTransfer** and **xcmPallet.send()**) and submit it.
* Wait for the governance to approve the proposal.