본문으로 건너뛰기

Module bridge::committee

use bridge::chain_ids;
use bridge::crypto;
use bridge::message;
use bridge::message_types;
use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::u64;
use std::vector;
use sui::accumulator;
use sui::accumulator_metadata;
use sui::accumulator_settlement;
use sui::address;
use sui::bag;
use sui::balance;
use sui::bcs;
use sui::coin;
use sui::config;
use sui::deny_list;
use sui::dynamic_field;
use sui::dynamic_object_field;
use sui::ecdsa_k1;
use sui::event;
use sui::funds_accumulator;
use sui::hash;
use sui::hex;
use sui::object;
use sui::party;
use sui::priority_queue;
use sui::sui;
use sui::table;
use sui::table_vec;
use sui::transfer;
use sui::tx_context;
use sui::types;
use sui::url;
use sui::vec_map;
use sui::vec_set;
use sui::versioned;
use sui_system::stake_subsidy;
use sui_system::staking_pool;
use sui_system::storage_fund;
use sui_system::sui_system;
use sui_system::sui_system_state_inner;
use sui_system::validator;
use sui_system::validator_cap;
use sui_system::validator_set;
use sui_system::validator_wrapper;
use sui_system::voting_power;

Struct BlocklistValidatorEvent​

public struct BlocklistValidatorEvent has copy, drop
Click to open
Fields
blocklisted: bool
public_keys: vector<vector<u8>>

Struct BridgeCommittee​

public struct BridgeCommittee has store
Click to open
Fields
members: sui::vec_map::VecMap<vector<u8>, bridge::committee::CommitteeMember>
member_registrations: sui::vec_map::VecMap<address, bridge::committee::CommitteeMemberRegistration>
last_committee_update_epoch: u64

Struct CommitteeUpdateEvent​

public struct CommitteeUpdateEvent has copy, drop
Click to open
Fields
members: sui::vec_map::VecMap<vector<u8>, bridge::committee::CommitteeMember>
stake_participation_percentage: u64

Struct CommitteeMemberUrlUpdateEvent​

public struct CommitteeMemberUrlUpdateEvent has copy, drop
Click to open
Fields
member: vector<u8>
new_url: vector<u8>

Struct CommitteeMember​

public struct CommitteeMember has copy, drop, store
Click to open
Fields
sui_address: address
The Sui Address of the validator
bridge_pubkey_bytes: vector<u8>
The public key bytes of the bridge key
voting_power: u64
Voting power, values are voting power in the scale of 10000.
http_rest_url: vector<u8>
The HTTP REST URL the member's node listens to it looks like b'https://127.0.0.1:9191'
blocklisted: bool
If this member is blocklisted

Struct CommitteeMemberRegistration​

public struct CommitteeMemberRegistration has copy, drop, store
Click to open
Fields
sui_address: address
The Sui Address of the validator
bridge_pubkey_bytes: vector<u8>
The public key bytes of the bridge key
http_rest_url: vector<u8>
The HTTP REST URL the member's node listens to it looks like b'https://127.0.0.1:9191'

Constants​

const ESignatureBelowThreshold: u64 = 0;

const EDuplicatedSignature: u64 = 1;

const EInvalidSignature: u64 = 2;

const ENotSystemAddress: u64 = 3;

const EValidatorBlocklistContainsUnknownKey: u64 = 4;

const ESenderNotActiveValidator: u64 = 5;

const EInvalidPubkeyLength: u64 = 6;

const ECommitteeAlreadyInitiated: u64 = 7;

const EDuplicatePubkey: u64 = 8;

const ESenderIsNotInBridgeCommittee: u64 = 9;

const SUI_MESSAGE_PREFIX: vector<u8> = vector[83, 85, 73, 95, 66, 82, 73, 68, 71, 69, 95, 77, 69, 83, 83, 65, 71, 69];

const ECDSA_COMPRESSED_PUBKEY_LENGTH: u64 = 33;

Function verify_signatures​

