axelar-cgp-sui

Module relayer_discovery::discovery

This module implements a discovery mechanic for the Relayer to be able to call some (!) transactions automatically.

Warning: this solution does allow for any transaction to be executed and should be treated as a reference and a temporary solution until there’s a proper discovery / execution mechanism in place.

use axelar_gateway::bytes32;
use axelar_gateway::channel;
use axelar_gateway::events;
use axelar_gateway::message;
use axelar_gateway::weighted_signer;
use axelar_gateway::weighted_signers;
use relayer_discovery::events;
use relayer_discovery::owner_cap;
use relayer_discovery::relayer_discovery_v0;
use relayer_discovery::transaction;
use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::vector;
use sui::address;
use sui::bcs;
use sui::dynamic_field;
use sui::event;
use sui::hash;
use sui::hex;
use sui::object;
use sui::party;
use sui::table;
use sui::transfer;
use sui::tx_context;
use sui::vec_map;
use sui::vec_set;
use sui::versioned;
use version_control::version_control;

Struct RelayerDiscovery

Structs ——-

public struct RelayerDiscovery has key
Fields
id: sui::object::UID
inner: sui::versioned::Versioned

Constants

Version ——- This is the version of the package that should change every package upgrade.

const VERSION: u64 = 0;

This is the version of the data that should change when we need to migrate Versioned type (e.g. from RelayerDiscovery_v0 to RelayerDiscovery_v1)

const DATA_VERSION: u64 = 0;

Function init

fun init(ctx: &mut sui::tx_context::TxContext)
Implementation 
fun init(ctx: &mut TxContext) {
    let inner = versioned::create(
        DATA_VERSION,
        relayer_discovery_v0::new(
            version_control(),
            ctx,
        ),
        ctx,
    );
    transfer::share_object(RelayerDiscovery {
        id: object::new(ctx),
        inner,
    });
    transfer::public_transfer(owner_cap::create(ctx), ctx.sender());
}

Macro function value

Macros ——

macro fun value($self: &relayer_discovery::discovery::RelayerDiscovery, $function_name: vector<u8>): &relayer_discovery::relayer_discovery_v0::RelayerDiscovery_v0
Implementation 
macro fun value($self: &RelayerDiscovery, $function_name: vector<u8>): &RelayerDiscovery_v0 {
    let relayer_discovery = $self;
    let value = relayer_discovery.inner.load_value<RelayerDiscovery_v0>();
    value.version_control().check(VERSION, ascii::string($function_name));
    value
}

Macro function value_mut

macro fun value_mut($self: &mut relayer_discovery::discovery::RelayerDiscovery, $function_name: vector<u8>): &mut relayer_discovery::relayer_discovery_v0::RelayerDiscovery_v0
Implementation 
macro fun value_mut($self: &mut RelayerDiscovery, $function_name: vector<u8>): &mut RelayerDiscovery_v0 {
    let relayer_discovery = $self;
    let value = relayer_discovery.inner.load_value_mut<RelayerDiscovery_v0>();
    value.version_control().check(VERSION, ascii::string($function_name));
    value
}

Function allow_function

entry fun allow_function(self: &mut relayer_discovery::discovery::RelayerDiscovery, _: &relayer_discovery::owner_cap::OwnerCap, version: u64, function_name: std::ascii::String)
Implementation 
entry fun allow_function(self: &mut RelayerDiscovery, _: &OwnerCap, version: u64, function_name: String) {
    self.value_mut!(b"allow_function").allow_function(version, function_name);
}

Function disallow_function

entry fun disallow_function(self: &mut relayer_discovery::discovery::RelayerDiscovery, _: &relayer_discovery::owner_cap::OwnerCap, version: u64, function_name: std::ascii::String)
Implementation 
entry fun disallow_function(self: &mut RelayerDiscovery, _: &OwnerCap, version: u64, function_name: String) {
    self.value_mut!(b"disallow_function").disallow_function(version, function_name);
}

Function register_transaction

During the creation of the object, the UID should be passed here to receive the Channel and emit an event which will be handled by the Relayer.

Example:

let id = object::new(ctx);
let channel = discovery::create_configuration(
relayer_discovery, &id, contents, ctx
);
let wrapper = ExampleWrapper { id, channel };
transfer::share_object(wrapper);

Note: Wrapper must be a shared object so that Relayer can access it.

public fun register_transaction(self: &mut relayer_discovery::discovery::RelayerDiscovery, channel: &axelar_gateway::channel::Channel, tx: relayer_discovery::transaction::Transaction)
Implementation 
public fun register_transaction(self: &mut RelayerDiscovery, channel: &Channel, tx: Transaction) {
    let value = self.value_mut!(b"register_transaction");
    let channel_id = channel.id();
    value.set_transaction(channel_id, tx);
}

Function remove_transaction

public fun remove_transaction(self: &mut relayer_discovery::discovery::RelayerDiscovery, channel: &axelar_gateway::channel::Channel)
Implementation 
public fun remove_transaction(self: &mut RelayerDiscovery, channel: &Channel) {
    let value = self.value_mut!(b"remove_transaction");
    let channel_id = channel.id();
    value.remove_transaction(channel_id);
}

Function get_transaction

Get a transaction for a specific channel by the channel ID.

public fun get_transaction(self: &relayer_discovery::discovery::RelayerDiscovery, channel_id: sui::object::ID): relayer_discovery::transaction::Transaction
Implementation 
public fun get_transaction(self: &RelayerDiscovery, channel_id: ID): Transaction {
    let value = self.value!(b"register_transaction");
    value.get_transaction(channel_id)
}

Function version_control

Private Functions —————–

fun version_control(): version_control::version_control::VersionControl
Implementation 
fun version_control(): VersionControl {
    version_control::new(vector[
        // version 0
        vector[b"register_transaction", b"remove_transaction", b"get_transaction", b"allow_function", b"disallow_function"].map!(
            |function_name| function_name.to_ascii_string(),
        ),
    ])
}
This site is open source. Improve this page.