Implementing light client algorithm

Author: majecty

ibc.ts/src/common/chain.ts

@@ -5,6 +5,7 @@ import { IBC } from "./foundry/transaction";
 import { delay } from "./util";
 import Debug from "debug";
 import { ClientState } from "./foundry/types";
+import { IBCHeader, IBCQueryResult } from "./types";
 
 const debug = Debug("common:tx");
 
@@ -36,7 +37,7 @@ export interface ChainConfig {
 export class Chain {
     private readonly sdk: SDK;
     private readonly faucetAddress: PlatformAddress;
-    private readonly counterpartyIdentifiers: CounterpartyIdentifiers;
+    public readonly counterpartyIdentifiers: CounterpartyIdentifiers;
 
     public constructor(config: ChainConfig) {
         this.sdk = new SDK({
@@ -64,6 +65,19 @@ export class Chain {
     public async latestHeight(): Promise<number> {
         return await this.sdk.rpc.chain.getBestBlockNumber();
     }
+
+    public async queryClient(
+        blockNumber: number
+    ): Promise<IBCQueryResult<ClientState> | null> {
+        return this.sdk.rpc.sendRpcRequest("ibc_query_client_state", [
+            this.counterpartyIdentifiers.client,
+            blockNumber
+        ]);
+    }
+
+    public async queryHeader(blockNumber: number): Promise<IBCHeader | null> {
+        return this.sdk.rpc.sendRpcRequest("ibc_compose_header", [blockNumber]);
+    }
 }
 
 async function waitForTx(sdk: SDK, txHash: H256) {

ibc.ts/src/common/datagram/updateClient.ts

@@ -0,0 +1,19 @@
+const RLP = require("rlp");
+
+export class UpdateClientDatagram {
+    private id: string;
+    private header: Buffer;
+
+    public constructor({ id, header }: { id: string; header: Buffer }) {
+        this.id = id;
+        this.header = header;
+    }
+
+    public rlpBytes(): Buffer {
+        return RLP.encode(this.toEncodeObject());
+    }
+
+    public toEncodeObject(): any[] {
+        return [2, this.id, this.header];
+    }
+}

ibc.ts/src/common/foundry/types.ts

@@ -0,0 +1,4 @@
+export interface ClientState {
+    number: number;
+    next_validator_set_hash: string;
+}

ibc.ts/src/common/types.ts

@@ -0,0 +1,6 @@
+export interface IBCQueryResult<T> {
+    data: T | null;
+    proof: string;
+}
+
+export type IBCHeader = string;

ibc.ts/src/relayer/index.ts

@@ -4,6 +4,7 @@ import { Datagram } from "../common/datagram/index";
 import { delay } from "../common/util";
 import { getConfig } from "./config";
 import { PlatformAddress } from "codechain-primitives/lib";
+import { UpdateClientDatagram } from "../common/datagram/updateClient";
 
 require("dotenv").config();
 
@@ -111,6 +112,27 @@ async function updateLightClient({
     height: number;
     counterpartyChainHeight: number;
 }): Promise<Datagram[]> {
-    console.error("Not implemented");
-    return [];
+    const datagrams = [];
+    const clientState = await chain.queryClient(height);
+
+    if (clientState!.data == null) {
+        throw new Error(
+            `No client state found. Please create a light client with identifier: ${chain.counterpartyIdentifiers.client}`
+        );
+    }
+    let currentBlockNumber = clientState!.data!.number;
+    while (currentBlockNumber < counterpartyChainHeight) {
+        const header = (await counterpartyChain.queryHeader(
+            currentBlockNumber + 1
+        ))!;
+        datagrams.push(
+            new UpdateClientDatagram({
+                id: chain.counterpartyIdentifiers.client,
+                header: Buffer.from(header, "hex")
+            })
+        );
+        currentBlockNumber += 1;
+    }
+
+    return datagrams;
 }