public fun verify_signatures(self: &bridge::committee::BridgeCommittee, message: bridge::message::BridgeMessage, signatures: vector<vector<u8>>)
Click to open
Implementation
public fun verify_signatures(
    self: &BridgeCommittee,
    message: BridgeMessage,
    signatures: vector<vector<u8>>,
) {
    let (mut i, signature_counts) = (0, vector::length(&signatures));
    let mut seen_pub_key = vec_set::empty<vector<u8>>();
    let required_voting_power = message.required_voting_power();
    // add prefix to the message bytes
    let mut message_bytes = SUI_MESSAGE_PREFIX;
    message_bytes.append(message.serialize_message());
    let mut threshold = 0;
    while (i < signature_counts) {
        let pubkey = ecdsa_k1::secp256k1_ecrecover(&signatures[i], &message_bytes, 0);
        // check duplicate
        // and make sure pub key is part of the committee
        assert!(!seen_pub_key.contains(&pubkey), EDuplicatedSignature);
        assert!(self.members.contains(&pubkey), EInvalidSignature);
        // get committee signature weight and check pubkey is part of the committee
        let member = &self.members[&pubkey];
        if (!member.blocklisted) {
            threshold = threshold + member.voting_power;
        };
        seen_pub_key.insert(pubkey);
        i = i + 1;
    };
    assert!(threshold >= required_voting_power, ESignatureBelowThreshold);
}

Function create​

public(package) fun create(ctx: &sui::tx_context::TxContext): bridge::committee::BridgeCommittee
Click to open
Implementation
public(package) fun create(ctx: &TxContext): BridgeCommittee {
    assert!(tx_context::sender(ctx) == @0x0, ENotSystemAddress);
    BridgeCommittee {
        members: vec_map::empty(),
        member_registrations: vec_map::empty(),
        last_committee_update_epoch: 0,
    }
}

Function register​

public(package) fun register(self: &mut bridge::committee::BridgeCommittee, system_state: &mut sui_system::sui_system::SuiSystemState, bridge_pubkey_bytes: vector<u8>, http_rest_url: vector<u8>, ctx: &sui::tx_context::TxContext)
Click to open
Implementation
public(package) fun register(
    self: &mut BridgeCommittee,
    system_state: &mut SuiSystemState,
    bridge_pubkey_bytes: vector<u8>,
    http_rest_url: vector<u8>,
    ctx: &TxContext,
) {
    // We disallow registration after committee initiated in v1
    assert!(self.members.is_empty(), ECommitteeAlreadyInitiated);
    // Ensure pubkey is valid
    assert!(bridge_pubkey_bytes.length() == ECDSA_COMPRESSED_PUBKEY_LENGTH, EInvalidPubkeyLength);
    // sender must be the same sender that created the validator object, this is to prevent DDoS from non-validator actor.
    let sender = ctx.sender();
    let validators = system_state.active_validator_addresses();
    assert!(validators.contains(&sender), ESenderNotActiveValidator);
    // Sender is active validator, record the registration
    // In case validator need to update the info
    let registration = if (self.member_registrations.contains(&sender)) {
        let registration = &mut self.member_registrations[&sender];
        registration.http_rest_url = http_rest_url;
        registration.bridge_pubkey_bytes = bridge_pubkey_bytes;
        *registration
    } else {
        let registration = CommitteeMemberRegistration {
            sui_address: sender,
            bridge_pubkey_bytes,
            http_rest_url,
        };
        self.member_registrations.insert(sender, registration);
        registration
    };
    // check uniqueness of the bridge pubkey.
    // try_create_next_committee will abort if bridge_pubkey_bytes are not unique and
    // that will fail the end of epoch transaction (possibly "forever", well, we
    // need to deploy proper validator changes to stop end of epoch from failing).
    check_uniqueness_bridge_keys(self, bridge_pubkey_bytes);
    emit(registration)
}

Function try_create_next_committee​

