Send connection datagrams in the scenario script and the relayer

Park Juhyung · majecty · commit 8ddaa958a46f · 2020-03-10T18:58:03.000+09:00
* connOpenInit
* connOpenTry
* connOpenAck
* connOpenConfirm
diff --git a/ibc.ts/src/common/datagram/connOpenAck.ts b/ibc.ts/src/common/datagram/connOpenAck.ts
@@ -0,0 +1,44 @@
+const RLP = require("rlp");
+
+export class ConnOpenAckDatagram {
+    private identifier: string;
+    private proofTry: Buffer;
+    private proofConsensus: Buffer;
+    private proofHeight: number;
+    private consensusHeight: number;
+
+    public constructor({
+        identifier,
+        proofTry,
+        proofConsensus,
+        proofHeight,
+        consensusHeight
+    }: {
+        identifier: string;
+        proofTry: Buffer;
+        proofConsensus: Buffer;
+        proofHeight: number;
+        consensusHeight: number;
+    }) {
+        this.identifier = identifier;
+        this.proofTry = proofTry;
+        this.proofConsensus = proofConsensus;
+        this.proofHeight = proofHeight;
+        this.consensusHeight = consensusHeight;
+    }
+
+    public rlpBytes(): Buffer {
+        return RLP.encode(this.toEncodeObject());
+    }
+
+    public toEncodeObject(): any[] {
+        return [
+            5,
+            this.identifier,
+            this.proofTry,
+            this.proofConsensus,
+            this.proofHeight,
+            this.consensusHeight
+        ];
+    }
+}
diff --git a/ibc.ts/src/common/datagram/connOpenConfirm.ts b/ibc.ts/src/common/datagram/connOpenConfirm.ts
@@ -0,0 +1,29 @@
+const RLP = require("rlp");
+
+export class ConnOpenConfirmDatagram {
+    private identifier: string;
+    private proofAck: Buffer;
+    private proofHeight: number;
+
+    public constructor({
+        identifier,
+        proofAck,
+        proofHeight
+    }: {
+        identifier: string;
+        proofAck: Buffer;
+        proofHeight: number;
+    }) {
+        this.identifier = identifier;
+        this.proofAck = proofAck;
+        this.proofHeight = proofHeight;
+    }
+
+    public rlpBytes(): Buffer {
+        return RLP.encode(this.toEncodeObject());
+    }
+
+    public toEncodeObject(): any[] {
+        return [6, this.identifier, this.proofAck, this.proofHeight];
+    }
+}
diff --git a/ibc.ts/src/common/datagram/connOpenInit.ts b/ibc.ts/src/common/datagram/connOpenInit.ts
@@ -0,0 +1,44 @@
+const RLP = require("rlp");
+
+export class ConnOpenInitDatagram {
+    private id: string;
+    private desiredCounterpartyConnectionIdentifier: string;
+    private counterpartyPrefix: string;
+    private clientIdentifier: string;
+    private counterpartyClientIdentifier: string;
+
+    public constructor({
+        id,
+        desiredCounterpartyConnectionIdentifier,
+        counterpartyPrefix,
+        clientIdentifier,
+        counterpartyClientIdentifier
+    }: {
+        id: string;
+        desiredCounterpartyConnectionIdentifier: string;
+        counterpartyPrefix: string;
+        clientIdentifier: string;
+        counterpartyClientIdentifier: string;
+    }) {
+        this.id = id;
+        this.desiredCounterpartyConnectionIdentifier = desiredCounterpartyConnectionIdentifier;
+        this.counterpartyPrefix = counterpartyPrefix;
+        this.clientIdentifier = clientIdentifier;
+        this.counterpartyClientIdentifier = counterpartyClientIdentifier;
+    }
+
+    public rlpBytes(): Buffer {
+        return RLP.encode(this.toEncodeObject());
+    }
+
+    public toEncodeObject(): any[] {
+        return [
+            3,
+            this.id,
+            this.desiredCounterpartyConnectionIdentifier,
+            this.counterpartyPrefix,
+            this.clientIdentifier,
+            this.counterpartyClientIdentifier
+        ];
+    }
+}
diff --git a/ibc.ts/src/common/datagram/connOpenTry.ts b/ibc.ts/src/common/datagram/connOpenTry.ts
@@ -0,0 +1,64 @@
+const RLP = require("rlp");
+
+export class ConnOpenTryDatagram {
+    private desiredIdentifier: string;
+    private counterpartyConnectionIdentifier: string;
+    private counterpartyPrefix: string;
+    private counterpartyClientIdentifier: string;
+    private clientIdentifier: string;
+    private proofInit: Buffer;
+    private proofConsensus: Buffer;
+    private proofHeight: number;
+    private consensusHeight: number;
+
+    public constructor({
+        desiredIdentifier,
+        counterpartyConnectionIdentifier,
+        counterpartyPrefix,
+        counterpartyClientIdentifier,
+        clientIdentifier,
+        proofInit,
+        proofConsensus,
+        proofHeight,
+        consensusHeight
+    }: {
+        desiredIdentifier: string;
+        counterpartyConnectionIdentifier: string;
+        counterpartyPrefix: string;
+        counterpartyClientIdentifier: string;
+        clientIdentifier: string;
+        proofInit: Buffer;
+        proofConsensus: Buffer;
+        proofHeight: number;
+        consensusHeight: number;
+    }) {
+        this.desiredIdentifier = desiredIdentifier;
+        this.counterpartyConnectionIdentifier = counterpartyConnectionIdentifier;
+        this.counterpartyPrefix = counterpartyPrefix;
+        this.counterpartyClientIdentifier = counterpartyClientIdentifier;
+        this.clientIdentifier = clientIdentifier;
+        this.proofInit = proofInit;
+        this.proofConsensus = proofConsensus;
+        this.proofHeight = proofHeight;
+        this.consensusHeight = consensusHeight;
+    }
+
+    public rlpBytes(): Buffer {
+        return RLP.encode(this.toEncodeObject());
+    }
+
+    public toEncodeObject(): any[] {
+        return [
+            4,
+            this.desiredIdentifier,
+            this.counterpartyConnectionIdentifier,
+            this.counterpartyPrefix,
+            this.counterpartyClientIdentifier,
+            this.clientIdentifier,
+            this.proofInit,
+            this.proofConsensus,
+            this.proofHeight,
+            this.consensusHeight
+        ];
+    }
+}
diff --git a/ibc.ts/src/relayer/index.ts b/ibc.ts/src/relayer/index.ts
@@ -6,6 +6,9 @@ import { getConfig } from "../common/config";
 import { PlatformAddress } from "codechain-primitives/lib";
 import { UpdateClientDatagram } from "../common/datagram/updateClient";
 import { strict as assert } from "assert";
