feat(gear-programs): vft-gateway & bridging-payment

Cargo.toml

@@ -4,10 +4,13 @@ members = [
     "ethereum/client",
     "gear-rpc-client",
     "prover",
-    "relayer",
+  #  "relayer",
     "circuits/*",
     "ethereum-common",
-    "gear-programs/*",
+    "gear-programs/grc20-gateway/app",
+    "gear-programs/grc20-gateway/wasm",
+    "gear-programs/bridging-payment/app",
+    "gear-programs/bridging-payment/wasm",
 ]
 
 resolver = "2"
@@ -27,7 +30,6 @@ plonky2_u32 = { path = "./circuits/plonky2_u32" }
 ethereum-client = { path = "./ethereum/client" }
 ethereum-common = { path = "ethereum-common", default-features = false }
 
-grc20_gateway = { path = "gear-programs/grc20-gateway" }
 bridging_payment = { path = "gear-programs/bridging-payment" }
 
 plonky2 = { git = "https://github.com/gear-tech/plonky2.git", rev = "4a620f4d79efe9233d0e7682df5a2fc625b5420e" }
@@ -80,7 +82,10 @@ unroll = "0.1.5"
 
 # Gear/Substrate deps
 gstd = { version = "1.4.1", features = ["nightly"] }
+gear-core = "1.4.1"
+gclient = "1.4.1"
 gear-wasm-builder = { version = "1.4.1", default-features = false }
