Implement submitDatagram

Author: majecty

ibc.ts/package.json

@@ -17,6 +17,8 @@
     "typescript": "^3.8.2"
   },
   "dependencies": {
+    "codechain-primitives": "^1.0.4",
+    "codechain-sdk": "^2.0.1",
     "debug": "^4.1.1",
     "rlp": "^2.0.0"
   }

ibc.ts/src/common/chain.ts

@@ -1,7 +1,60 @@
 import { Datagram } from "./datagram/index";
+import { SDK } from "codechain-sdk";
+import { H256, PlatformAddress } from "codechain-primitives";
+import { IBC } from "./foundry/transaction";
+import { delay } from "./util";
+import Debug from "debug";
+
+const debug = Debug("common:tx");
+
+export interface ChainConfig {
+    /**
+     * Example: "http://localhost:8080"
+     */
+    server: string;
+    networkId: string;
+    faucetAddress: PlatformAddress;
+}
 
 export class Chain {
-    public async submitDatagram(datagram: Datagram): Promise<any> {
-        return null;
+    private readonly sdk: SDK;
+    private readonly faucetAddress: PlatformAddress;
+
+    public constructor(config: ChainConfig) {
+        this.sdk = new SDK({
+            server: config.server,
+            networkId: config.networkId
+        });
+        this.faucetAddress = config.faucetAddress;
+    }
+
+    public async submitDatagram(datagram: Datagram): Promise<void> {
+        const ibcAction = new IBC(this.sdk.networkId, datagram.rlpBytes());
+
+        const seq = await this.sdk.rpc.chain.getSeq(this.faucetAddress);
+        const signedTx = await this.sdk.key.signTransaction(ibcAction, {
+            account: this.faucetAddress,
+            fee: 100,
+            seq
+        });
+
+        const txHash = await this.sdk.rpc.chain.sendSignedTransaction(signedTx);
+        waitForTx(this.sdk, txHash);
     }
 }
+
+async function waitForTx(sdk: SDK, txHash: H256) {
+    const timeout = delay(10 * 1000).then(() => {
+        throw new Error("Timeout");
+    });
+    const wait = (async () => {
+        while (true) {
+            debug(`wait tx: ${txHash.toString()}`);
+            if (sdk.rpc.chain.containsTransaction(txHash)) {
+                return;
+            }
+            await delay(500);
+        }
+    })();
+    return Promise.race([timeout, wait]);
+}

ibc.ts/src/common/foundry/transaction.ts

@@ -0,0 +1,30 @@
+import { Transaction } from "codechain-sdk/lib/core/classes";
+import { NetworkId } from "codechain-sdk/lib/core/types";
+
+export interface IBCActionJSON {
+    bytes: Buffer;
+}
+
+export class IBC extends Transaction {
+    private readonly bytes: Buffer;
+
+    public constructor(networkId: NetworkId, bytes: Buffer) {
+        super(networkId);
+        this.bytes = bytes;
+    }
+
+    public type(): string {
+        return "ibc";
+    }
+
+    protected actionToEncodeObject(): any[] {
+        return [0x20, this.bytes];
+    }
+
+    // Since the result type is hard-coded in the SDK, we should use any type here.
+    protected actionToJSON(): any {
+        return {
+            bytes: this.bytes
+        };
+    }
+}

ibc.ts/src/relayer/config.ts

@@ -0,0 +1,38 @@
+export interface Config {
+    chainA: FoundryChainConfig;
+    chainB: FoundryChainConfig;
+}
+
+interface FoundryChainConfig {
+    /**
+     * Foundry RPC URL
+     * ex) http://localhost:8080
+     */
+    rpcURL: string;
+    networkId: string;
+    faucetAddress: string;
+}
+
+export function getConfig(): Config {
+    return {
+        chainA: {
+            rpcURL: getEnv("CHAIN_A_RPC_URL"),
+            networkId: getEnv("CHAIN_A_NETWORK_ID"),
+            faucetAddress: getEnv("CHAIN_A_FAUCET_ADDRESS")
+        },
+        chainB: {
+            rpcURL: getEnv("CHAIN_B_RPC_URL"),
+            networkId: getEnv("CHAIN_B_NETWORK_ID"),
+            faucetAddress: getEnv("CHAIN_B_FAUCET_ADDRESS")
+        }
+    };
+}
+
+function getEnv(key: string): string {
+    const result = process.env[key];
+    if (result) {
+        return result;
+    } else {
+        throw new Error(`Environment variable ${key} is not set`);
+    }
+}

ibc.ts/src/relayer/index.ts

@@ -2,12 +2,23 @@ import Debug from "debug";
 import { Chain } from "../common/chain";
 import { Datagram } from "../common/datagram/index";
 import { delay } from "../common/util";
+import { getConfig } from "./config";
+import { PlatformAddress } from "codechain-primitives/lib";
 
 const debug = Debug("relayer:main");
 
 async function main() {
-    const chainA = new Chain();
-    const chainB = new Chain();
+    const config = getConfig();
+    const chainA = new Chain({
+        server: config.chainA.rpcURL,
+        networkId: config.chainA.networkId,
+        faucetAddress: PlatformAddress.fromString(config.chainA.faucetAddress)
+    });
+    const chainB = new Chain({
+        server: config.chainB.rpcURL,
+        networkId: config.chainB.networkId,
+        faucetAddress: PlatformAddress.fromString(config.chainB.faucetAddress)
+    });
 
     while (true) {
         debug("Run relay");