axelar-cgp-sui

Module axelar_gateway::weighted_signers

• Struct WeightedSigners
• Constants
• Function peel
• Function validate
• Function hash
• Function signers
• Function threshold
• Function nonce
• Function validate_signers
• Function total_weight
• Function validate_threshold

use axelar_gateway::bytes32;
use axelar_gateway::weighted_signer;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;
use sui::address;
use sui::bcs;
use sui::hash;
use sui::hex;

Struct WeightedSigners

public struct WeightedSigners has copy, drop, store

Fields

signers: vector<axelar_gateway::weighted_signer::WeightedSigner>

threshold: u128

nonce: axelar_gateway::bytes32::Bytes32

Constants

---

Errors ——

#[error]
const EInvalidSignersLength: vector<u8> = b"invalid signers length: expected at least 1 signer";

#[error]
const EInvalidThreshold: vector<u8> = b"invalid threshold: expected non-zero value and less than or equal to the total weight of the signers";

#[error]
const EInvalidSignerOrder: vector<u8> = b"invalid signer order: signers must be in ascending order by their public key";

Function peel

---

Package Functions —————– Decode a WeightedSigners from the BCS encoded bytes.

public(package) fun peel(bcs: &mut sui::bcs::BCS): axelar_gateway::weighted_signers::WeightedSigners

Implementation

public(package) fun peel(bcs: &mut BCS): WeightedSigners {
    let len = bcs.peel_vec_length();
    assert!(len > 0, EInvalidSignersLength);
    WeightedSigners {
        signers: vector::tabulate!(len, |_| weighted_signer::peel(bcs)),
        threshold: bcs.peel_u128(),
        nonce: bytes32::peel(bcs),
    }
}

Function validate

Validates the weighted signers. The following must be true:

1. The signers are in ascending order by their public key.
2. The threshold is greater than zero.
3. The threshold is less than or equal to the total weight of the signers.

public(package) fun validate(self: &axelar_gateway::weighted_signers::WeightedSigners)

Implementation

public(package) fun validate(self: &WeightedSigners) {
    self.validate_signers();
    self.validate_threshold();
}

Function hash

public(package) fun hash(self: &axelar_gateway::weighted_signers::WeightedSigners): axelar_gateway::bytes32::Bytes32

Implementation

public(package) fun hash(self: &WeightedSigners): Bytes32 {
    bytes32::from_bytes(hash::keccak256(&bcs::to_bytes(self)))
}

Function signers

public(package) fun signers(self: &axelar_gateway::weighted_signers::WeightedSigners): &vector<axelar_gateway::weighted_signer::WeightedSigner>

Implementation

public(package) fun signers(self: &WeightedSigners): &vector<WeightedSigner> {
    &self.signers
}

Function threshold

public(package) fun threshold(self: &axelar_gateway::weighted_signers::WeightedSigners): u128

Implementation

public(package) fun threshold(self: &WeightedSigners): u128 {
    self.threshold
}

Function nonce

public(package) fun nonce(self: &axelar_gateway::weighted_signers::WeightedSigners): axelar_gateway::bytes32::Bytes32

Implementation

public(package) fun nonce(self: &WeightedSigners): Bytes32 {
    self.nonce
}

Function validate_signers

---

Internal Functions —– Validates the order of the signers and the length of the signers. The signers must be in ascending order by their public key. Otherwise, the error EInvalidSignersLength is raised.

fun validate_signers(self: &axelar_gateway::weighted_signers::WeightedSigners)

Implementation

fun validate_signers(self: &WeightedSigners) {
    assert!(!self.signers.is_empty(), EInvalidSignersLength);
    let mut previous = &weighted_signer::default();
    self.signers.do_ref!(|signer| {
        signer.validate();
        assert!(previous.lt(signer), EInvalidSignerOrder);
        previous = signer;
    });
}

Function total_weight

Calculates the total weight of the signers.

fun total_weight(self: &axelar_gateway::weighted_signers::WeightedSigners): u128

Implementation

fun total_weight(self: &WeightedSigners): u128 {
    self.signers.fold!<WeightedSigner, u128>(0, |acc, signer| acc + signer.weight())
}

Function validate_threshold

Validates the threshold. The threshold must be greater than zero and less than or equal to the total weight of the signers. Otherwise, the error EInvalidThreshold is raised.

fun validate_threshold(self: &axelar_gateway::weighted_signers::WeightedSigners)

Implementation

fun validate_threshold(self: &WeightedSigners) {
    assert!(self.threshold != 0 && self.total_weight() >= self.threshold, EInvalidThreshold);
}