+gwasm-builder = { package = "gear-wasm-builder", version = "1.1.1" }
 gsdk = { git = "https://github.com/gear-tech/gear.git", branch = "dn-pallet-gear-bridge" }
 pallet-gear-bridge-rpc-runtime-api = { git = "https://github.com/gear-tech/gear.git", branch = "dn-pallet-gear-bridge", default-features = false, features = [
     "std",
@@ -131,6 +136,13 @@ alloy-sol-type-parser = { git = "https://github.com/alloy-rs/core.git", package
     "std",
 ] }
 
+sails-idl-gen = { git = "https://github.com/gear-tech/sails" }
+sails-client-gen = { git = "https://github.com/gear-tech/sails" }
+sails-rtl = { git = "https://github.com/gear-tech/sails" }
+
+gbuiltin-bridge = { git = "https://github.com/gear-tech/gear", branch = "dn-pallet-gear-bridge" }
+git-download = "0.1"
+
 [patch.crates-io]
 alloy-primitives = { git = "https://github.com/alloy-rs/core.git", package = "alloy-primitives", rev = "1bac7678797fcd1bee2f2580825724b4165b12c1" }
 alloy-sol-types = { git = "https://github.com/alloy-rs/core.git", package = "alloy-sol-types", rev = "1bac7678797fcd1bee2f2580825724b4165b12c1" }

gear-programs/bridging-payment/app/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "bridge-payment-app"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sails-rtl.workspace = true
+parity-scale-codec.workspace = true
+scale-info.workspace = true
+gstd.workspace = true
+gbuiltin-bridge.workspace = true
+
+[build-dependencies]
+git-download.workspace = true
+sails-client-gen.workspace = true

gear-programs/bridging-payment/app/build.rs

@@ -0,0 +1,11 @@
+use std::{env, path::PathBuf};
+
+fn main() {
+    let out_dir_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+
+    let idl_file_path = PathBuf::from("../../grc20-gateway/wasm/grc20-gateway.idl");
+
+    let client_rs_file_path = out_dir_path.join("grc20-gateway.rs");
+
+    sails_client_gen::generate_client_from_idl(&idl_file_path, client_rs_file_path).unwrap();
+}

gear-programs/bridging-payment/app/src/lib.rs

@@ -0,0 +1,19 @@
+#![no_std]
+
+use sails_rtl::gstd::{gprogram, GStdExecContext};
+pub mod services;
+use services::{BridgePayment, InitConfig};
+#[derive(Default)]
+pub struct Program;
+
+#[gprogram]
+impl Program {
+    pub fn new(init_config: InitConfig) -> Self {
+        BridgePayment::<GStdExecContext>::seed(init_config, GStdExecContext::new());
+        Self
+    }
+
+    pub fn bridge_payment(&self) -> BridgePayment<GStdExecContext> {
+        BridgePayment::new(GStdExecContext::new())
+    }
+}

gear-programs/bridging-payment/app/src/services/grc20_gateway.rs

@@ -0,0 +1 @@
+include!(concat!(env!("OUT_DIR"), "/grc20-gateway.rs"));

gear-programs/bridging-payment/app/src/services/mod.rs

@@ -0,0 +1,193 @@
+use gstd::MessageId;
+use sails_rtl::{
+    gstd::{gservice, msg, ExecContext},
+    prelude::*,
+};
+
+use gstd::exec;
+mod grc20_gateway;
+mod utils;
+pub struct BridgePayment<ExecContext> {
+    exec_context: ExecContext,
+}
+
+#[derive(Encode, Decode, TypeInfo)]
+pub enum BridgePaymentEvents {
+    TeleportVaraToEth {
+        nonce: U256,
+        sender: ActorId,
+        amount: U256,
+        receiver: H160,
+        eth_token_id: H160,
+    },
+}
+
+static mut DATA: Option<BridgePaymentData> = None;
+static mut CONFIG: Option<Config> = None;
+
+#[derive(Debug)]
+pub struct BridgePaymentData {
+    admin_address: ActorId,
+    grc20_gateway_address: ActorId,
+}
+
+#[derive(Debug, Decode, Encode, TypeInfo)]
+pub struct InitConfig {
+    admin_address: ActorId,
+    grc20_gateway_address: ActorId,
+    config: Config,
+}
+
+impl InitConfig {
+    pub fn new(admin_address: ActorId, grc20_gateway_address: ActorId, config: Config) -> Self {
+        Self {
+            admin_address,
+            grc20_gateway_address,
+            config,
+        }
+    }
+}
+
+#[derive(Debug, Decode, Encode, TypeInfo)]
+pub struct Config {
+    fee: u128,
+    gas_for_reply_deposit: u64,
+    gas_to_send_request_to_gateway: u64,
+}
+
+impl Config {
+    pub fn new(fee: u128, gas_for_reply_deposit: u64, gas_to_send_request_to_gateway: u64) -> Self {
+        Self {
+            fee,
+            gas_for_reply_deposit,
+            gas_to_send_request_to_gateway,
+        }
+    }
+}
+impl<T> BridgePayment<T>
+where
+    T: ExecContext,
+{
+    pub fn seed(config: InitConfig, exec_context: T) {
+        unsafe {
+            DATA = Some(BridgePaymentData {
+                admin_address: exec_context.actor_id(),
+                grc20_gateway_address: config.grc20_gateway_address,
+            });
+            CONFIG = Some(config.config);
+        }
+    }
+    pub fn new(exec_context: T) -> Self {
+        Self { exec_context }
+    }
+
+    fn data(&self) -> &BridgePaymentData {
+        unsafe {
+            DATA.as_ref()
+                .expect("BridgePaymentData::seed() should be called")
+        }
+    }
+
+    fn data_mut(&mut self) -> &mut BridgePaymentData {
+        unsafe {
+            DATA.as_mut()
+                .expect("BridgePaymentData::seed() should be called")
+        }
+    }
+
+    fn config(&self) -> &Config {
+        unsafe {
+            CONFIG
+                .as_ref()
+                .expect("BridgePaymentData::seed() should be called")
+        }
+    }
+
+    fn config_mut(&self) -> &mut Config {
+        unsafe {
+            CONFIG
+                .as_mut()
+                .expect("BridgePaymentData::seed() should be called")
+        }
+    }
+
+    pub fn handle_reply() {}
+}
+
+#[gservice(events = BridgePaymentEvents)]
+impl<T> BridgePayment<T>
+where
+    T: ExecContext,
+{
+    pub fn set_fee(&mut self, fee: u128) {
+        let data = self.data();
+        if data.admin_address != self.exec_context.actor_id() {
+            panic!("Not admin");
+        }
+        let config: &mut Config = self.config_mut();
+        config.fee = fee;
+    }
+
+    pub fn reclaim_fee(&mut self) {
+        let data = self.data();
+        if data.admin_address != self.exec_context.actor_id() {
+            panic!("Not admin");
+        }
+        let fee_balance = exec::value_available();
+        msg::send_with_gas(data.admin_address.into(), "", 0, fee_balance)
+            .expect("Failed to reclaim fees");
+    }
+
+    pub async fn request_to_gateway(
+        &mut self,
+        sender: ActorId,
+        amount: U256,
+        receiver: [u8; 20],
+        eth_token_id: [u8; 20],
+    ) {
+        let data = self.data();
+        let config = self.config();
+
+        let attached_value = msg::value();
+
+        if attached_value < config.fee {
+            panic!("Not enough fee");
+        }
+        match utils::send_message_to_gateway(
+            data.grc20_gateway_address,
+            sender,
+            amount,
+            receiver,
+            eth_token_id,
+            config,
+        )
+        .await
+        {
+            Ok(Ok(nonce)) => {
+                self.notify_on(BridgePaymentEvents::TeleportVaraToEth {
+                    nonce,
+                    sender,
+                    amount,
+                    receiver: receiver.into(),
+                    eth_token_id: eth_token_id.into(),
+                })
+                .expect("Error in depositing event");
+
+                // return remainder
+                let refund = self.config().fee - attached_value;
+                if refund >= exec::env_vars().existential_deposit {
+                    handle_refund(self.exec_context.actor_id(), refund);
+                }
+            }
+
+            _ => {
+                // Handle refund for the full attached value on any error
+                handle_refund(self.exec_context.actor_id(), attached_value);
+            }
+        }
+    }
+}
+
+fn handle_refund(actor_id: ActorId, amount: u128) {
+    msg::send_with_gas(actor_id.into(), "", 0, amount).expect("Error in refund");
+}

gear-programs/bridging-payment/app/src/services/utils.rs

@@ -0,0 +1,50 @@
+use super::{grc20_gateway, Config};
+use gstd::{msg, prelude::collections::HashMap, MessageId};
+use sails_rtl::prelude::*;
+
+#[derive(Debug, Encode, Decode, TypeInfo)]
+pub enum Error {
+    RequestToGateWaySendError,
+    RequestToGateWayReplyError,
+    RequestToGateWayDecodeError,
+    RequestToBuiltinReplyError,
+    PayloadSizeError,
+    MintTokensSendError,
+    MintTokensReplyError,
+    MintTokensDecodeError,
+    ReplyTimeoutError,
+    TokensRefundedError,
+}
+
+pub async fn send_message_to_gateway(
+    gateway_address: ActorId,
+    sender: ActorId,
+    amount: U256,
+    receiver: [u8; 20],
+    eth_token_id: [u8; 20],
+    config: &Config,
+) -> Result<Result<U256, grc20_gateway::Error>, Error> {
+    let bytes: Vec<u8> = grc20_gateway::grc_20_gateway_io::TeleportVaraToEth::encode_call(
+        sender,
+        amount,
+        receiver,
+        eth_token_id,
+    );
+
+    let reply_bytes = msg::send_bytes_with_gas_for_reply(
+        gateway_address.into(),
+        bytes,
+        config.gas_to_send_request_to_gateway,
+        0,
+        config.gas_for_reply_deposit,
+    )
+    .map_err(|_| Error::RequestToGateWaySendError)?
+    .await
+    .map_err(|_| Error::RequestToGateWayReplyError)?;
+
+    let reply: Result<U256, grc20_gateway::Error> =
+        grc20_gateway::grc_20_gateway_io::TeleportVaraToEth::decode_reply(&reply_bytes)
+            .map_err(|_| Error::RequestToGateWayDecodeError)?;
+
+    Ok(reply)
+}