+import { ConnOpenTryDatagram } from "../common/datagram/connOpenTry";
+import { ConnOpenAckDatagram } from "../common/datagram/connOpenAck";
+import { ConnOpenConfirmDatagram } from "../common/datagram/connOpenConfirm";
 
 require("dotenv").config();
 
@@ -97,6 +100,21 @@ async function pendingDatagrams({
         })
     );
 
+    const {
+        localDatagrams: localDatagramsForConnection,
+        counterpartyDatagrams: counterpartyDatagramsForConnection
+    } = await buildConnection({
+        chain,
+        counterpartyChain,
+        height,
+        counterpartyChainHeight
+    });
+
+    localDatagrams = localDatagrams.concat(localDatagramsForConnection);
+    counterpartyDatagrams = counterpartyDatagrams.concat(
+        counterpartyDatagramsForConnection
+    );
+
     return { localDatagrams, counterpartyDatagrams };
 }
 
@@ -136,3 +154,94 @@ async function updateLightClient({
 
     return datagrams;
 }
+
+async function buildConnection({
+    chain,
+    counterpartyChain,
+    height,
+    counterpartyChainHeight
+}: {
+    chain: Chain;
+    counterpartyChain: Chain;
+    height: number;
+    counterpartyChainHeight: number;
+}) {
+    const localDatagrams: Datagram[] = [];
+    const counterpartyDatagrams = [];
+    const connectionIdentifiers = await chain.queryClientConnections(height);
+
+    assert.notEqual(connectionIdentifiers, null, "Client should be exist");
+    for (const connectionIdentifier of connectionIdentifiers!.data || []) {
+        const client = await chain.queryClient(height);
+        const counterpartyClient = await counterpartyChain.queryClient(
+            counterpartyChainHeight
+        );
+
+        assert.strictEqual(
+            connectionIdentifier,
+            chain.counterpartyIdentifiers.connection,
+            "PoC supports only one connection"
+        );
+        const connectionEnd = await chain.queryConnection(height);
+        const counterpartyConnectionEnd = await counterpartyChain.queryConnection(
+            counterpartyChainHeight
+        );
+        assert.notEqual(
+            connectionEnd!.data,
+            null,
+            "Connection exists because we acquired the identifier from RPC"
+        );
+        if (
+            connectionEnd!.data!.state === "INIT" &&
+            counterpartyConnectionEnd!.data == null
+        ) {
+            counterpartyDatagrams.push(
+                new ConnOpenTryDatagram({
+                    desiredIdentifier:
+                        counterpartyChain.counterpartyIdentifiers.connection,
+                    counterpartyConnectionIdentifier:
+                        chain.counterpartyIdentifiers.connection,
+                    counterpartyClientIdentifier:
+                        chain.counterpartyIdentifiers.client,
+                    clientIdentifier:
+                        counterpartyChain.counterpartyIdentifiers.client,
+                    proofInit: Buffer.from(connectionEnd!.proof, "hex"),
+                    proofConsensus: Buffer.alloc(0),
+                    proofHeight: height,
+                    consensusHeight: client!.data!.number,
+                    counterpartyPrefix: ""
+                })
+            );
+        } else if (
+            connectionEnd!.data!.state === "INIT" &&
+            counterpartyConnectionEnd!.data!.state === "TRYOPEN"
+        ) {
+            localDatagrams.push(
+                new ConnOpenAckDatagram({
+                    identifier: chain.counterpartyIdentifiers.connection,
+                    proofTry: Buffer.from(
+                        counterpartyConnectionEnd!.proof,
+                        "hex"
+                    ),
+                    proofConsensus: Buffer.alloc(0),
+                    proofHeight: counterpartyChainHeight,
+                    consensusHeight: counterpartyClient!.data!.number
+                })
+            );
+        } else if (
+            connectionEnd!.data!.state === "OPEN" &&
+            counterpartyConnectionEnd!.data!.state === "TRYOPEN"
+        ) {
+            counterpartyDatagrams.push(
+                new ConnOpenConfirmDatagram({
+                    identifier:
+                        counterpartyChain.counterpartyIdentifiers.connection,
+                    proofAck: Buffer.from(connectionEnd!.proof, "hex"),
+                    proofHeight: height
+                })
+            );
+        }
+    }
+
+    return { localDatagrams, counterpartyDatagrams };
+}
diff --git a/ibc.ts/src/scenario/index.ts b/ibc.ts/src/scenario/index.ts
@@ -4,6 +4,7 @@ import { Chain } from "../common/chain";
 import { PlatformAddress } from "codechain-primitives/lib";
 import { CreateClientDatagram } from "../common/datagram/createClient";
 import { strict as assert } from "assert";
+import { ConnOpenInitDatagram } from "../common/datagram/connOpenInit";
 const { Select } = require("enquirer");
 
 require("dotenv").config();
@@ -56,6 +57,22 @@ async function main() {
         console.log("Create a light client in chain B");
         await createLightClient({ chain: chainB, counterpartyChain: chainA });
     }
+
+    const connectionPrompt = new Select({
+        name: "connection",
+        message: "Will you create connection?",
+        choices: ["yes", "skip", "exit"]
+    });
+    const connectionAnswer = await connectionPrompt.run();
+
+    if (connectionAnswer === "exit") {
+        return;
+    }
+
+    if (connectionAnswer === "yes") {
+        console.log("Create a connection");
+        await createConnection({ chainA, chainB });
+    }
 }
 
 main().catch(console.error);
@@ -103,3 +120,22 @@ async function createLightClient({
     assert.notEqual(clientStateAfter!.data, null, "client is initialized");
     debug(`Create client is ${JSON.stringify(clientStateAfter)}`);
 }
+
+async function createConnection({
+    chainA,
+    chainB
+}: {
+    chainA: Chain;
+    chainB: Chain;
+}) {
+    await chainA.submitDatagram(
+        new ConnOpenInitDatagram({
+            id: chainA.counterpartyIdentifiers.connection,
+            desiredCounterpartyConnectionIdentifier:
+                chainB.counterpartyIdentifiers.connection,
+            counterpartyPrefix: "",
+            clientIdentifier: chainA.counterpartyIdentifiers.client,
+            counterpartyClientIdentifier: chainB.counterpartyIdentifiers.client
+        })
+    );
+}