public(package) fun try_create_next_committee(self: &mut bridge::committee::BridgeCommittee, active_validator_voting_power: sui::vec_map::VecMap<address, u64>, min_stake_participation_percentage: u64, ctx: &sui::tx_context::TxContext)
Click to open
Implementation
public(package) fun try_create_next_committee(
    self: &mut BridgeCommittee,
    active_validator_voting_power: VecMap<address, u64>,
    min_stake_participation_percentage: u64,
    ctx: &TxContext,
) {
    let mut i = 0;
    let mut new_members = vec_map::empty();
    let mut stake_participation_percentage = 0;
    while (i < self.member_registrations.length()) {
        // retrieve registration
        let (_, registration) = self.member_registrations.get_entry_by_idx(i);
        // Find validator stake amount from system state
        // Process registration if it's active validator
        let voting_power = active_validator_voting_power.try_get(®istration.sui_address);
        if (voting_power.is_some()) {
            let voting_power = voting_power.destroy_some();
            stake_participation_percentage = stake_participation_percentage + voting_power;
            let member = CommitteeMember {
                sui_address: registration.sui_address,
                bridge_pubkey_bytes: registration.bridge_pubkey_bytes,
                voting_power: (voting_power as u64),
                http_rest_url: registration.http_rest_url,
                blocklisted: false,
            };
            new_members.insert(registration.bridge_pubkey_bytes, member)
        };
        i = i + 1;
    };
    // Make sure the new committee represent enough stakes, percentage are accurate to 2DP
    if (stake_participation_percentage >= min_stake_participation_percentage) {
        // Clear registrations
        self.member_registrations = vec_map::empty();
        // Store new committee info
        self.members = new_members;
        self.last_committee_update_epoch = ctx.epoch();
        emit(CommitteeUpdateEvent {
            members: new_members,
            stake_participation_percentage,
        })
    }
}

Function execute_blocklist​

public(package) fun execute_blocklist(self: &mut bridge::committee::BridgeCommittee, blocklist: bridge::message::Blocklist)
Click to open
Implementation
public(package) fun execute_blocklist(self: &mut BridgeCommittee, blocklist: Blocklist) {
    let blocklisted = blocklist.blocklist_type() != 1;
    let eth_addresses = blocklist.blocklist_validator_addresses();
    let list_len = eth_addresses.length();
    let mut list_idx = 0;
    let mut member_idx = 0;
    let mut pub_keys = vector[];
    while (list_idx < list_len) {
        let target_address = ð_addresses[list_idx];
        let mut found = false;
        while (member_idx < self.members.length()) {
            let (pub_key, member) = self.members.get_entry_by_idx_mut(member_idx);
            let eth_address = crypto::ecdsa_pub_key_to_eth_address(pub_key);
            if (*target_address == eth_address) {
                member.blocklisted = blocklisted;
                pub_keys.push_back(*pub_key);
                found = true;
                member_idx = 0;
                break
            };
            member_idx = member_idx + 1;
        };
        assert!(found, EValidatorBlocklistContainsUnknownKey);
        list_idx = list_idx + 1;
    };
    emit(BlocklistValidatorEvent {
        blocklisted,
        public_keys: pub_keys,
    })
}

Function committee_members​

public(package) fun committee_members(self: &bridge::committee::BridgeCommittee): &sui::vec_map::VecMap<vector<u8>, bridge::committee::CommitteeMember>
Click to open
Implementation
public(package) fun committee_members(
    self: &BridgeCommittee,
): &VecMap<vector<u8>, CommitteeMember> {
    &self.members
}

Function update_node_url​

public(package) fun update_node_url(self: &mut bridge::committee::BridgeCommittee, new_url: vector<u8>, ctx: &sui::tx_context::TxContext)
Click to open
Implementation
public(package) fun update_node_url(
    self: &mut BridgeCommittee,
    new_url: vector<u8>,
    ctx: &TxContext,
) {
    let mut idx = 0;
    while (idx < self.members.length()) {
        let (_, member) = self.members.get_entry_by_idx_mut(idx);
        if (member.sui_address == ctx.sender()) {
            member.http_rest_url = new_url;
            emit(CommitteeMemberUrlUpdateEvent {
                member: member.bridge_pubkey_bytes,
                new_url,
            });
            return
        };
        idx = idx + 1;
    };
    abort ESenderIsNotInBridgeCommittee
}

Function check_uniqueness_bridge_keys​

fun check_uniqueness_bridge_keys(self: &bridge::committee::BridgeCommittee, bridge_pubkey_bytes: vector<u8>)
Click to open
Implementation
fun check_uniqueness_bridge_keys(self: &BridgeCommittee, bridge_pubkey_bytes: vector<u8>) {
    let mut count = self.member_registrations.length();
    // bridge_pubkey_bytes must be found once and once only
    let mut bridge_key_found = false;
    while (count > 0) {
        count = count - 1;
        let (_, registration) = self.member_registrations.get_entry_by_idx(count);
        if (registration.bridge_pubkey_bytes == bridge_pubkey_bytes) {
            assert!(!bridge_key_found, EDuplicatePubkey);
            bridge_key_found = true; // bridge_pubkey_bytes found, we must not have another one
        }
    };
}