wip: evm to wasm relayer connection complete

Author: realnimish

packages/gateway/src/index.ts

@@ -4,6 +4,8 @@ import { readFileSync } from 'fs';
 import { ethers } from 'ethers';
 import { AzeroId } from './azero-id';
 import { GasLimit } from './utils';
+import { Relayer } from './registration-relayer';
+import { Keyring } from '@polkadot/keyring';
 import supportedTLDs from './supported-tlds.json';
 
 const program = new Command();
@@ -28,7 +30,7 @@ const signer = new ethers.utils.SigningKey(privateKey);
 
 // TODO: make it configurable
 const defaultGasLimit: GasLimit = {
-  refTime: 10_000_000_000,
+  refTime: 100_000_000_000,
   proofSize: 1_000_000,
 };
 
@@ -43,4 +45,24 @@ AzeroId.init(
   const app = makeApp(signer, '/', db);
   console.log(`Serving on port ${options.port} with signing address ${address}`);
   app.listen(parseInt(options.port));
+}).then(async () => {
+  // TODO: make it configurable
+  const evmProviderURL = "https://ethereum-sepolia.publicnode.com";
+  const evmRelayerAddr = "0x2BaD727319377af238a7F6D166494118Ca9D0497";
+  const wasmRelayerAddr = "5GNDka5xV9y9nsES2gqYQponJ8vJaAmoJjMUvrqGqPF65q7P";;
+  const wasmProviderURL = options.providerUrl;
+  const keyring = new Keyring({ type: 'sr25519' });
+  const seed = "0xd5836897dc77e6c87e5cc268abaaa9c661bcf19aea9f0f50a1e149d21ce31eb7"; // public seed
+  const wasmSigner = keyring.createFromUri(seed);
+
+  const relayer = await Relayer.init(
+    evmProviderURL,
+    evmRelayerAddr,
+    wasmProviderURL,
+    wasmRelayerAddr,
+    wasmSigner,
+    defaultGasLimit
+  );
+
+  relayer.start();
 });

packages/gateway/src/registration-relayer.ts

@@ -0,0 +1,111 @@
+import { ethers } from 'ethers';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { ContractPromise } from '@polkadot/api-contract';
+import { KeyringPair } from '@polkadot/keyring/types';
+import type { WeightV2 } from '@polkadot/types/interfaces';
+import evmABI from './artefacts/evm.json';
+import wasmABI from './artefacts/wasm.json';
+import { GasLimit } from './utils';
+
+export class Relayer {
+    evm: ethers.Contract;
+    wasm: ContractPromise;
+    wasmSigner: KeyringPair;
+    wasmGasLimit: WeightV2;
+
+    constructor(
+        evm: ethers.Contract, 
+        wasm: ContractPromise, 
+        wasmSigner: KeyringPair, 
+        wasmGasLimit: WeightV2
+    ) {
+        this.evm = evm;
+        this.wasm = wasm;
+        this.wasmSigner = wasmSigner;
+        this.wasmGasLimit = wasmGasLimit
+    }
+
+    static async init(
+        evmProviderURL: string, 
+        evmAddr: string, 
+        wasmProviderURL: string, 
+        wasmAddr: string,
+        wasmSigner: KeyringPair,
+        wasmGasLimit: GasLimit
+    ): Promise<Relayer> {
+        const evmProvider = ethers.getDefaultProvider(evmProviderURL);
+        const evm = new ethers.Contract(evmAddr, evmABI, evmProvider);
+
+        const wsProvider = new WsProvider(wasmProviderURL);
+        const api = await ApiPromise.create({ provider: wsProvider });
+        const wasm = new ContractPromise(api, wasmABI, wasmAddr);
+        const weightV2 = api.registry.createType('WeightV2', wasmGasLimit) as WeightV2;
+
+        return new Relayer(evm, wasm, wasmSigner, weightV2);
+    }
+
+    start() {
+        this.evm.on("InitiateRequest", (id, name, recipient, yearsToRegister, value, ttl) => {
+            console.log("New request:", Number(id), name, ttl);
+            // TODO: Check ttl is valid
+            this.executeRequest(Number(id), name, recipient, Number(yearsToRegister), value);
+        })
+    }
+
+    async executeRequest(
+        id: number, 
+        name: string, 
+        recipient: string, 
+        yearsToRegister: number, 
+        maxFeesInEVM: number
+    ) {
+        const maxFeesInWASM = this.valueEVM2WASM(maxFeesInEVM);
+
+        // TODO: first dry-run to save Tx which would fail
+        
+        await this.wasm.tx.register(
+            {
+                gasLimit: this.wasmGasLimit
+            },
+            id,
+            name,
+            recipient,
+            yearsToRegister,
+            maxFeesInWASM,
+        )
+        .signAndSend(this.wasmSigner, ({ events = [], status }) => {
+            if (status.isFinalized) {
+                let successEventRecord = events.find((eventRecord) => {
+                    const isContractEvent = this.wasm.api.events.contracts.ContractEmitted.is;
+                    const verifyEventEmitter = (addr: any) => eventRecord.event.data.at(0)?.eq(addr);
+                    
+                    const successEventExists = (eventRecord: any, id: number) => {
+                        const decoded = this.wasm.abi.decodeEvent(eventRecord);
+                        const emittedID = Number(decoded.args[0]);
+                        return decoded.event.identifier === "wasm::registration_proxy::Success" &&
+                            emittedID === id;
+                    };
+
+                    return isContractEvent(eventRecord.event) && 
+                        verifyEventEmitter(this.wasm.address) &&
+                        successEventExists(eventRecord, id);
+                });
+
+                if (successEventRecord === undefined) {
+                    // Failure
+                    console.log("Failed to register")
+                } else {
+                    // Success
+                    const decoded = this.wasm.abi.decodeEvent(successEventRecord);
+                    const priceInWASM = Number(decoded.args[1]);
+                    console.log("Registered successfully with price:", priceInWASM);
+                }
+            }
+        });
+    }
+
+    private valueEVM2WASM(valueInEVM: number) {
+        // TODO: set value converter properly
+        return valueInEVM + 10000000000000;
+    }
+}