Package

// Move bytecode v6
module b.bridge {
use 000000000000000000000000000000000000000000000000000000000000000b::chain_ids;
use 000000000000000000000000000000000000000000000000000000000000000b::committee;
use 000000000000000000000000000000000000000000000000000000000000000b::limiter;
use 000000000000000000000000000000000000000000000000000000000000000b::message;
use 000000000000000000000000000000000000000000000000000000000000000b::message_types;
use 000000000000000000000000000000000000000000000000000000000000000b::treasury;
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::linked_table;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::versioned;
use 0000000000000000000000000000000000000000000000000000000000000003::safe_system;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Bridge has key {
	id: UID,
	inner: Versioned
}

struct BridgeInner has store {
	bridge_version: u64,
	message_version: u8,
	chain_id: u8,
	sequence_nums: VecMap<u8, u64>,
	committee: BridgeCommittee,
	treasury: BridgeTreasury,
	token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>,
	limiter: TransferLimiter,
	paused: bool
}

struct TokenDepositedEvent has copy, drop {
	seq_num: u64,
	source_chain: u8,
	sender_address: vector<u8>,
	target_chain: u8,
	target_address: vector<u8>,
	token_type: u8,
	amount: u64
}

struct EmergencyOpEvent has copy, drop {
	frozen: bool
}

struct BridgeRecord has drop, store {
	message: BridgeMessage,
	verified_signatures: Option<vector<vector<u8>>>,
	claimed: bool
}

struct TokenTransferApproved has copy, drop {
	message_key: BridgeMessageKey
}

struct TokenTransferClaimed has copy, drop {
	message_key: BridgeMessageKey
}

struct TokenTransferAlreadyApproved has copy, drop {
	message_key: BridgeMessageKey
}

struct TokenTransferAlreadyClaimed has copy, drop {
	message_key: BridgeMessageKey
}

struct TokenTransferLimitExceed has copy, drop {
	message_key: BridgeMessageKey
}

create(Arg0: UID, Arg1: u8, Arg2: &mut TxContext) {
L3:	loc0: BridgeInner
B0:
	0: CopyLoc[2](Arg2: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: LdConst[25](address: 0x00..)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[2](Arg2: &mut TxContext)
	8: Pop
	9: LdConst[10](u64: 5)
	10: Abort
B3:
	11: LdConst[6](u64: 1)
	12: LdConst[0](u8: 1)
	13: MoveLoc[1](Arg1: u8)
	14: Call vec_map::empty<u8, u64>(): VecMap<u8, u64>
	15: CopyLoc[2](Arg2: &mut TxContext)
	16: FreezeRef
	17: Call committee::create(&TxContext): BridgeCommittee
	18: CopyLoc[2](Arg2: &mut TxContext)
	19: Call treasury::create(&mut TxContext): BridgeTreasury
	20: CopyLoc[2](Arg2: &mut TxContext)
	21: Call linked_table::new<BridgeMessageKey, BridgeRecord>(&mut TxContext): LinkedTable<BridgeMessageKey, BridgeRecord>
	22: Call limiter::new(): TransferLimiter
	23: LdFalse
	24: Pack[1](BridgeInner)
	25: StLoc[3](loc0: BridgeInner)
	26: MoveLoc[0](Arg0: UID)
	27: LdConst[6](u64: 1)
	28: MoveLoc[3](loc0: BridgeInner)
	29: MoveLoc[2](Arg2: &mut TxContext)
	30: Call versioned::create<BridgeInner>(u64, BridgeInner, &mut TxContext): Versioned
	31: Pack[0](Bridge)
	32: Call transfer::share_object<Bridge>(Bridge)
	33: Ret
}

init_bridge_committee(Arg0: &mut Bridge, Arg1: VecMap<address, u64>, Arg2: u64, Arg3: &TxContext) {
L4:	loc0: &mut BridgeInner
B0:
	0: CopyLoc[3](Arg3: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[25](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[3](Arg3: &TxContext)
	7: Pop
	8: MoveLoc[0](Arg0: &mut Bridge)
	9: Pop
	10: LdConst[10](u64: 5)
	11: Abort
B3:
	12: MoveLoc[0](Arg0: &mut Bridge)
	13: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	14: StLoc[4](loc0: &mut BridgeInner)
	15: CopyLoc[4](loc0: &mut BridgeInner)
	16: ImmBorrowField[0](BridgeInner.committee: BridgeCommittee)
	17: Call committee::committee_members(&BridgeCommittee): &VecMap<vector<u8>, CommitteeMember>
	18: Call vec_map::is_empty<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>): bool
	19: BrFalse(27)
B4:
	20: MoveLoc[4](loc0: &mut BridgeInner)
	21: MutBorrowField[0](BridgeInner.committee: BridgeCommittee)
	22: MoveLoc[1](Arg1: VecMap<address, u64>)
	23: MoveLoc[2](Arg2: u64)
	24: MoveLoc[3](Arg3: &TxContext)
	25: Call committee::try_create_next_committee(&mut BridgeCommittee, VecMap<address, u64>, u64, &TxContext)
	26: Branch(31)
B5:
	27: MoveLoc[4](loc0: &mut BridgeInner)
	28: Pop
	29: MoveLoc[3](Arg3: &TxContext)
	30: Pop
B6:
	31: Ret
}

public committee_registration(Arg0: &mut Bridge, Arg1: &mut SafeSystemState, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: MutBorrowField[0](BridgeInner.committee: BridgeCommittee)
	3: MoveLoc[1](Arg1: &mut SafeSystemState)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: MoveLoc[3](Arg3: vector<u8>)
	6: MoveLoc[4](Arg4: &TxContext)
	7: Call committee::register(&mut BridgeCommittee, &mut SafeSystemState, vector<u8>, vector<u8>, &TxContext)
	8: Ret
}

public update_node_url(Arg0: &mut Bridge, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: MutBorrowField[0](BridgeInner.committee: BridgeCommittee)
	3: MoveLoc[1](Arg1: vector<u8>)
	4: MoveLoc[2](Arg2: &TxContext)
	5: Call committee::update_node_url(&mut BridgeCommittee, vector<u8>, &TxContext)
	6: Ret
}

public register_foreign_token<Ty0>(Arg0: &mut Bridge, Arg1: TreasuryCap<Ty0>, Arg2: UpgradeCap, Arg3: &CoinMetadata<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: MutBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	3: MoveLoc[1](Arg1: TreasuryCap<Ty0>)
	4: MoveLoc[2](Arg2: UpgradeCap)
	5: MoveLoc[3](Arg3: &CoinMetadata<Ty0>)
	6: Call treasury::register_foreign_token<Ty0>(&mut BridgeTreasury, TreasuryCap<Ty0>, UpgradeCap, &CoinMetadata<Ty0>)
	7: Ret
}

public send_token<Ty0>(Arg0: &mut Bridge, Arg1: u8, Arg2: vector<u8>, Arg3: Coin<Ty0>, Arg4: &mut TxContext) {
L5:	loc0: u64
L6:	loc1: &mut BridgeInner
L7:	loc2: BridgeMessage
L8:	loc3: u64
L9:	loc4: u8
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: StLoc[6](loc1: &mut BridgeInner)
	3: CopyLoc[6](loc1: &mut BridgeInner)
	4: ImmBorrowField[2](BridgeInner.paused: bool)
	5: ReadRef
	6: Not
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[6](loc1: &mut BridgeInner)
	10: Pop
	11: MoveLoc[4](Arg4: &mut TxContext)
	12: Pop
	13: LdConst[13](u64: 8)
	14: Abort
B3:
	15: CopyLoc[6](loc1: &mut BridgeInner)
	16: ImmBorrowField[3](BridgeInner.chain_id: u8)
	17: ReadRef
	18: CopyLoc[1](Arg1: u8)
	19: Call chain_ids::is_valid_route(u8, u8): bool
	20: BrFalse(22)
B4:
	21: Branch(28)
B5:
	22: MoveLoc[6](loc1: &mut BridgeInner)
	23: Pop
	24: MoveLoc[4](Arg4: &mut TxContext)
	25: Pop
	26: LdConst[21](u64: 16)
	27: Abort
B6:
	28: ImmBorrowLoc[2](Arg2: vector<u8>)
	29: VecLen(11)
	30: LdConst[4](u64: 20)
	31: Eq
	32: BrFalse(34)
B7:
	33: Branch(40)
B8:
	34: MoveLoc[6](loc1: &mut BridgeInner)
	35: Pop
	36: MoveLoc[4](Arg4: &mut TxContext)
	37: Pop
	38: LdConst[23](u64: 18)
	39: Abort
B9:
	40: CopyLoc[6](loc1: &mut BridgeInner)
	41: Call message_types::token(): u8
	42: Call get_current_seq_num_and_increment(&mut BridgeInner, u8): u64
	43: StLoc[5](loc0: u64)
	44: CopyLoc[6](loc1: &mut BridgeInner)
	45: ImmBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	46: Call treasury::token_id<Ty0>(&BridgeTreasury): u8
	47: StLoc[9](loc4: u8)
	48: ImmBorrowLoc[3](Arg3: Coin<Ty0>)
	49: Call coin::balance<Ty0>(&Coin<Ty0>): &Balance<Ty0>
	50: Call balance::value<Ty0>(&Balance<Ty0>): u64
	51: StLoc[8](loc3: u64)
	52: CopyLoc[8](loc3: u64)
	53: LdU64(0)
	54: Gt
	55: BrFalse(57)
B10:
	56: Branch(63)
B11:
	57: MoveLoc[6](loc1: &mut BridgeInner)
	58: Pop
	59: MoveLoc[4](Arg4: &mut TxContext)
	60: Pop
	61: LdConst[24](u64: 19)
	62: Abort
B12:
	63: CopyLoc[6](loc1: &mut BridgeInner)
	64: ImmBorrowField[3](BridgeInner.chain_id: u8)
	65: ReadRef
	66: CopyLoc[5](loc0: u64)
	67: CopyLoc[4](Arg4: &mut TxContext)
	68: FreezeRef
	69: Call tx_context::sender(&TxContext): address
	70: Call address::to_bytes(address): vector<u8>
	71: CopyLoc[1](Arg1: u8)
	72: CopyLoc[2](Arg2: vector<u8>)
	73: CopyLoc[9](loc4: u8)
	74: CopyLoc[8](loc3: u64)
	75: Call message::create_token_bridge_message(u8, u64, vector<u8>, u8, vector<u8>, u8, u64): BridgeMessage
	76: StLoc[7](loc2: BridgeMessage)
	77: CopyLoc[6](loc1: &mut BridgeInner)
	78: MutBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	79: MoveLoc[3](Arg3: Coin<Ty0>)
	80: Call treasury::burn<Ty0>(&mut BridgeTreasury, Coin<Ty0>)
	81: CopyLoc[6](loc1: &mut BridgeInner)
	82: MutBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	83: ImmBorrowLoc[7](loc2: BridgeMessage)
	84: Call message::key(&BridgeMessage): BridgeMessageKey
	85: MoveLoc[7](loc2: BridgeMessage)
	86: Call option::none<vector<vector<u8>>>(): Option<vector<vector<u8>>>
	87: LdFalse
	88: Pack[4](BridgeRecord)
	89: Call linked_table::push_back<BridgeMessageKey, BridgeRecord>(&mut LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey, BridgeRecord)
	90: MoveLoc[5](loc0: u64)
	91: MoveLoc[6](loc1: &mut BridgeInner)
	92: ImmBorrowField[3](BridgeInner.chain_id: u8)
	93: ReadRef
	94: MoveLoc[4](Arg4: &mut TxContext)
	95: FreezeRef
	96: Call tx_context::sender(&TxContext): address
	97: Call address::to_bytes(address): vector<u8>
	98: MoveLoc[1](Arg1: u8)
	99: MoveLoc[2](Arg2: vector<u8>)
	100: MoveLoc[9](loc4: u8)
	101: MoveLoc[8](loc3: u64)
	102: Pack[2](TokenDepositedEvent)
	103: Call event::emit<TokenDepositedEvent>(TokenDepositedEvent)
	104: Ret
}

public approve_token_transfer(Arg0: &mut Bridge, Arg1: BridgeMessage, Arg2: vector<vector<u8>>) {
L3:	loc0: bool
L4:	loc1: &mut BridgeInner
L5:	loc2: BridgeMessageKey
L6:	loc3: &mut BridgeRecord
L7:	loc4: u8
L8:	loc5: TokenTransferPayload
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: StLoc[4](loc1: &mut BridgeInner)
	3: CopyLoc[4](loc1: &mut BridgeInner)
	4: ImmBorrowField[2](BridgeInner.paused: bool)
	5: ReadRef
	6: Not
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[4](loc1: &mut BridgeInner)
	10: Pop
	11: LdConst[13](u64: 8)
	12: Abort
B3:
	13: CopyLoc[4](loc1: &mut BridgeInner)
	14: ImmBorrowField[0](BridgeInner.committee: BridgeCommittee)
	15: CopyLoc[1](Arg1: BridgeMessage)
	16: CopyLoc[2](Arg2: vector<vector<u8>>)
	17: Call committee::verify_signatures(&BridgeCommittee, BridgeMessage, vector<vector<u8>>)
	18: ImmBorrowLoc[1](Arg1: BridgeMessage)
	19: Call message::message_type(&BridgeMessage): u8
	20: Call message_types::token(): u8
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[4](loc1: &mut BridgeInner)
	25: Pop
	26: LdConst[22](u64: 17)
	27: Abort
B6:
	28: ImmBorrowLoc[1](Arg1: BridgeMessage)
	29: Call message::message_version(&BridgeMessage): u8
	30: LdConst[0](u8: 1)
	31: Eq
	32: BrFalse(34)
B7:
	33: Branch(38)
B8:
	34: MoveLoc[4](loc1: &mut BridgeInner)
	35: Pop
	36: LdConst[17](u64: 12)
	37: Abort
B9:
	38: ImmBorrowLoc[1](Arg1: BridgeMessage)
	39: Call message::extract_token_bridge_payload(&BridgeMessage): TokenTransferPayload
	40: StLoc[8](loc5: TokenTransferPayload)
	41: ImmBorrowLoc[8](loc5: TokenTransferPayload)
	42: Call message::token_target_chain(&TokenTransferPayload): u8
	43: StLoc[7](loc4: u8)
	44: ImmBorrowLoc[1](Arg1: BridgeMessage)
	45: Call message::source_chain(&BridgeMessage): u8
	46: CopyLoc[4](loc1: &mut BridgeInner)
	47: ImmBorrowField[3](BridgeInner.chain_id: u8)
	48: ReadRef
	49: Eq
	50: BrFalse(54)
B10:
	51: LdTrue
	52: StLoc[3](loc0: bool)
	53: Branch(60)
B11:
	54: MoveLoc[7](loc4: u8)
	55: CopyLoc[4](loc1: &mut BridgeInner)
	56: ImmBorrowField[3](BridgeInner.chain_id: u8)
	57: ReadRef
	58: Eq
	59: StLoc[3](loc0: bool)
B12:
	60: MoveLoc[3](loc0: bool)
	61: BrFalse(63)
B13:
	62: Branch(67)
B14:
	63: MoveLoc[4](loc1: &mut BridgeInner)
	64: Pop
	65: LdConst[9](u64: 4)
	66: Abort
B15:
	67: ImmBorrowLoc[1](Arg1: BridgeMessage)
	68: Call message::key(&BridgeMessage): BridgeMessageKey
	69: StLoc[5](loc2: BridgeMessageKey)
	70: ImmBorrowLoc[1](Arg1: BridgeMessage)
	71: Call message::source_chain(&BridgeMessage): u8
	72: CopyLoc[4](loc1: &mut BridgeInner)
	73: ImmBorrowField[3](BridgeInner.chain_id: u8)
	74: ReadRef
	75: Eq
	76: BrFalse(119)
B16:
	77: MoveLoc[4](loc1: &mut BridgeInner)
	78: MutBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	79: CopyLoc[5](loc2: BridgeMessageKey)
	80: Call linked_table::borrow_mut<BridgeMessageKey, BridgeRecord>(&mut LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): &mut BridgeRecord
	81: StLoc[6](loc3: &mut BridgeRecord)
	82: CopyLoc[6](loc3: &mut BridgeRecord)
	83: ImmBorrowField[5](BridgeRecord.message: BridgeMessage)
	84: ReadRef
	85: MoveLoc[1](Arg1: BridgeMessage)
	86: Eq
	87: BrFalse(89)
B17:
	88: Branch(93)
B18:
	89: MoveLoc[6](loc3: &mut BridgeRecord)
	90: Pop
	91: LdConst[7](u64: 2)
	92: Abort
B19:
	93: CopyLoc[6](loc3: &mut BridgeRecord)
	94: ImmBorrowField[6](BridgeRecord.claimed: bool)
	95: ReadRef
	96: Not
	97: BrFalse(99)
B20:
	98: Branch(103)
B21:
	99: MoveLoc[6](loc3: &mut BridgeRecord)
	100: Pop
	101: LdConst[15](u64: 10)
	102: Abort
B22:
	103: CopyLoc[6](loc3: &mut BridgeRecord)
	104: ImmBorrowField[7](BridgeRecord.verified_signatures: Option<vector<vector<u8>>>)
	105: Call option::is_some<vector<vector<u8>>>(&Option<vector<vector<u8>>>): bool
	106: BrFalse(113)
B23:
	107: MoveLoc[6](loc3: &mut BridgeRecord)
	108: Pop
	109: MoveLoc[5](loc2: BridgeMessageKey)
	110: Pack[7](TokenTransferAlreadyApproved)
	111: Call event::emit<TokenTransferAlreadyApproved>(TokenTransferAlreadyApproved)
	112: Ret
B24:
	113: MoveLoc[2](Arg2: vector<vector<u8>>)
	114: Call option::some<vector<vector<u8>>>(vector<vector<u8>>): Option<vector<vector<u8>>>
	115: MoveLoc[6](loc3: &mut BridgeRecord)
	116: MutBorrowField[7](BridgeRecord.verified_signatures: Option<vector<vector<u8>>>)
	117: WriteRef
	118: Branch(139)
B25:
	119: CopyLoc[4](loc1: &mut BridgeInner)
	120: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	121: CopyLoc[5](loc2: BridgeMessageKey)
	122: Call linked_table::contains<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): bool
	123: BrFalse(130)
B26:
	124: MoveLoc[4](loc1: &mut BridgeInner)
	125: Pop
	126: MoveLoc[5](loc2: BridgeMessageKey)
	127: Pack[7](TokenTransferAlreadyApproved)
	128: Call event::emit<TokenTransferAlreadyApproved>(TokenTransferAlreadyApproved)
	129: Ret
B27:
	130: MoveLoc[4](loc1: &mut BridgeInner)
	131: MutBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	132: CopyLoc[5](loc2: BridgeMessageKey)
	133: MoveLoc[1](Arg1: BridgeMessage)
	134: MoveLoc[2](Arg2: vector<vector<u8>>)
	135: Call option::some<vector<vector<u8>>>(vector<vector<u8>>): Option<vector<vector<u8>>>
	136: LdFalse
	137: Pack[4](BridgeRecord)
	138: Call linked_table::push_back<BridgeMessageKey, BridgeRecord>(&mut LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey, BridgeRecord)
B28:
	139: MoveLoc[5](loc2: BridgeMessageKey)
	140: Pack[5](TokenTransferApproved)
	141: Call event::emit<TokenTransferApproved>(TokenTransferApproved)
	142: Ret
}

public claim_token<Ty0>(Arg0: &mut Bridge, Arg1: &Clock, Arg2: u8, Arg3: u64, Arg4: &mut TxContext): Coin<Ty0> {
L5:	loc0: Option<Coin<Ty0>>
L6:	loc1: address
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: MoveLoc[1](Arg1: &Clock)
	2: MoveLoc[2](Arg2: u8)
	3: MoveLoc[3](Arg3: u64)
	4: CopyLoc[4](Arg4: &mut TxContext)
	5: Call claim_token_internal<Ty0>(&mut Bridge, &Clock, u8, u64, &mut TxContext): Option<Coin<Ty0>> * address
	6: StLoc[6](loc1: address)
	7: StLoc[5](loc0: Option<Coin<Ty0>>)
	8: MoveLoc[4](Arg4: &mut TxContext)
	9: FreezeRef
	10: Call tx_context::sender(&TxContext): address
	11: MoveLoc[6](loc1: address)
	12: Eq
	13: BrFalse(15)
B1:
	14: Branch(17)
B2:
	15: LdConst[6](u64: 1)
	16: Abort
B3:
	17: ImmBorrowLoc[5](loc0: Option<Coin<Ty0>>)
	18: Call option::is_some<Coin<Ty0>>(&Option<Coin<Ty0>>): bool
	19: BrFalse(21)
B4:
	20: Branch(23)
B5:
	21: LdConst[20](u64: 15)
	22: Abort
B6:
	23: MoveLoc[5](loc0: Option<Coin<Ty0>>)
	24: Call option::destroy_some<Coin<Ty0>>(Option<Coin<Ty0>>): Coin<Ty0>
	25: Ret
}

public claim_and_transfer_token<Ty0>(Arg0: &mut Bridge, Arg1: &Clock, Arg2: u8, Arg3: u64, Arg4: &mut TxContext) {
L5:	loc0: address
L6:	loc1: Option<Coin<Ty0>>
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: MoveLoc[1](Arg1: &Clock)
	2: MoveLoc[2](Arg2: u8)
	3: MoveLoc[3](Arg3: u64)
	4: MoveLoc[4](Arg4: &mut TxContext)
	5: Call claim_token_internal<Ty0>(&mut Bridge, &Clock, u8, u64, &mut TxContext): Option<Coin<Ty0>> * address
	6: StLoc[5](loc0: address)
	7: StLoc[6](loc1: Option<Coin<Ty0>>)
	8: ImmBorrowLoc[6](loc1: Option<Coin<Ty0>>)
	9: Call option::is_some<Coin<Ty0>>(&Option<Coin<Ty0>>): bool
	10: BrFalse(16)
B1:
	11: MoveLoc[6](loc1: Option<Coin<Ty0>>)
	12: Call option::destroy_some<Coin<Ty0>>(Option<Coin<Ty0>>): Coin<Ty0>
	13: MoveLoc[5](loc0: address)
	14: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	15: Branch(18)
B2:
	16: MoveLoc[6](loc1: Option<Coin<Ty0>>)
	17: Call option::destroy_none<Coin<Ty0>>(Option<Coin<Ty0>>)
B3:
	18: Ret
}

public execute_system_message(Arg0: &mut Bridge, Arg1: BridgeMessage, Arg2: vector<vector<u8>>) {
L3:	loc0: u64
L4:	loc1: &mut BridgeInner
L5:	loc2: u8
L6:	loc3: EmergencyOp
L7:	loc4: Blocklist
L8:	loc5: UpdateBridgeLimit
L9:	loc6: UpdateAssetPrice
L10:	loc7: AddTokenOnSafe
B0:
	0: ImmBorrowLoc[1](Arg1: BridgeMessage)
	1: Call message::message_type(&BridgeMessage): u8
	2: StLoc[5](loc2: u8)
	3: ImmBorrowLoc[1](Arg1: BridgeMessage)
	4: Call message::message_version(&BridgeMessage): u8
	5: LdConst[0](u8: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut Bridge)
	10: Pop
	11: LdConst[17](u64: 12)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut Bridge)
	14: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	15: StLoc[4](loc1: &mut BridgeInner)
	16: ImmBorrowLoc[1](Arg1: BridgeMessage)
	17: Call message::source_chain(&BridgeMessage): u8
	18: CopyLoc[4](loc1: &mut BridgeInner)
	19: ImmBorrowField[3](BridgeInner.chain_id: u8)
	20: ReadRef
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[4](loc1: &mut BridgeInner)
	25: Pop
	26: LdConst[9](u64: 4)
	27: Abort
B6:
	28: CopyLoc[4](loc1: &mut BridgeInner)
	29: CopyLoc[5](loc2: u8)
	30: Call get_current_seq_num_and_increment(&mut BridgeInner, u8): u64
	31: StLoc[3](loc0: u64)
	32: ImmBorrowLoc[1](Arg1: BridgeMessage)
	33: Call message::seq_num(&BridgeMessage): u64
	34: MoveLoc[3](loc0: u64)
	35: Eq
	36: BrFalse(38)
B7:
	37: Branch(42)
B8:
	38: MoveLoc[4](loc1: &mut BridgeInner)
	39: Pop
	40: LdConst[11](u64: 6)
	41: Abort
B9:
	42: CopyLoc[4](loc1: &mut BridgeInner)
	43: ImmBorrowField[0](BridgeInner.committee: BridgeCommittee)
	44: CopyLoc[1](Arg1: BridgeMessage)
	45: MoveLoc[2](Arg2: vector<vector<u8>>)
	46: Call committee::verify_signatures(&BridgeCommittee, BridgeMessage, vector<vector<u8>>)
	47: CopyLoc[5](loc2: u8)
	48: Call message_types::emergency_op(): u8
	49: Eq
	50: BrFalse(58)
B10:
	51: ImmBorrowLoc[1](Arg1: BridgeMessage)
	52: Call message::extract_emergency_op_payload(&BridgeMessage): EmergencyOp
	53: StLoc[6](loc3: EmergencyOp)
	54: MoveLoc[4](loc1: &mut BridgeInner)
	55: MoveLoc[6](loc3: EmergencyOp)
	56: Call execute_emergency_op(&mut BridgeInner, EmergencyOp)
	57: Branch(107)
B11:
	58: CopyLoc[5](loc2: u8)
	59: Call message_types::committee_blocklist(): u8
	60: Eq
	61: BrFalse(70)
B12:
	62: ImmBorrowLoc[1](Arg1: BridgeMessage)
	63: Call message::extract_blocklist_payload(&BridgeMessage): Blocklist
	64: StLoc[7](loc4: Blocklist)
	65: MoveLoc[4](loc1: &mut BridgeInner)
	66: MutBorrowField[0](BridgeInner.committee: BridgeCommittee)
	67: MoveLoc[7](loc4: Blocklist)
	68: Call committee::execute_blocklist(&mut BridgeCommittee, Blocklist)
	69: Branch(107)
B13:
	70: CopyLoc[5](loc2: u8)
	71: Call message_types::update_bridge_limit(): u8
	72: Eq
	73: BrFalse(81)
B14:
	74: ImmBorrowLoc[1](Arg1: BridgeMessage)
	75: Call message::extract_update_bridge_limit(&BridgeMessage): UpdateBridgeLimit
	76: StLoc[8](loc5: UpdateBridgeLimit)
	77: MoveLoc[4](loc1: &mut BridgeInner)
	78: MoveLoc[8](loc5: UpdateBridgeLimit)
	79: Call execute_update_bridge_limit(&mut BridgeInner, UpdateBridgeLimit)
	80: Branch(107)
B15:
	81: CopyLoc[5](loc2: u8)
	82: Call message_types::update_asset_price(): u8
	83: Eq
	84: BrFalse(92)
B16:
	85: ImmBorrowLoc[1](Arg1: BridgeMessage)
	86: Call message::extract_update_asset_price(&BridgeMessage): UpdateAssetPrice
	87: StLoc[9](loc6: UpdateAssetPrice)
	88: MoveLoc[4](loc1: &mut BridgeInner)
	89: MoveLoc[9](loc6: UpdateAssetPrice)
	90: Call execute_update_asset_price(&mut BridgeInner, UpdateAssetPrice)
	91: Branch(107)
B17:
	92: MoveLoc[5](loc2: u8)
	93: Call message_types::add_tokens_on_safe(): u8
	94: Eq
	95: BrFalse(103)
B18:
	96: ImmBorrowLoc[1](Arg1: BridgeMessage)
	97: Call message::extract_add_tokens_on_safe(&BridgeMessage): AddTokenOnSafe
	98: StLoc[10](loc7: AddTokenOnSafe)
	99: MoveLoc[4](loc1: &mut BridgeInner)
	100: MoveLoc[10](loc7: AddTokenOnSafe)
	101: Call execute_add_tokens_on_safe(&mut BridgeInner, AddTokenOnSafe)
	102: Branch(107)
B19:
	103: MoveLoc[4](loc1: &mut BridgeInner)
	104: Pop
	105: LdConst[5](u64: 0)
	106: Abort
B20:
	107: Ret
}

get_token_transfer_action_status(Arg0: &Bridge, Arg1: u8, Arg2: u64): u8 {
L3:	loc0: &BridgeInner
L4:	loc1: BridgeMessageKey
L5:	loc2: &BridgeRecord
B0:
	0: MoveLoc[0](Arg0: &Bridge)
	1: Call load_inner(&Bridge): &BridgeInner
	2: StLoc[3](loc0: &BridgeInner)
	3: MoveLoc[1](Arg1: u8)
	4: Call message_types::token(): u8
	5: MoveLoc[2](Arg2: u64)
	6: Call message::create_key(u8, u8, u64): BridgeMessageKey
	7: StLoc[4](loc1: BridgeMessageKey)
	8: CopyLoc[3](loc0: &BridgeInner)
	9: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	10: CopyLoc[4](loc1: BridgeMessageKey)
	11: Call linked_table::contains<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): bool
	12: Not
	13: BrFalse(18)
B1:
	14: MoveLoc[3](loc0: &BridgeInner)
	15: Pop
	16: LdConst[3](u8: 3)
	17: Ret
B2:
	18: MoveLoc[3](loc0: &BridgeInner)
	19: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	20: MoveLoc[4](loc1: BridgeMessageKey)
	21: Call linked_table::borrow<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): &BridgeRecord
	22: StLoc[5](loc2: &BridgeRecord)
	23: CopyLoc[5](loc2: &BridgeRecord)
	24: ImmBorrowField[6](BridgeRecord.claimed: bool)
	25: ReadRef
	26: BrFalse(31)
B3:
	27: MoveLoc[5](loc2: &BridgeRecord)
	28: Pop
	29: LdConst[2](u8: 2)
	30: Ret
B4:
	31: MoveLoc[5](loc2: &BridgeRecord)
	32: ImmBorrowField[7](BridgeRecord.verified_signatures: Option<vector<vector<u8>>>)
	33: Call option::is_some<vector<vector<u8>>>(&Option<vector<vector<u8>>>): bool
	34: BrFalse(37)
B5:
	35: LdConst[0](u8: 1)
	36: Ret
B6:
	37: LdConst[1](u8: 0)
	38: Ret
}

get_token_transfer_action_signatures(Arg0: &Bridge, Arg1: u8, Arg2: u64): Option<vector<vector<u8>>> {
L3:	loc0: &BridgeInner
L4:	loc1: BridgeMessageKey
B0:
	0: MoveLoc[0](Arg0: &Bridge)
	1: Call load_inner(&Bridge): &BridgeInner
	2: StLoc[3](loc0: &BridgeInner)
	3: MoveLoc[1](Arg1: u8)
	4: Call message_types::token(): u8
	5: MoveLoc[2](Arg2: u64)
	6: Call message::create_key(u8, u8, u64): BridgeMessageKey
	7: StLoc[4](loc1: BridgeMessageKey)
	8: CopyLoc[3](loc0: &BridgeInner)
	9: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	10: CopyLoc[4](loc1: BridgeMessageKey)
	11: Call linked_table::contains<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): bool
	12: Not
	13: BrFalse(18)
B1:
	14: MoveLoc[3](loc0: &BridgeInner)
	15: Pop
	16: Call option::none<vector<vector<u8>>>(): Option<vector<vector<u8>>>
	17: Ret
B2:
	18: MoveLoc[3](loc0: &BridgeInner)
	19: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	20: MoveLoc[4](loc1: BridgeMessageKey)
	21: Call linked_table::borrow<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): &BridgeRecord
	22: ImmBorrowField[7](BridgeRecord.verified_signatures: Option<vector<vector<u8>>>)
	23: ReadRef
	24: Ret
}

load_inner(Arg0: &Bridge): &BridgeInner {
L1:	loc0: &BridgeInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &Bridge)
	1: ImmBorrowField[8](Bridge.inner: Versioned)
	2: Call versioned::version(&Versioned): u64
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[6](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &Bridge)
	10: Pop
	11: LdConst[12](u64: 7)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &Bridge)
	14: ImmBorrowField[8](Bridge.inner: Versioned)
	15: Call versioned::load_value<BridgeInner>(&Versioned): &BridgeInner
	16: StLoc[1](loc0: &BridgeInner)
	17: CopyLoc[1](loc0: &BridgeInner)
	18: ImmBorrowField[9](BridgeInner.bridge_version: u64)
	19: ReadRef
	20: MoveLoc[2](loc1: u64)
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[1](loc0: &BridgeInner)
	25: Pop
	26: LdConst[12](u64: 7)
	27: Abort
B6:
	28: MoveLoc[1](loc0: &BridgeInner)
	29: Ret
}

load_inner_mut(Arg0: &mut Bridge): &mut BridgeInner {
L1:	loc0: &mut BridgeInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut Bridge)
	1: ImmBorrowField[8](Bridge.inner: Versioned)
	2: Call versioned::version(&Versioned): u64
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[6](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut Bridge)
	10: Pop
	11: LdConst[12](u64: 7)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut Bridge)
	14: MutBorrowField[8](Bridge.inner: Versioned)
	15: Call versioned::load_value_mut<BridgeInner>(&mut Versioned): &mut BridgeInner
	16: StLoc[1](loc0: &mut BridgeInner)
	17: CopyLoc[1](loc0: &mut BridgeInner)
	18: ImmBorrowField[9](BridgeInner.bridge_version: u64)
	19: ReadRef
	20: MoveLoc[2](loc1: u64)
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[1](loc0: &mut BridgeInner)
	25: Pop
	26: LdConst[12](u64: 7)
	27: Abort
B6:
	28: MoveLoc[1](loc0: &mut BridgeInner)
	29: Ret
}

claim_token_internal<Ty0>(Arg0: &mut Bridge, Arg1: &Clock, Arg2: u8, Arg3: u64, Arg4: &mut TxContext): Option<Coin<Ty0>> * address {
L5:	loc0: u8
L6:	loc1: u8
L7:	loc2: &u8
L8:	loc3: u64
L9:	loc4: &mut BridgeInner
L10:	loc5: BridgeMessageKey
L11:	loc6: address
L12:	loc7: &mut BridgeRecord
L13:	loc8: BridgeRoute
L14:	loc9: u8
L15:	loc10: Coin<Ty0>
L16:	loc11: TokenTransferPayload
B0:
	0: MoveLoc[0](Arg0: &mut Bridge)
	1: Call load_inner_mut(&mut Bridge): &mut BridgeInner
	2: StLoc[9](loc4: &mut BridgeInner)
	3: CopyLoc[9](loc4: &mut BridgeInner)
	4: ImmBorrowField[2](BridgeInner.paused: bool)
	5: ReadRef
	6: Not
	7: BrFalse(9)
B1:
	8: Branch(17)
B2:
	9: MoveLoc[9](loc4: &mut BridgeInner)
	10: Pop
	11: MoveLoc[4](Arg4: &mut TxContext)
	12: Pop
	13: MoveLoc[1](Arg1: &Clock)
	14: Pop
	15: LdConst[13](u64: 8)
	16: Abort
B3:
	17: CopyLoc[2](Arg2: u8)
	18: Call message_types::token(): u8
	19: MoveLoc[3](Arg3: u64)
	20: Call message::create_key(u8, u8, u64): BridgeMessageKey
	21: StLoc[10](loc5: BridgeMessageKey)
	22: CopyLoc[9](loc4: &mut BridgeInner)
	23: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	24: CopyLoc[10](loc5: BridgeMessageKey)
	25: Call linked_table::contains<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): bool
	26: BrFalse(28)
B4:
	27: Branch(36)
B5:
	28: MoveLoc[9](loc4: &mut BridgeInner)
	29: Pop
	30: MoveLoc[4](Arg4: &mut TxContext)
	31: Pop
	32: MoveLoc[1](Arg1: &Clock)
	33: Pop
	34: LdConst[16](u64: 11)
	35: Abort
B6:
	36: CopyLoc[9](loc4: &mut BridgeInner)
	37: MutBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	38: CopyLoc[10](loc5: BridgeMessageKey)
	39: Call linked_table::borrow_mut<BridgeMessageKey, BridgeRecord>(&mut LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): &mut BridgeRecord
	40: StLoc[12](loc7: &mut BridgeRecord)
	41: CopyLoc[12](loc7: &mut BridgeRecord)
	42: ImmBorrowField[5](BridgeRecord.message: BridgeMessage)
	43: Call message::message_type(&BridgeMessage): u8
	44: StLoc[5](loc0: u8)
	45: ImmBorrowLoc[5](loc0: u8)
	46: StLoc[7](loc2: &u8)
	47: Call message_types::token(): u8
	48: StLoc[6](loc1: u8)
	49: MoveLoc[7](loc2: &u8)
	50: ImmBorrowLoc[6](loc1: u8)
	51: Eq
	52: BrFalse(54)
B7:
	53: Branch(64)
B8:
	54: MoveLoc[12](loc7: &mut BridgeRecord)
	55: Pop
	56: MoveLoc[9](loc4: &mut BridgeInner)
	57: Pop
	58: MoveLoc[4](Arg4: &mut TxContext)
	59: Pop
	60: MoveLoc[1](Arg1: &Clock)
	61: Pop
	62: LdConst[5](u64: 0)
	63: Abort
B9:
	64: CopyLoc[12](loc7: &mut BridgeRecord)
	65: ImmBorrowField[7](BridgeRecord.verified_signatures: Option<vector<vector<u8>>>)
	66: Call option::is_some<vector<vector<u8>>>(&Option<vector<vector<u8>>>): bool
	67: BrFalse(69)
B10:
	68: Branch(79)
B11:
	69: MoveLoc[12](loc7: &mut BridgeRecord)
	70: Pop
	71: MoveLoc[9](loc4: &mut BridgeInner)
	72: Pop
	73: MoveLoc[4](Arg4: &mut TxContext)
	74: Pop
	75: MoveLoc[1](Arg1: &Clock)
	76: Pop
	77: LdConst[6](u64: 1)
	78: Abort
B12:
	79: CopyLoc[12](loc7: &mut BridgeRecord)
	80: ImmBorrowField[5](BridgeRecord.message: BridgeMessage)
	81: Call message::extract_token_bridge_payload(&BridgeMessage): TokenTransferPayload
	82: StLoc[16](loc11: TokenTransferPayload)
	83: ImmBorrowLoc[16](loc11: TokenTransferPayload)
	84: Call message::token_target_address(&TokenTransferPayload): vector<u8>
	85: Call address::from_bytes(vector<u8>): address
	86: StLoc[11](loc6: address)
	87: CopyLoc[12](loc7: &mut BridgeRecord)
	88: ImmBorrowField[6](BridgeRecord.claimed: bool)
	89: ReadRef
	90: BrFalse(105)
B13:
	91: MoveLoc[12](loc7: &mut BridgeRecord)
	92: Pop
	93: MoveLoc[9](loc4: &mut BridgeInner)
	94: Pop
	95: MoveLoc[4](Arg4: &mut TxContext)
	96: Pop
	97: MoveLoc[1](Arg1: &Clock)
	98: Pop
	99: MoveLoc[10](loc5: BridgeMessageKey)
	100: Pack[8](TokenTransferAlreadyClaimed)
	101: Call event::emit<TokenTransferAlreadyClaimed>(TokenTransferAlreadyClaimed)
	102: Call option::none<Coin<Ty0>>(): Option<Coin<Ty0>>
	103: MoveLoc[11](loc6: address)
	104: Ret
B14:
	105: ImmBorrowLoc[16](loc11: TokenTransferPayload)
	106: Call message::token_target_chain(&TokenTransferPayload): u8
	107: StLoc[14](loc9: u8)
	108: CopyLoc[14](loc9: u8)
	109: CopyLoc[9](loc4: &mut BridgeInner)
	110: ImmBorrowField[3](BridgeInner.chain_id: u8)
	111: ReadRef
	112: Eq
	113: BrFalse(115)
B15:
	114: Branch(125)
B16:
	115: MoveLoc[12](loc7: &mut BridgeRecord)
	116: Pop
	117: MoveLoc[9](loc4: &mut BridgeInner)
	118: Pop
	119: MoveLoc[4](Arg4: &mut TxContext)
	120: Pop
	121: MoveLoc[1](Arg1: &Clock)
	122: Pop
	123: LdConst[9](u64: 4)
	124: Abort
B17:
	125: MoveLoc[2](Arg2: u8)
	126: MoveLoc[14](loc9: u8)
	127: Call chain_ids::get_route(u8, u8): BridgeRoute
	128: StLoc[13](loc8: BridgeRoute)
	129: CopyLoc[9](loc4: &mut BridgeInner)
	130: ImmBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	131: Call treasury::token_id<Ty0>(&BridgeTreasury): u8
	132: ImmBorrowLoc[16](loc11: TokenTransferPayload)
	133: Call message::token_type(&TokenTransferPayload): u8
	134: Eq
	135: BrFalse(137)
B18:
	136: Branch(147)
B19:
	137: MoveLoc[12](loc7: &mut BridgeRecord)
	138: Pop
	139: MoveLoc[9](loc4: &mut BridgeInner)
	140: Pop
	141: MoveLoc[4](Arg4: &mut TxContext)
	142: Pop
	143: MoveLoc[1](Arg1: &Clock)
	144: Pop
	145: LdConst[8](u64: 3)
	146: Abort
B20:
	147: ImmBorrowLoc[16](loc11: TokenTransferPayload)
	148: Call message::token_amount(&TokenTransferPayload): u64
	149: StLoc[8](loc3: u64)
	150: CopyLoc[9](loc4: &mut BridgeInner)
	151: MutBorrowField[10](BridgeInner.limiter: TransferLimiter)
	152: CopyLoc[9](loc4: &mut BridgeInner)
	153: ImmBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	154: MoveLoc[1](Arg1: &Clock)
	155: MoveLoc[13](loc8: BridgeRoute)
	156: CopyLoc[8](loc3: u64)
	157: Call limiter::check_and_record_sending_transfer<Ty0>(&mut TransferLimiter, &BridgeTreasury, &Clock, BridgeRoute, u64): bool
	158: Not
	159: BrFalse(172)
B21:
	160: MoveLoc[12](loc7: &mut BridgeRecord)
	161: Pop
	162: MoveLoc[9](loc4: &mut BridgeInner)
	163: Pop
	164: MoveLoc[4](Arg4: &mut TxContext)
	165: Pop
	166: MoveLoc[10](loc5: BridgeMessageKey)
	167: Pack[9](TokenTransferLimitExceed)
	168: Call event::emit<TokenTransferLimitExceed>(TokenTransferLimitExceed)
	169: Call option::none<Coin<Ty0>>(): Option<Coin<Ty0>>
	170: MoveLoc[11](loc6: address)
	171: Ret
B22:
	172: MoveLoc[9](loc4: &mut BridgeInner)
	173: MutBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	174: MoveLoc[8](loc3: u64)
	175: MoveLoc[4](Arg4: &mut TxContext)
	176: Call treasury::mint<Ty0>(&mut BridgeTreasury, u64, &mut TxContext): Coin<Ty0>
	177: StLoc[15](loc10: Coin<Ty0>)
	178: LdTrue
	179: MoveLoc[12](loc7: &mut BridgeRecord)
	180: MutBorrowField[6](BridgeRecord.claimed: bool)
	181: WriteRef
	182: MoveLoc[10](loc5: BridgeMessageKey)
	183: Pack[6](TokenTransferClaimed)
	184: Call event::emit<TokenTransferClaimed>(TokenTransferClaimed)
	185: MoveLoc[15](loc10: Coin<Ty0>)
	186: Call option::some<Coin<Ty0>>(Coin<Ty0>): Option<Coin<Ty0>>
	187: MoveLoc[11](loc6: address)
	188: Ret
}

execute_emergency_op(Arg0: &mut BridgeInner, Arg1: EmergencyOp) {
L2:	loc0: u8
B0:
	0: ImmBorrowLoc[1](Arg1: EmergencyOp)
	1: Call message::emergency_op_type(&EmergencyOp): u8
	2: StLoc[2](loc0: u8)
	3: CopyLoc[2](loc0: u8)
	4: Call message::emergency_op_pause(): u8
	5: Eq
	6: BrFalse(25)
B1:
	7: CopyLoc[0](Arg0: &mut BridgeInner)
	8: ImmBorrowField[2](BridgeInner.paused: bool)
	9: ReadRef
	10: Not
	11: BrFalse(13)
B2:
	12: Branch(17)
B3:
	13: MoveLoc[0](Arg0: &mut BridgeInner)
	14: Pop
	15: LdConst[18](u64: 13)
	16: Abort
B4:
	17: LdTrue
	18: MoveLoc[0](Arg0: &mut BridgeInner)
	19: MutBorrowField[2](BridgeInner.paused: bool)
	20: WriteRef
	21: LdTrue
	22: Pack[3](EmergencyOpEvent)
	23: Call event::emit<EmergencyOpEvent>(EmergencyOpEvent)
	24: Branch(50)
B5:
	25: MoveLoc[2](loc0: u8)
	26: Call message::emergency_op_unpause(): u8
	27: Eq
	28: BrFalse(46)
B6:
	29: CopyLoc[0](Arg0: &mut BridgeInner)
	30: ImmBorrowField[2](BridgeInner.paused: bool)
	31: ReadRef
	32: BrFalse(34)
B7:
	33: Branch(38)
B8:
	34: MoveLoc[0](Arg0: &mut BridgeInner)
	35: Pop
	36: LdConst[19](u64: 14)
	37: Abort
B9:
	38: LdFalse
	39: MoveLoc[0](Arg0: &mut BridgeInner)
	40: MutBorrowField[2](BridgeInner.paused: bool)
	41: WriteRef
	42: LdFalse
	43: Pack[3](EmergencyOpEvent)
	44: Call event::emit<EmergencyOpEvent>(EmergencyOpEvent)
	45: Branch(50)
B10:
	46: MoveLoc[0](Arg0: &mut BridgeInner)
	47: Pop
	48: LdConst[14](u64: 9)
	49: Abort
B11:
	50: Ret
}

execute_update_bridge_limit(Arg0: &mut BridgeInner, Arg1: UpdateBridgeLimit) {
L2:	loc0: u8
L3:	loc1: BridgeRoute
B0:
	0: ImmBorrowLoc[1](Arg1: UpdateBridgeLimit)
	1: Call message::update_bridge_limit_payload_receiving_chain(&UpdateBridgeLimit): u8
	2: StLoc[2](loc0: u8)
	3: CopyLoc[2](loc0: u8)
	4: CopyLoc[0](Arg0: &mut BridgeInner)
	5: ImmBorrowField[3](BridgeInner.chain_id: u8)
	6: ReadRef
	7: Eq
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[0](Arg0: &mut BridgeInner)
	11: Pop
	12: LdConst[9](u64: 4)
	13: Abort
B3:
	14: ImmBorrowLoc[1](Arg1: UpdateBridgeLimit)
	15: Call message::update_bridge_limit_payload_sending_chain(&UpdateBridgeLimit): u8
	16: MoveLoc[2](loc0: u8)
	17: Call chain_ids::get_route(u8, u8): BridgeRoute
	18: StLoc[3](loc1: BridgeRoute)
	19: MoveLoc[0](Arg0: &mut BridgeInner)
	20: MutBorrowField[10](BridgeInner.limiter: TransferLimiter)
	21: ImmBorrowLoc[3](loc1: BridgeRoute)
	22: ImmBorrowLoc[1](Arg1: UpdateBridgeLimit)
	23: Call message::update_bridge_limit_payload_limit(&UpdateBridgeLimit): u64
	24: Call limiter::update_route_limit(&mut TransferLimiter, &BridgeRoute, u64)
	25: Ret
}

execute_update_asset_price(Arg0: &mut BridgeInner, Arg1: UpdateAssetPrice) {
B0:
	0: MoveLoc[0](Arg0: &mut BridgeInner)
	1: MutBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	2: ImmBorrowLoc[1](Arg1: UpdateAssetPrice)
	3: Call message::update_asset_price_payload_token_id(&UpdateAssetPrice): u8
	4: ImmBorrowLoc[1](Arg1: UpdateAssetPrice)
	5: Call message::update_asset_price_payload_new_price(&UpdateAssetPrice): u64
	6: Call treasury::update_asset_notional_price(&mut BridgeTreasury, u8, u64)
	7: Ret
}

execute_add_tokens_on_safe(Arg0: &mut BridgeInner, Arg1: AddTokenOnSafe) {
L2:	loc0: bool
L3:	loc1: u8
L4:	loc2: vector<u8>
L5:	loc3: u64
L6:	loc4: vector<u64>
L7:	loc5: String
L8:	loc6: vector<String>
B0:
	0: ImmBorrowLoc[1](Arg1: AddTokenOnSafe)
	1: Call message::is_native(&AddTokenOnSafe): bool
	2: StLoc[2](loc0: bool)
	3: ImmBorrowLoc[1](Arg1: AddTokenOnSafe)
	4: Call message::token_ids(&AddTokenOnSafe): vector<u8>
	5: StLoc[4](loc2: vector<u8>)
	6: ImmBorrowLoc[1](Arg1: AddTokenOnSafe)
	7: Call message::token_type_names(&AddTokenOnSafe): vector<String>
	8: StLoc[8](loc6: vector<String>)
	9: ImmBorrowLoc[1](Arg1: AddTokenOnSafe)
	10: Call message::token_prices(&AddTokenOnSafe): vector<u64>
	11: StLoc[6](loc4: vector<u64>)
	12: ImmBorrowLoc[4](loc2: vector<u8>)
	13: VecLen(11)
	14: ImmBorrowLoc[8](loc6: vector<String>)
	15: VecLen(111)
	16: Eq
	17: BrFalse(19)
B1:
	18: Branch(23)
B2:
	19: MoveLoc[0](Arg0: &mut BridgeInner)
	20: Pop
	21: LdConst[7](u64: 2)
	22: Abort
B3:
	23: ImmBorrowLoc[4](loc2: vector<u8>)
	24: VecLen(11)
	25: ImmBorrowLoc[6](loc4: vector<u64>)
	26: VecLen(23)
	27: Eq
	28: BrFalse(30)
B4:
	29: Branch(34)
B5:
	30: MoveLoc[0](Arg0: &mut BridgeInner)
	31: Pop
	32: LdConst[7](u64: 2)
	33: Abort
B6:
	34: ImmBorrowLoc[4](loc2: vector<u8>)
	35: VecLen(11)
	36: LdU64(0)
	37: Gt
	38: BrFalse(56)
B7:
	39: MutBorrowLoc[4](loc2: vector<u8>)
	40: VecPopBack(11)
	41: StLoc[3](loc1: u8)
	42: MutBorrowLoc[8](loc6: vector<String>)
	43: VecPopBack(111)
	44: StLoc[7](loc5: String)
	45: MutBorrowLoc[6](loc4: vector<u64>)
	46: VecPopBack(23)
	47: StLoc[5](loc3: u64)
	48: CopyLoc[0](Arg0: &mut BridgeInner)
	49: MutBorrowField[1](BridgeInner.treasury: BridgeTreasury)
	50: MoveLoc[7](loc5: String)
	51: MoveLoc[3](loc1: u8)
	52: CopyLoc[2](loc0: bool)
	53: MoveLoc[5](loc3: u64)
	54: Call treasury::add_new_token(&mut BridgeTreasury, String, u8, bool, u64)
	55: Branch(34)
B8:
	56: MoveLoc[0](Arg0: &mut BridgeInner)
	57: Pop
	58: Ret
}

get_current_seq_num_and_increment(Arg0: &mut BridgeInner, Arg1: u8): u64 {
L2:	loc0: &mut u64
L3:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut BridgeInner)
	1: ImmBorrowField[11](BridgeInner.sequence_nums: VecMap<u8, u64>)
	2: ImmBorrowLoc[1](Arg1: u8)
	3: Call vec_map::contains<u8, u64>(&VecMap<u8, u64>, &u8): bool
	4: Not
	5: BrFalse(13)
B1:
	6: MoveLoc[0](Arg0: &mut BridgeInner)
	7: MutBorrowField[11](BridgeInner.sequence_nums: VecMap<u8, u64>)
	8: MoveLoc[1](Arg1: u8)
	9: LdU64(1)
	10: Call vec_map::insert<u8, u64>(&mut VecMap<u8, u64>, u8, u64)
	11: LdU64(0)
	12: Ret
B2:
	13: MoveLoc[0](Arg0: &mut BridgeInner)
	14: MutBorrowField[11](BridgeInner.sequence_nums: VecMap<u8, u64>)
	15: ImmBorrowLoc[1](Arg1: u8)
	16: Call vec_map::get_mut<u8, u64>(&mut VecMap<u8, u64>, &u8): &mut u64
	17: StLoc[2](loc0: &mut u64)
	18: CopyLoc[2](loc0: &mut u64)
	19: ReadRef
	20: StLoc[3](loc1: u64)
	21: CopyLoc[3](loc1: u64)
	22: LdU64(1)
	23: Add
	24: MoveLoc[2](loc0: &mut u64)
	25: WriteRef
	26: MoveLoc[3](loc1: u64)
	27: Ret
}

get_parsed_token_transfer_message(Arg0: &Bridge, Arg1: u8, Arg2: u64): Option<ParsedTokenTransferMessage> {
L3:	loc0: &BridgeInner
L4:	loc1: BridgeMessageKey
B0:
	0: MoveLoc[0](Arg0: &Bridge)
	1: Call load_inner(&Bridge): &BridgeInner
	2: StLoc[3](loc0: &BridgeInner)
	3: MoveLoc[1](Arg1: u8)
	4: Call message_types::token(): u8
	5: MoveLoc[2](Arg2: u64)
	6: Call message::create_key(u8, u8, u64): BridgeMessageKey
	7: StLoc[4](loc1: BridgeMessageKey)
	8: CopyLoc[3](loc0: &BridgeInner)
	9: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	10: CopyLoc[4](loc1: BridgeMessageKey)
	11: Call linked_table::contains<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): bool
	12: Not
	13: BrFalse(18)
B1:
	14: MoveLoc[3](loc0: &BridgeInner)
	15: Pop
	16: Call option::none<ParsedTokenTransferMessage>(): Option<ParsedTokenTransferMessage>
	17: Ret
B2:
	18: MoveLoc[3](loc0: &BridgeInner)
	19: ImmBorrowField[4](BridgeInner.token_transfer_records: LinkedTable<BridgeMessageKey, BridgeRecord>)
	20: MoveLoc[4](loc1: BridgeMessageKey)
	21: Call linked_table::borrow<BridgeMessageKey, BridgeRecord>(&LinkedTable<BridgeMessageKey, BridgeRecord>, BridgeMessageKey): &BridgeRecord
	22: ImmBorrowField[5](BridgeRecord.message: BridgeMessage)
	23: Call message::to_parsed_token_transfer_message(&BridgeMessage): ParsedTokenTransferMessage
	24: Call option::some<ParsedTokenTransferMessage>(ParsedTokenTransferMessage): Option<ParsedTokenTransferMessage>
	25: Ret
}

Constants [
	0 => u8: 1
	1 => u8: 0
	2 => u8: 2
	3 => u8: 3
	4 => u64: 20
	5 => u64: 0
	6 => u64: 1
	7 => u64: 2
	8 => u64: 3
	9 => u64: 4
	10 => u64: 5
	11 => u64: 6
	12 => u64: 7
	13 => u64: 8
	14 => u64: 9
	15 => u64: 10
	16 => u64: 11
	17 => u64: 12
	18 => u64: 13
	19 => u64: 14
	20 => u64: 15
	21 => u64: 16
	22 => u64: 17
	23 => u64: 18
	24 => u64: 19
	25 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module b.chain_ids {
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct BridgeRoute has copy, drop, store {
	source: u8,
	destination: u8
}

public safe_mainnet(): u8 {
B0:
	0: LdConst[0](u8: 0)
	1: Ret
}

public safe_testnet(): u8 {
B0:
	0: LdConst[1](u8: 1)
	1: Ret
}

public safe_custom(): u8 {
B0:
	0: LdConst[2](u8: 2)
	1: Ret
}

public eth_mainnet(): u8 {
B0:
	0: LdConst[3](u8: 10)
	1: Ret
}

public eth_sepolia(): u8 {
B0:
	0: LdConst[4](u8: 11)
	1: Ret
}

public eth_custom(): u8 {
B0:
	0: LdConst[5](u8: 12)
	1: Ret
}

public route_source(Arg0: &BridgeRoute): &u8 {
B0:
	0: MoveLoc[0](Arg0: &BridgeRoute)
	1: ImmBorrowField[0](BridgeRoute.source: u8)
	2: Ret
}

public route_destination(Arg0: &BridgeRoute): &u8 {
B0:
	0: MoveLoc[0](Arg0: &BridgeRoute)
	1: ImmBorrowField[1](BridgeRoute.destination: u8)
	2: Ret
}

public assert_valid_chain_id(Arg0: u8) {
L1:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: u8)
	1: LdConst[0](u8: 0)
	2: Eq
	3: BrFalse(7)
B1:
	4: LdTrue
	5: StLoc[1](loc0: bool)
	6: Branch(39)
B2:
	7: CopyLoc[0](Arg0: u8)
	8: LdConst[1](u8: 1)
	9: Eq
	10: BrFalse(14)
B3:
	11: LdTrue
	12: StLoc[1](loc0: bool)
	13: Branch(39)
B4:
	14: CopyLoc[0](Arg0: u8)
	15: LdConst[2](u8: 2)
	16: Eq
	17: BrFalse(21)
B5:
	18: LdTrue
	19: StLoc[1](loc0: bool)
	20: Branch(39)
B6:
	21: CopyLoc[0](Arg0: u8)
	22: LdConst[3](u8: 10)
	23: Eq
	24: BrFalse(28)
B7:
	25: LdTrue
	26: StLoc[1](loc0: bool)
	27: Branch(39)
B8:
	28: CopyLoc[0](Arg0: u8)
	29: LdConst[4](u8: 11)
	30: Eq
	31: BrFalse(35)
B9:
	32: LdTrue
	33: StLoc[1](loc0: bool)
	34: Branch(39)
B10:
	35: MoveLoc[0](Arg0: u8)
	36: LdConst[5](u8: 12)
	37: Eq
	38: StLoc[1](loc0: bool)
B11:
	39: MoveLoc[1](loc0: bool)
	40: BrFalse(42)
B12:
	41: Branch(44)
B13:
	42: LdConst[6](u64: 0)
	43: Abort
B14:
	44: Ret
}

public valid_routes(): vector<BridgeRoute> {
B0:
	0: LdConst[0](u8: 0)
	1: LdConst[3](u8: 10)
	2: Pack[0](BridgeRoute)
	3: LdConst[3](u8: 10)
	4: LdConst[0](u8: 0)
	5: Pack[0](BridgeRoute)
	6: LdConst[1](u8: 1)
	7: LdConst[4](u8: 11)
	8: Pack[0](BridgeRoute)
	9: LdConst[1](u8: 1)
	10: LdConst[5](u8: 12)
	11: Pack[0](BridgeRoute)
	12: LdConst[2](u8: 2)
	13: LdConst[5](u8: 12)
	14: Pack[0](BridgeRoute)
	15: LdConst[2](u8: 2)
	16: LdConst[4](u8: 11)
	17: Pack[0](BridgeRoute)
	18: LdConst[4](u8: 11)
	19: LdConst[1](u8: 1)
	20: Pack[0](BridgeRoute)
	21: LdConst[4](u8: 11)
	22: LdConst[2](u8: 2)
	23: Pack[0](BridgeRoute)
	24: LdConst[5](u8: 12)
	25: LdConst[1](u8: 1)
	26: Pack[0](BridgeRoute)
	27: LdConst[5](u8: 12)
	28: LdConst[2](u8: 2)
	29: Pack[0](BridgeRoute)
	30: VecPack(7, 10)
	31: Ret
}

public is_valid_route(Arg0: u8, Arg1: u8): bool {
L2:	loc0: vector<BridgeRoute>
L3:	loc1: BridgeRoute
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: u8)
	2: Pack[0](BridgeRoute)
	3: StLoc[3](loc1: BridgeRoute)
	4: Call valid_routes(): vector<BridgeRoute>
	5: StLoc[2](loc0: vector<BridgeRoute>)
	6: ImmBorrowLoc[2](loc0: vector<BridgeRoute>)
	7: ImmBorrowLoc[3](loc1: BridgeRoute)
	8: Call vector::contains<BridgeRoute>(&vector<BridgeRoute>, &BridgeRoute): bool
	9: Ret
}

public get_route(Arg0: u8, Arg1: u8): BridgeRoute {
L2:	loc0: vector<BridgeRoute>
L3:	loc1: BridgeRoute
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: u8)
	2: Pack[0](BridgeRoute)
	3: StLoc[3](loc1: BridgeRoute)
	4: Call valid_routes(): vector<BridgeRoute>
	5: StLoc[2](loc0: vector<BridgeRoute>)
	6: ImmBorrowLoc[2](loc0: vector<BridgeRoute>)
	7: ImmBorrowLoc[3](loc1: BridgeRoute)
	8: Call vector::contains<BridgeRoute>(&vector<BridgeRoute>, &BridgeRoute): bool
	9: BrFalse(11)
B1:
	10: Branch(13)
B2:
	11: LdConst[6](u64: 0)
	12: Abort
B3:
	13: MoveLoc[3](loc1: BridgeRoute)
	14: Ret
}

Constants [
	0 => u8: 0
	1 => u8: 1
	2 => u8: 2
	3 => u8: 10
	4 => u8: 11
	5 => u8: 12
	6 => u64: 0
]
}

// Move bytecode v6
module b.committee {
use 000000000000000000000000000000000000000000000000000000000000000b::crypto;
use 000000000000000000000000000000000000000000000000000000000000000b::message;
use 0000000000000000000000000000000000000000000000000000000000000002::ecdsa_k1;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000003::safe_system;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct BlocklistValidatorEvent has copy, drop {
	blocklisted: bool,
	public_keys: vector<vector<u8>>
}

struct BridgeCommittee has store {
	members: VecMap<vector<u8>, CommitteeMember>,
	member_registrations: VecMap<address, CommitteeMemberRegistration>,
	last_committee_update_epoch: u64
}

struct CommitteeUpdateEvent has copy, drop {
	members: VecMap<vector<u8>, CommitteeMember>,
	stake_participation_percentage: u64
}

struct CommitteeMemberUrlUpdateEvent has copy, drop {
	member: vector<u8>,
	new_url: vector<u8>
}

struct CommitteeMember has copy, drop, store {
	safe_address: address,
	bridge_pubkey_bytes: vector<u8>,
	voting_power: u64,
	http_rest_url: vector<u8>,
	blocklisted: bool
}

struct CommitteeMemberRegistration has copy, drop, store {
	safe_address: address,
	bridge_pubkey_bytes: vector<u8>,
	http_rest_url: vector<u8>
}

public verify_signatures(Arg0: &BridgeCommittee, Arg1: BridgeMessage, Arg2: vector<vector<u8>>) {
L3:	loc0: u64
L4:	loc1: &CommitteeMember
L5:	loc2: vector<u8>
L6:	loc3: vector<u8>
L7:	loc4: u64
L8:	loc5: VecSet<vector<u8>>
L9:	loc6: u64
L10:	loc7: u64
B0:
	0: LdU64(0)
	1: ImmBorrowLoc[2](Arg2: vector<vector<u8>>)
	2: VecLen(12)
	3: StLoc[9](loc6: u64)
	4: StLoc[3](loc0: u64)
	5: Call vec_set::empty<vector<u8>>(): VecSet<vector<u8>>
	6: StLoc[8](loc5: VecSet<vector<u8>>)
	7: ImmBorrowLoc[1](Arg1: BridgeMessage)
	8: Call message::required_voting_power(&BridgeMessage): u64
	9: StLoc[7](loc4: u64)
	10: LdConst[10](vector<u8>: "SAF..)
	11: StLoc[5](loc2: vector<u8>)
	12: MutBorrowLoc[5](loc2: vector<u8>)
	13: MoveLoc[1](Arg1: BridgeMessage)
	14: Call message::serialize_message(BridgeMessage): vector<u8>
	15: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	16: LdU64(0)
	17: StLoc[10](loc7: u64)
B1:
	18: CopyLoc[3](loc0: u64)
	19: CopyLoc[9](loc6: u64)
	20: Lt
	21: BrFalse(77)
B2:
	22: Branch(23)
B3:
	23: ImmBorrowLoc[2](Arg2: vector<vector<u8>>)
	24: CopyLoc[3](loc0: u64)
	25: VecImmBorrow(12)
	26: ImmBorrowLoc[5](loc2: vector<u8>)
	27: LdU8(0)
	28: Call ecdsa_k1::secp256k1_ecrecover(&vector<u8>, &vector<u8>, u8): vector<u8>
	29: StLoc[6](loc3: vector<u8>)
	30: ImmBorrowLoc[8](loc5: VecSet<vector<u8>>)
	31: ImmBorrowLoc[6](loc3: vector<u8>)
	32: Call vec_set::contains<vector<u8>>(&VecSet<vector<u8>>, &vector<u8>): bool
	33: Not
	34: BrFalse(36)
B4:
	35: Branch(40)
B5:
	36: MoveLoc[0](Arg0: &BridgeCommittee)
	37: Pop
	38: LdConst[1](u64: 1)
	39: Abort
B6:
	40: CopyLoc[0](Arg0: &BridgeCommittee)
	41: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	42: ImmBorrowLoc[6](loc3: vector<u8>)
	43: Call vec_map::contains<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>, &vector<u8>): bool
	44: BrFalse(46)
B7:
	45: Branch(50)
B8:
	46: MoveLoc[0](Arg0: &BridgeCommittee)
	47: Pop
	48: LdConst[2](u64: 2)
	49: Abort
B9:
	50: CopyLoc[0](Arg0: &BridgeCommittee)
	51: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	52: ImmBorrowLoc[6](loc3: vector<u8>)
	53: Call vec_map::get<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>, &vector<u8>): &CommitteeMember
	54: StLoc[4](loc1: &CommitteeMember)
	55: CopyLoc[4](loc1: &CommitteeMember)
	56: ImmBorrowField[1](CommitteeMember.blocklisted: bool)
	57: ReadRef
	58: Not
	59: BrFalse(67)
B10:
	60: MoveLoc[10](loc7: u64)
	61: MoveLoc[4](loc1: &CommitteeMember)
	62: ImmBorrowField[2](CommitteeMember.voting_power: u64)
	63: ReadRef
	64: Add
	65: StLoc[10](loc7: u64)
	66: Branch(69)
B11:
	67: MoveLoc[4](loc1: &CommitteeMember)
	68: Pop
B12:
	69: MutBorrowLoc[8](loc5: VecSet<vector<u8>>)
	70: MoveLoc[6](loc3: vector<u8>)
	71: Call vec_set::insert<vector<u8>>(&mut VecSet<vector<u8>>, vector<u8>)
	72: MoveLoc[3](loc0: u64)
	73: LdU64(1)
	74: Add
	75: StLoc[3](loc0: u64)
	76: Branch(18)
B13:
	77: MoveLoc[0](Arg0: &BridgeCommittee)
	78: Pop
	79: MoveLoc[10](loc7: u64)
	80: MoveLoc[7](loc4: u64)
	81: Ge
	82: BrFalse(84)
B14:
	83: Branch(86)
B15:
	84: LdConst[0](u64: 0)
	85: Abort
B16:
	86: Ret
}

public(friend) create(Arg0: &TxContext): BridgeCommittee {
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[12](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[3](u64: 3)
	7: Abort
B3:
	8: Call vec_map::empty<vector<u8>, CommitteeMember>(): VecMap<vector<u8>, CommitteeMember>
	9: Call vec_map::empty<address, CommitteeMemberRegistration>(): VecMap<address, CommitteeMemberRegistration>
	10: LdU64(0)
	11: Pack[1](BridgeCommittee)
	12: Ret
}

public(friend) register(Arg0: &mut BridgeCommittee, Arg1: &mut SafeSystemState, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: &TxContext) {
L5:	loc0: CommitteeMemberRegistration
L6:	loc1: &mut CommitteeMemberRegistration
L7:	loc2: CommitteeMemberRegistration
L8:	loc3: CommitteeMemberRegistration
L9:	loc4: address
L10:	loc5: vector<address>
B0:
	0: CopyLoc[0](Arg0: &mut BridgeCommittee)
	1: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	2: Call vec_map::is_empty<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>): bool
	3: BrFalse(5)
B1:
	4: Branch(13)
B2:
	5: MoveLoc[1](Arg1: &mut SafeSystemState)
	6: Pop
	7: MoveLoc[0](Arg0: &mut BridgeCommittee)
	8: Pop
	9: MoveLoc[4](Arg4: &TxContext)
	10: Pop
	11: LdConst[7](u64: 7)
	12: Abort
B3:
	13: ImmBorrowLoc[2](Arg2: vector<u8>)
	14: VecLen(17)
	15: LdConst[11](u64: 33)
	16: Eq
	17: BrFalse(19)
B4:
	18: Branch(27)
B5:
	19: MoveLoc[1](Arg1: &mut SafeSystemState)
	20: Pop
	21: MoveLoc[0](Arg0: &mut BridgeCommittee)
	22: Pop
	23: MoveLoc[4](Arg4: &TxContext)
	24: Pop
	25: LdConst[6](u64: 6)
	26: Abort
B6:
	27: MoveLoc[4](Arg4: &TxContext)
	28: Call tx_context::sender(&TxContext): address
	29: StLoc[9](loc4: address)
	30: MoveLoc[1](Arg1: &mut SafeSystemState)
	31: Call safe_system::active_validator_addresses(&mut SafeSystemState): vector<address>
	32: StLoc[10](loc5: vector<address>)
	33: ImmBorrowLoc[10](loc5: vector<address>)
	34: ImmBorrowLoc[9](loc4: address)
	35: Call vector::contains<address>(&vector<address>, &address): bool
	36: BrFalse(38)
B7:
	37: Branch(42)
B8:
	38: MoveLoc[0](Arg0: &mut BridgeCommittee)
	39: Pop
	40: LdConst[5](u64: 5)
	41: Abort
B9:
	42: CopyLoc[0](Arg0: &mut BridgeCommittee)
	43: ImmBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	44: ImmBorrowLoc[9](loc4: address)
	45: Call vec_map::contains<address, CommitteeMemberRegistration>(&VecMap<address, CommitteeMemberRegistration>, &address): bool
	46: BrFalse(64)
B10:
	47: CopyLoc[0](Arg0: &mut BridgeCommittee)
	48: MutBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	49: ImmBorrowLoc[9](loc4: address)
	50: Call vec_map::get_mut<address, CommitteeMemberRegistration>(&mut VecMap<address, CommitteeMemberRegistration>, &address): &mut CommitteeMemberRegistration
	51: StLoc[6](loc1: &mut CommitteeMemberRegistration)
	52: MoveLoc[3](Arg3: vector<u8>)
	53: CopyLoc[6](loc1: &mut CommitteeMemberRegistration)
	54: MutBorrowField[4](CommitteeMemberRegistration.http_rest_url: vector<u8>)
	55: WriteRef
	56: CopyLoc[2](Arg2: vector<u8>)
	57: CopyLoc[6](loc1: &mut CommitteeMemberRegistration)
	58: MutBorrowField[5](CommitteeMemberRegistration.bridge_pubkey_bytes: vector<u8>)
	59: WriteRef
	60: MoveLoc[6](loc1: &mut CommitteeMemberRegistration)
	61: ReadRef
	62: StLoc[5](loc0: CommitteeMemberRegistration)
	63: Branch(76)
B11:
	64: CopyLoc[9](loc4: address)
	65: CopyLoc[2](Arg2: vector<u8>)
	66: MoveLoc[3](Arg3: vector<u8>)
	67: Pack[5](CommitteeMemberRegistration)
	68: StLoc[7](loc2: CommitteeMemberRegistration)
	69: CopyLoc[0](Arg0: &mut BridgeCommittee)
	70: MutBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	71: MoveLoc[9](loc4: address)
	72: CopyLoc[7](loc2: CommitteeMemberRegistration)
	73: Call vec_map::insert<address, CommitteeMemberRegistration>(&mut VecMap<address, CommitteeMemberRegistration>, address, CommitteeMemberRegistration)
	74: MoveLoc[7](loc2: CommitteeMemberRegistration)
	75: StLoc[5](loc0: CommitteeMemberRegistration)
B12:
	76: MoveLoc[5](loc0: CommitteeMemberRegistration)
	77: StLoc[8](loc3: CommitteeMemberRegistration)
	78: MoveLoc[0](Arg0: &mut BridgeCommittee)
	79: FreezeRef
	80: MoveLoc[2](Arg2: vector<u8>)
	81: Call check_uniqueness_bridge_keys(&BridgeCommittee, vector<u8>)
	82: MoveLoc[8](loc3: CommitteeMemberRegistration)
	83: Call event::emit<CommitteeMemberRegistration>(CommitteeMemberRegistration)
	84: Ret
}

public(friend) try_create_next_committee(Arg0: &mut BridgeCommittee, Arg1: VecMap<address, u64>, Arg2: u64, Arg3: &TxContext) {
L4:	loc0: u64
L5:	loc1: CommitteeMember
L6:	loc2: VecMap<vector<u8>, CommitteeMember>
L7:	loc3: &CommitteeMemberRegistration
L8:	loc4: u64
L9:	loc5: Option<u64>
L10:	loc6: u64
B0:
	0: LdU64(0)
	1: StLoc[4](loc0: u64)
	2: Call vec_map::empty<vector<u8>, CommitteeMember>(): VecMap<vector<u8>, CommitteeMember>
	3: StLoc[6](loc2: VecMap<vector<u8>, CommitteeMember>)
	4: LdU64(0)
	5: StLoc[8](loc4: u64)
B1:
	6: CopyLoc[4](loc0: u64)
	7: CopyLoc[0](Arg0: &mut BridgeCommittee)
	8: ImmBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	9: Call vec_map::size<address, CommitteeMemberRegistration>(&VecMap<address, CommitteeMemberRegistration>): u64
	10: Lt
	11: BrFalse(62)
B2:
	12: Branch(13)
B3:
	13: CopyLoc[0](Arg0: &mut BridgeCommittee)
	14: ImmBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	15: CopyLoc[4](loc0: u64)
	16: Call vec_map::get_entry_by_idx<address, CommitteeMemberRegistration>(&VecMap<address, CommitteeMemberRegistration>, u64): &address * &CommitteeMemberRegistration
	17: StLoc[7](loc3: &CommitteeMemberRegistration)
	18: Pop
	19: ImmBorrowLoc[1](Arg1: VecMap<address, u64>)
	20: CopyLoc[7](loc3: &CommitteeMemberRegistration)
	21: ImmBorrowField[6](CommitteeMemberRegistration.safe_address: address)
	22: Call vec_map::try_get<address, u64>(&VecMap<address, u64>, &address): Option<u64>
	23: StLoc[9](loc5: Option<u64>)
	24: ImmBorrowLoc[9](loc5: Option<u64>)
	25: Call option::is_some<u64>(&Option<u64>): bool
	26: BrFalse(55)
B4:
	27: MoveLoc[9](loc5: Option<u64>)
	28: Call option::destroy_some<u64>(Option<u64>): u64
	29: StLoc[10](loc6: u64)
	30: MoveLoc[8](loc4: u64)
	31: CopyLoc[10](loc6: u64)
	32: Add
	33: StLoc[8](loc4: u64)
	34: CopyLoc[7](loc3: &CommitteeMemberRegistration)
	35: ImmBorrowField[6](CommitteeMemberRegistration.safe_address: address)
	36: ReadRef
	37: CopyLoc[7](loc3: &CommitteeMemberRegistration)
	38: ImmBorrowField[5](CommitteeMemberRegistration.bridge_pubkey_bytes: vector<u8>)
	39: ReadRef
	40: MoveLoc[10](loc6: u64)
	41: CastU64
	42: CopyLoc[7](loc3: &CommitteeMemberRegistration)
	43: ImmBorrowField[4](CommitteeMemberRegistration.http_rest_url: vector<u8>)
	44: ReadRef
	45: LdFalse
	46: Pack[4](CommitteeMember)
	47: StLoc[5](loc1: CommitteeMember)
	48: MutBorrowLoc[6](loc2: VecMap<vector<u8>, CommitteeMember>)
	49: MoveLoc[7](loc3: &CommitteeMemberRegistration)
	50: ImmBorrowField[5](CommitteeMemberRegistration.bridge_pubkey_bytes: vector<u8>)
	51: ReadRef
	52: MoveLoc[5](loc1: CommitteeMember)
	53: Call vec_map::insert<vector<u8>, CommitteeMember>(&mut VecMap<vector<u8>, CommitteeMember>, vector<u8>, CommitteeMember)
	54: Branch(57)
B5:
	55: MoveLoc[7](loc3: &CommitteeMemberRegistration)
	56: Pop
B6:
	57: MoveLoc[4](loc0: u64)
	58: LdU64(1)
	59: Add
	60: StLoc[4](loc0: u64)
	61: Branch(6)
B7:
	62: CopyLoc[8](loc4: u64)
	63: MoveLoc[2](Arg2: u64)
	64: Ge
	65: BrFalse(84)
B8:
	66: Call vec_map::empty<address, CommitteeMemberRegistration>(): VecMap<address, CommitteeMemberRegistration>
	67: CopyLoc[0](Arg0: &mut BridgeCommittee)
	68: MutBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	69: WriteRef
	70: CopyLoc[6](loc2: VecMap<vector<u8>, CommitteeMember>)
	71: CopyLoc[0](Arg0: &mut BridgeCommittee)
	72: MutBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	73: WriteRef
	74: MoveLoc[3](Arg3: &TxContext)
	75: Call tx_context::epoch(&TxContext): u64
	76: MoveLoc[0](Arg0: &mut BridgeCommittee)
	77: MutBorrowField[7](BridgeCommittee.last_committee_update_epoch: u64)
	78: WriteRef
	79: MoveLoc[6](loc2: VecMap<vector<u8>, CommitteeMember>)
	80: MoveLoc[8](loc4: u64)
	81: Pack[2](CommitteeUpdateEvent)
	82: Call event::emit<CommitteeUpdateEvent>(CommitteeUpdateEvent)
	83: Branch(88)
B9:
	84: MoveLoc[0](Arg0: &mut BridgeCommittee)
	85: Pop
	86: MoveLoc[3](Arg3: &TxContext)
	87: Pop
B10:
	88: Ret
}

public(friend) execute_blocklist(Arg0: &mut BridgeCommittee, Arg1: Blocklist) {
L2:	loc0: bool
L3:	loc1: vector<u8>
L4:	loc2: &vector<vector<u8>>
L5:	loc3: bool
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: &mut CommitteeMember
L9:	loc7: u64
L10:	loc8: &vector<u8>
L11:	loc9: vector<vector<u8>>
L12:	loc10: &vector<u8>
B0:
	0: ImmBorrowLoc[1](Arg1: Blocklist)
	1: Call message::blocklist_type(&Blocklist): u8
	2: LdU8(1)
	3: Neq
	4: StLoc[2](loc0: bool)
	5: ImmBorrowLoc[1](Arg1: Blocklist)
	6: Call message::blocklist_validator_addresses(&Blocklist): &vector<vector<u8>>
	7: StLoc[4](loc2: &vector<vector<u8>>)
	8: CopyLoc[4](loc2: &vector<vector<u8>>)
	9: VecLen(12)
	10: StLoc[7](loc5: u64)
	11: LdU64(0)
	12: StLoc[6](loc4: u64)
	13: LdU64(0)
	14: StLoc[9](loc7: u64)
	15: LdConst[13](vector<vector<u8>>: 00)
	16: StLoc[11](loc9: vector<vector<u8>>)
B1:
	17: CopyLoc[6](loc4: u64)
	18: CopyLoc[7](loc5: u64)
	19: Lt
	20: BrFalse(87)
B2:
	21: Branch(22)
B3:
	22: CopyLoc[4](loc2: &vector<vector<u8>>)
	23: CopyLoc[6](loc4: u64)
	24: VecImmBorrow(12)
	25: StLoc[12](loc10: &vector<u8>)
	26: LdFalse
	27: StLoc[5](loc3: bool)
B4:
	28: CopyLoc[9](loc7: u64)
	29: CopyLoc[0](Arg0: &mut BridgeCommittee)
	30: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	31: Call vec_map::size<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>): u64
	32: Lt
	33: BrFalse(73)
B5:
	34: Branch(35)
B6:
	35: CopyLoc[0](Arg0: &mut BridgeCommittee)
	36: MutBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	37: CopyLoc[9](loc7: u64)
	38: Call vec_map::get_entry_by_idx_mut<vector<u8>, CommitteeMember>(&mut VecMap<vector<u8>, CommitteeMember>, u64): &vector<u8> * &mut CommitteeMember
	39: StLoc[8](loc6: &mut CommitteeMember)
	40: StLoc[10](loc8: &vector<u8>)
	41: CopyLoc[10](loc8: &vector<u8>)
	42: Call crypto::ecdsa_pub_key_to_eth_address(&vector<u8>): vector<u8>
	43: StLoc[3](loc1: vector<u8>)
	44: CopyLoc[12](loc10: &vector<u8>)
	45: ReadRef
	46: MoveLoc[3](loc1: vector<u8>)
	47: Eq
	48: BrFalse(64)
B7:
	49: MoveLoc[12](loc10: &vector<u8>)
	50: Pop
	51: CopyLoc[2](loc0: bool)
	52: MoveLoc[8](loc6: &mut CommitteeMember)
	53: MutBorrowField[1](CommitteeMember.blocklisted: bool)
	54: WriteRef
	55: MutBorrowLoc[11](loc9: vector<vector<u8>>)
	56: MoveLoc[10](loc8: &vector<u8>)
	57: ReadRef
	58: VecPushBack(12)
	59: LdTrue
	60: StLoc[5](loc3: bool)
	61: LdU64(0)
	62: StLoc[9](loc7: u64)
	63: Branch(73)
B8:
	64: MoveLoc[10](loc8: &vector<u8>)
	65: Pop
	66: MoveLoc[8](loc6: &mut CommitteeMember)
	67: Pop
	68: MoveLoc[9](loc7: u64)
	69: LdU64(1)
	70: Add
	71: StLoc[9](loc7: u64)
	72: Branch(28)
B9:
	73: MoveLoc[5](loc3: bool)
	74: BrFalse(76)
B10:
	75: Branch(82)
B11:
	76: MoveLoc[0](Arg0: &mut BridgeCommittee)
	77: Pop
	78: MoveLoc[4](loc2: &vector<vector<u8>>)
	79: Pop
	80: LdConst[4](u64: 4)
	81: Abort
B12:
	82: MoveLoc[6](loc4: u64)
	83: LdU64(1)
	84: Add
	85: StLoc[6](loc4: u64)
	86: Branch(17)
B13:
	87: MoveLoc[0](Arg0: &mut BridgeCommittee)
	88: Pop
	89: MoveLoc[4](loc2: &vector<vector<u8>>)
	90: Pop
	91: MoveLoc[2](loc0: bool)
	92: MoveLoc[11](loc9: vector<vector<u8>>)
	93: Pack[0](BlocklistValidatorEvent)
	94: Call event::emit<BlocklistValidatorEvent>(BlocklistValidatorEvent)
	95: Ret
}

public(friend) committee_members(Arg0: &BridgeCommittee): &VecMap<vector<u8>, CommitteeMember> {
B0:
	0: MoveLoc[0](Arg0: &BridgeCommittee)
	1: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	2: Ret
}

public(friend) update_node_url(Arg0: &mut BridgeCommittee, Arg1: vector<u8>, Arg2: &TxContext) {
L3:	loc0: u64
L4:	loc1: &mut CommitteeMember
B0:
	0: LdU64(0)
	1: StLoc[3](loc0: u64)
B1:
	2: CopyLoc[3](loc0: u64)
	3: CopyLoc[0](Arg0: &mut BridgeCommittee)
	4: ImmBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	5: Call vec_map::size<vector<u8>, CommitteeMember>(&VecMap<vector<u8>, CommitteeMember>): u64
	6: Lt
	7: BrFalse(44)
B2:
	8: Branch(9)
B3:
	9: CopyLoc[0](Arg0: &mut BridgeCommittee)
	10: MutBorrowField[0](BridgeCommittee.members: VecMap<vector<u8>, CommitteeMember>)
	11: CopyLoc[3](loc0: u64)
	12: Call vec_map::get_entry_by_idx_mut<vector<u8>, CommitteeMember>(&mut VecMap<vector<u8>, CommitteeMember>, u64): &vector<u8> * &mut CommitteeMember
	13: StLoc[4](loc1: &mut CommitteeMember)
	14: Pop
	15: CopyLoc[4](loc1: &mut CommitteeMember)
	16: ImmBorrowField[8](CommitteeMember.safe_address: address)
	17: ReadRef
	18: CopyLoc[2](Arg2: &TxContext)
	19: Call tx_context::sender(&TxContext): address
	20: Eq
	21: BrFalse(37)
B4:
	22: MoveLoc[0](Arg0: &mut BridgeCommittee)
	23: Pop
	24: MoveLoc[2](Arg2: &TxContext)
	25: Pop
	26: CopyLoc[1](Arg1: vector<u8>)
	27: CopyLoc[4](loc1: &mut CommitteeMember)
	28: MutBorrowField[9](CommitteeMember.http_rest_url: vector<u8>)
	29: WriteRef
	30: MoveLoc[4](loc1: &mut CommitteeMember)
	31: ImmBorrowField[10](CommitteeMember.bridge_pubkey_bytes: vector<u8>)
	32: ReadRef
	33: MoveLoc[1](Arg1: vector<u8>)
	34: Pack[3](CommitteeMemberUrlUpdateEvent)
	35: Call event::emit<CommitteeMemberUrlUpdateEvent>(CommitteeMemberUrlUpdateEvent)
	36: Ret
B5:
	37: MoveLoc[4](loc1: &mut CommitteeMember)
	38: Pop
	39: MoveLoc[3](loc0: u64)
	40: LdU64(1)
	41: Add
	42: StLoc[3](loc0: u64)
	43: Branch(2)
B6:
	44: MoveLoc[0](Arg0: &mut BridgeCommittee)
	45: Pop
	46: MoveLoc[2](Arg2: &TxContext)
	47: Pop
	48: LdConst[9](u64: 9)
	49: Abort
}

check_uniqueness_bridge_keys(Arg0: &BridgeCommittee, Arg1: vector<u8>) {
L2:	loc0: bool
L3:	loc1: u64
L4:	loc2: &CommitteeMemberRegistration
B0:
	0: CopyLoc[0](Arg0: &BridgeCommittee)
	1: ImmBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	2: Call vec_map::size<address, CommitteeMemberRegistration>(&VecMap<address, CommitteeMemberRegistration>): u64
	3: StLoc[3](loc1: u64)
	4: LdFalse
	5: StLoc[2](loc0: bool)
B1:
	6: CopyLoc[3](loc1: u64)
	7: LdU64(0)
	8: Gt
	9: BrFalse(38)
B2:
	10: Branch(11)
B3:
	11: MoveLoc[3](loc1: u64)
	12: LdU64(1)
	13: Sub
	14: StLoc[3](loc1: u64)
	15: CopyLoc[0](Arg0: &BridgeCommittee)
	16: ImmBorrowField[3](BridgeCommittee.member_registrations: VecMap<address, CommitteeMemberRegistration>)
	17: CopyLoc[3](loc1: u64)
	18: Call vec_map::get_entry_by_idx<address, CommitteeMemberRegistration>(&VecMap<address, CommitteeMemberRegistration>, u64): &address * &CommitteeMemberRegistration
	19: StLoc[4](loc2: &CommitteeMemberRegistration)
	20: Pop
	21: MoveLoc[4](loc2: &CommitteeMemberRegistration)
	22: ImmBorrowField[5](CommitteeMemberRegistration.bridge_pubkey_bytes: vector<u8>)
	23: ReadRef
	24: CopyLoc[1](Arg1: vector<u8>)
	25: Eq
	26: BrFalse(6)
B4:
	27: MoveLoc[2](loc0: bool)
	28: Not
	29: BrFalse(31)
B5:
	30: Branch(35)
B6:
	31: MoveLoc[0](Arg0: &BridgeCommittee)
	32: Pop
	33: LdConst[8](u64: 8)
	34: Abort
B7:
	35: LdTrue
	36: StLoc[2](loc0: bool)
	37: Branch(6)
B8:
	38: MoveLoc[0](Arg0: &BridgeCommittee)
	39: Pop
	40: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
	6 => u64: 6
	7 => u64: 7
	8 => u64: 8
	9 => u64: 9
	10 => vector<u8>: "SAFE_BRIDGE_MESSAGE" // interpreted as UTF8 string
	11 => u64: 33
	12 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
	13 => vector<vector<u8>>: 00
]
}

// Move bytecode v6
module b.crypto {
use 0000000000000000000000000000000000000000000000000000000000000002::ecdsa_k1;
use 0000000000000000000000000000000000000000000000000000000000000002::hash;

public(friend) ecdsa_pub_key_to_eth_address(Arg0: &vector<u8>): vector<u8> {
L1:	loc0: vector<u8>
L2:	loc1: vector<u8>
L3:	loc2: vector<u8>
L4:	loc3: vector<u8>
L5:	loc4: u64
L6:	loc5: u64
B0:
	0: MoveLoc[0](Arg0: &vector<u8>)
	1: Call ecdsa_k1::decompress_pubkey(&vector<u8>): vector<u8>
	2: StLoc[2](loc1: vector<u8>)
	3: LdU64(1)
	4: LdConst[0](vector<u8>: "" /..)
	5: StLoc[3](loc2: vector<u8>)
	6: StLoc[5](loc4: u64)
B1:
	7: CopyLoc[5](loc4: u64)
	8: LdU64(65)
	9: Lt
	10: BrFalse(23)
B2:
	11: Branch(12)
B3:
	12: MutBorrowLoc[3](loc2: vector<u8>)
	13: ImmBorrowLoc[2](loc1: vector<u8>)
	14: CopyLoc[5](loc4: u64)
	15: VecImmBorrow(4)
	16: ReadRef
	17: VecPushBack(4)
	18: MoveLoc[5](loc4: u64)
	19: LdU64(1)
	20: Add
	21: StLoc[5](loc4: u64)
	22: Branch(7)
B4:
	23: ImmBorrowLoc[3](loc2: vector<u8>)
	24: Call hash::keccak256(&vector<u8>): vector<u8>
	25: StLoc[4](loc3: vector<u8>)
	26: LdConst[0](vector<u8>: "" /..)
	27: StLoc[1](loc0: vector<u8>)
	28: LdU64(12)
	29: StLoc[6](loc5: u64)
B5:
	30: CopyLoc[6](loc5: u64)
	31: LdU64(32)
	32: Lt
	33: BrFalse(46)
B6:
	34: Branch(35)
B7:
	35: MutBorrowLoc[1](loc0: vector<u8>)
	36: ImmBorrowLoc[4](loc3: vector<u8>)
	37: CopyLoc[6](loc5: u64)
	38: VecImmBorrow(4)
	39: ReadRef
	40: VecPushBack(4)
	41: MoveLoc[6](loc5: u64)
	42: LdU64(1)
	43: Add
	44: StLoc[6](loc5: u64)
	45: Branch(30)
B8:
	46: MoveLoc[1](loc0: vector<u8>)
	47: Ret
}

Constants [
	0 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module b.limiter {
use 000000000000000000000000000000000000000000000000000000000000000b::chain_ids;
use 000000000000000000000000000000000000000000000000000000000000000b::treasury;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct TransferLimiter has store {
	transfer_limits: VecMap<BridgeRoute, u64>,
	transfer_records: VecMap<BridgeRoute, TransferRecord>
}

struct TransferRecord has store {
	hour_head: u64,
	hour_tail: u64,
	per_hour_amounts: vector<u64>,
	total_amount: u64
}

struct UpdateRouteLimitEvent has copy, drop {
	sending_chain: u8,
	receiving_chain: u8,
	new_limit: u64
}

public get_route_limit(Arg0: &TransferLimiter, Arg1: &BridgeRoute): u64 {
B0:
	0: MoveLoc[0](Arg0: &TransferLimiter)
	1: ImmBorrowField[0](TransferLimiter.transfer_limits: VecMap<BridgeRoute, u64>)
	2: MoveLoc[1](Arg1: &BridgeRoute)
	3: Call vec_map::get<BridgeRoute, u64>(&VecMap<BridgeRoute, u64>, &BridgeRoute): &u64
	4: ReadRef
	5: Ret
}

public(friend) new(): TransferLimiter {
B0:
	0: Call initial_transfer_limits(): VecMap<BridgeRoute, u64>
	1: Call vec_map::empty<BridgeRoute, TransferRecord>(): VecMap<BridgeRoute, TransferRecord>
	2: Pack[0](TransferLimiter)
	3: Ret
}

public(friend) check_and_record_sending_transfer<Ty0>(Arg0: &mut TransferLimiter, Arg1: &BridgeTreasury, Arg2: &Clock, Arg3: BridgeRoute, Arg4: u64): bool {
L5:	loc0: u64
L6:	loc1: u64
L7:	loc2: u64
L8:	loc3: u128
L9:	loc4: &mut TransferRecord
L10:	loc5: Option<u64>
L11:	loc6: u128
B0:
	0: CopyLoc[0](Arg0: &mut TransferLimiter)
	1: ImmBorrowField[1](TransferLimiter.transfer_records: VecMap<BridgeRoute, TransferRecord>)
	2: ImmBorrowLoc[3](Arg3: BridgeRoute)
	3: Call vec_map::contains<BridgeRoute, TransferRecord>(&VecMap<BridgeRoute, TransferRecord>, &BridgeRoute): bool
	4: Not
	5: BrFalse(15)
B1:
	6: CopyLoc[0](Arg0: &mut TransferLimiter)
	7: MutBorrowField[1](TransferLimiter.transfer_records: VecMap<BridgeRoute, TransferRecord>)
	8: CopyLoc[3](Arg3: BridgeRoute)
	9: LdU64(0)
	10: LdU64(0)
	11: LdConst[3](vector<u64>: 00)
	12: LdU64(0)
	13: Pack[1](TransferRecord)
	14: Call vec_map::insert<BridgeRoute, TransferRecord>(&mut VecMap<BridgeRoute, TransferRecord>, BridgeRoute, TransferRecord)
B2:
	15: CopyLoc[0](Arg0: &mut TransferLimiter)
	16: MutBorrowField[1](TransferLimiter.transfer_records: VecMap<BridgeRoute, TransferRecord>)
	17: ImmBorrowLoc[3](Arg3: BridgeRoute)
	18: Call vec_map::get_mut<BridgeRoute, TransferRecord>(&mut VecMap<BridgeRoute, TransferRecord>, &BridgeRoute): &mut TransferRecord
	19: StLoc[9](loc4: &mut TransferRecord)
	20: MoveLoc[2](Arg2: &Clock)
	21: Call current_hour_since_epoch(&Clock): u64
	22: StLoc[5](loc0: u64)
	23: CopyLoc[9](loc4: &mut TransferRecord)
	24: MoveLoc[5](loc0: u64)
	25: Call adjust_transfer_records(&mut TransferRecord, u64)
	26: MoveLoc[0](Arg0: &mut TransferLimiter)
	27: ImmBorrowField[0](TransferLimiter.transfer_limits: VecMap<BridgeRoute, u64>)
	28: ImmBorrowLoc[3](Arg3: BridgeRoute)
	29: Call vec_map::try_get<BridgeRoute, u64>(&VecMap<BridgeRoute, u64>, &BridgeRoute): Option<u64>
	30: StLoc[10](loc5: Option<u64>)
	31: ImmBorrowLoc[10](loc5: Option<u64>)
	32: Call option::is_some<u64>(&Option<u64>): bool
	33: BrFalse(35)
B3:
	34: Branch(41)
B4:
	35: MoveLoc[1](Arg1: &BridgeTreasury)
	36: Pop
	37: MoveLoc[9](loc4: &mut TransferRecord)
	38: Pop
	39: LdConst[0](u64: 0)
	40: Abort
B5:
	41: MoveLoc[10](loc5: Option<u64>)
	42: Call option::destroy_some<u64>(Option<u64>): u64
	43: CastU128
	44: CopyLoc[1](Arg1: &BridgeTreasury)
	45: Call treasury::decimal_multiplier<Ty0>(&BridgeTreasury): u64
	46: CastU128
	47: Mul
	48: StLoc[11](loc6: u128)
	49: CopyLoc[1](Arg1: &BridgeTreasury)
	50: Call treasury::notional_value<Ty0>(&BridgeTreasury): u64
	51: CastU128
	52: MoveLoc[4](Arg4: u64)
	53: CastU128
	54: Mul
	55: StLoc[8](loc3: u128)
	56: CopyLoc[9](loc4: &mut TransferRecord)
	57: ImmBorrowField[2](TransferRecord.total_amount: u64)
	58: ReadRef
	59: CastU128
	60: CopyLoc[1](Arg1: &BridgeTreasury)
	61: Call treasury::decimal_multiplier<Ty0>(&BridgeTreasury): u64
	62: CastU128
	63: Mul
	64: CopyLoc[8](loc3: u128)
	65: Add
	66: MoveLoc[11](loc6: u128)
	67: Gt
	68: BrFalse(75)
B6:
	69: MoveLoc[1](Arg1: &BridgeTreasury)
	70: Pop
	71: MoveLoc[9](loc4: &mut TransferRecord)
	72: Pop
	73: LdFalse
	74: Ret
B7:
	75: MoveLoc[8](loc3: u128)
	76: MoveLoc[1](Arg1: &BridgeTreasury)
	77: Call treasury::decimal_multiplier<Ty0>(&BridgeTreasury): u64
	78: CastU128
	79: Div
	80: CastU64
	81: StLoc[7](loc2: u64)
	82: CopyLoc[9](loc4: &mut TransferRecord)
	83: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	84: VecPopBack(1)
	85: CopyLoc[7](loc2: u64)
	86: Add
	87: StLoc[6](loc1: u64)
	88: CopyLoc[9](loc4: &mut TransferRecord)
	89: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	90: MoveLoc[6](loc1: u64)
	91: VecPushBack(1)
	92: CopyLoc[9](loc4: &mut TransferRecord)
	93: ImmBorrowField[2](TransferRecord.total_amount: u64)
	94: ReadRef
	95: MoveLoc[7](loc2: u64)
	96: Add
	97: MoveLoc[9](loc4: &mut TransferRecord)
	98: MutBorrowField[2](TransferRecord.total_amount: u64)
	99: WriteRef
	100: LdTrue
	101: Ret
}

public(friend) update_route_limit(Arg0: &mut TransferLimiter, Arg1: &BridgeRoute, Arg2: u64) {
L3:	loc0: u8
B0:
	0: CopyLoc[1](Arg1: &BridgeRoute)
	1: Call chain_ids::route_destination(&BridgeRoute): &u8
	2: ReadRef
	3: StLoc[3](loc0: u8)
	4: CopyLoc[0](Arg0: &mut TransferLimiter)
	5: ImmBorrowField[0](TransferLimiter.transfer_limits: VecMap<BridgeRoute, u64>)
	6: CopyLoc[1](Arg1: &BridgeRoute)
	7: Call vec_map::contains<BridgeRoute, u64>(&VecMap<BridgeRoute, u64>, &BridgeRoute): bool
	8: Not
	9: BrFalse(17)
B1:
	10: MoveLoc[0](Arg0: &mut TransferLimiter)
	11: MutBorrowField[0](TransferLimiter.transfer_limits: VecMap<BridgeRoute, u64>)
	12: CopyLoc[1](Arg1: &BridgeRoute)
	13: ReadRef
	14: CopyLoc[2](Arg2: u64)
	15: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	16: Branch(23)
B2:
	17: CopyLoc[2](Arg2: u64)
	18: MoveLoc[0](Arg0: &mut TransferLimiter)
	19: MutBorrowField[0](TransferLimiter.transfer_limits: VecMap<BridgeRoute, u64>)
	20: CopyLoc[1](Arg1: &BridgeRoute)
	21: Call vec_map::get_mut<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, &BridgeRoute): &mut u64
	22: WriteRef
B3:
	23: MoveLoc[1](Arg1: &BridgeRoute)
	24: Call chain_ids::route_source(&BridgeRoute): &u8
	25: ReadRef
	26: MoveLoc[3](loc0: u8)
	27: MoveLoc[2](Arg2: u64)
	28: Pack[2](UpdateRouteLimitEvent)
	29: Call event::emit<UpdateRouteLimitEvent>(UpdateRouteLimitEvent)
	30: Ret
}

current_hour_since_epoch(Arg0: &Clock): u64 {
B0:
	0: MoveLoc[0](Arg0: &Clock)
	1: Call clock::timestamp_ms(&Clock): u64
	2: LdU64(3600000)
	3: Div
	4: Ret
}

adjust_transfer_records(Arg0: &mut TransferRecord, Arg1: u64) {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut TransferRecord)
	1: ImmBorrowField[4](TransferRecord.hour_head: u64)
	2: ReadRef
	3: CopyLoc[1](Arg1: u64)
	4: Eq
	5: BrFalse(9)
B1:
	6: MoveLoc[0](Arg0: &mut TransferRecord)
	7: Pop
	8: Ret
B2:
	9: CopyLoc[1](Arg1: u64)
	10: LdU64(23)
	11: Sub
	12: StLoc[2](loc0: u64)
	13: CopyLoc[0](Arg0: &mut TransferRecord)
	14: ImmBorrowField[4](TransferRecord.hour_head: u64)
	15: ReadRef
	16: CopyLoc[2](loc0: u64)
	17: Lt
	18: BrFalse(40)
B3:
	19: LdConst[3](vector<u64>: 00)
	20: CopyLoc[0](Arg0: &mut TransferRecord)
	21: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	22: WriteRef
	23: LdU64(0)
	24: CopyLoc[0](Arg0: &mut TransferRecord)
	25: MutBorrowField[2](TransferRecord.total_amount: u64)
	26: WriteRef
	27: CopyLoc[2](loc0: u64)
	28: CopyLoc[0](Arg0: &mut TransferRecord)
	29: MutBorrowField[5](TransferRecord.hour_tail: u64)
	30: WriteRef
	31: MoveLoc[2](loc0: u64)
	32: CopyLoc[0](Arg0: &mut TransferRecord)
	33: MutBorrowField[4](TransferRecord.hour_head: u64)
	34: WriteRef
	35: CopyLoc[0](Arg0: &mut TransferRecord)
	36: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	37: LdU64(0)
	38: VecPushBack(1)
	39: Branch(66)
B4:
	40: CopyLoc[0](Arg0: &mut TransferRecord)
	41: ImmBorrowField[5](TransferRecord.hour_tail: u64)
	42: ReadRef
	43: CopyLoc[2](loc0: u64)
	44: Lt
	45: BrFalse(66)
B5:
	46: CopyLoc[0](Arg0: &mut TransferRecord)
	47: ImmBorrowField[2](TransferRecord.total_amount: u64)
	48: ReadRef
	49: CopyLoc[0](Arg0: &mut TransferRecord)
	50: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	51: LdU64(0)
	52: Call vector::remove<u64>(&mut vector<u64>, u64): u64
	53: Sub
	54: CopyLoc[0](Arg0: &mut TransferRecord)
	55: MutBorrowField[2](TransferRecord.total_amount: u64)
	56: WriteRef
	57: CopyLoc[0](Arg0: &mut TransferRecord)
	58: ImmBorrowField[5](TransferRecord.hour_tail: u64)
	59: ReadRef
	60: LdU64(1)
	61: Add
	62: CopyLoc[0](Arg0: &mut TransferRecord)
	63: MutBorrowField[5](TransferRecord.hour_tail: u64)
	64: WriteRef
	65: Branch(40)
B6:
	66: CopyLoc[0](Arg0: &mut TransferRecord)
	67: ImmBorrowField[4](TransferRecord.hour_head: u64)
	68: ReadRef
	69: CopyLoc[1](Arg1: u64)
	70: Lt
	71: BrFalse(86)
B7:
	72: Branch(73)
B8:
	73: CopyLoc[0](Arg0: &mut TransferRecord)
	74: MutBorrowField[3](TransferRecord.per_hour_amounts: vector<u64>)
	75: LdU64(0)
	76: VecPushBack(1)
	77: CopyLoc[0](Arg0: &mut TransferRecord)
	78: ImmBorrowField[4](TransferRecord.hour_head: u64)
	79: ReadRef
	80: LdU64(1)
	81: Add
	82: CopyLoc[0](Arg0: &mut TransferRecord)
	83: MutBorrowField[4](TransferRecord.hour_head: u64)
	84: WriteRef
	85: Branch(66)
B9:
	86: MoveLoc[0](Arg0: &mut TransferRecord)
	87: Pop
	88: Ret
}

initial_transfer_limits(): VecMap<BridgeRoute, u64> {
L0:	loc0: VecMap<BridgeRoute, u64>
B0:
	0: Call vec_map::empty<BridgeRoute, u64>(): VecMap<BridgeRoute, u64>
	1: StLoc[0](loc0: VecMap<BridgeRoute, u64>)
	2: MutBorrowLoc[0](loc0: VecMap<BridgeRoute, u64>)
	3: Call chain_ids::eth_mainnet(): u8
	4: Call chain_ids::safe_mainnet(): u8
	5: Call chain_ids::get_route(u8, u8): BridgeRoute
	6: LdU64(5000000)
	7: LdConst[2](u64: 1000..)
	8: Mul
	9: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	10: MutBorrowLoc[0](loc0: VecMap<BridgeRoute, u64>)
	11: Call chain_ids::eth_sepolia(): u8
	12: Call chain_ids::safe_testnet(): u8
	13: Call chain_ids::get_route(u8, u8): BridgeRoute
	14: LdConst[1](u64: 1844..)
	15: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	16: MutBorrowLoc[0](loc0: VecMap<BridgeRoute, u64>)
	17: Call chain_ids::eth_sepolia(): u8
	18: Call chain_ids::safe_custom(): u8
	19: Call chain_ids::get_route(u8, u8): BridgeRoute
	20: LdConst[1](u64: 1844..)
	21: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	22: MutBorrowLoc[0](loc0: VecMap<BridgeRoute, u64>)
	23: Call chain_ids::eth_custom(): u8
	24: Call chain_ids::safe_testnet(): u8
	25: Call chain_ids::get_route(u8, u8): BridgeRoute
	26: LdConst[1](u64: 1844..)
	27: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	28: MutBorrowLoc[0](loc0: VecMap<BridgeRoute, u64>)
	29: Call chain_ids::eth_custom(): u8
	30: Call chain_ids::safe_custom(): u8
	31: Call chain_ids::get_route(u8, u8): BridgeRoute
	32: LdConst[1](u64: 1844..)
	33: Call vec_map::insert<BridgeRoute, u64>(&mut VecMap<BridgeRoute, u64>, BridgeRoute, u64)
	34: MoveLoc[0](loc0: VecMap<BridgeRoute, u64>)
	35: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 18446744073709551615
	2 => u64: 100000000
	3 => vector<u64>: 00
]
}

// Move bytecode v6
module b.message {
use 000000000000000000000000000000000000000000000000000000000000000b::chain_ids;
use 000000000000000000000000000000000000000000000000000000000000000b::message_types;
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct BridgeMessage has copy, drop, store {
	message_type: u8,
	message_version: u8,
	seq_num: u64,
	source_chain: u8,
	payload: vector<u8>
}

struct BridgeMessageKey has copy, drop, store {
	source_chain: u8,
	message_type: u8,
	bridge_seq_num: u64
}

struct TokenTransferPayload has drop {
	sender_address: vector<u8>,
	target_chain: u8,
	target_address: vector<u8>,
	token_type: u8,
	amount: u64
}

struct EmergencyOp has drop {
	op_type: u8
}

struct Blocklist has drop {
	blocklist_type: u8,
	validator_eth_addresses: vector<vector<u8>>
}

struct UpdateBridgeLimit has drop {
	receiving_chain: u8,
	sending_chain: u8,
	limit: u64
}

struct UpdateAssetPrice has drop {
	token_id: u8,
	new_price: u64
}

struct AddTokenOnSafe has drop {
	native_token: bool,
	token_ids: vector<u8>,
	token_type_names: vector<String>,
	token_prices: vector<u64>
}

struct ParsedTokenTransferMessage has drop {
	message_version: u8,
	seq_num: u64,
	source_chain: u8,
	payload: vector<u8>,
	parsed_payload: TokenTransferPayload
}

public extract_token_bridge_payload(Arg0: &BridgeMessage): TokenTransferPayload {
L1:	loc0: vector<u8>
L2:	loc1: u64
L3:	loc2: BCS
L4:	loc3: vector<u8>
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u8
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Call bcs::new(vector<u8>): BCS
	4: StLoc[3](loc2: BCS)
	5: MutBorrowLoc[3](loc2: BCS)
	6: Call bcs::peel_vec_u8(&mut BCS): vector<u8>
	7: StLoc[4](loc3: vector<u8>)
	8: MutBorrowLoc[3](loc2: BCS)
	9: Call bcs::peel_u8(&mut BCS): u8
	10: StLoc[6](loc5: u8)
	11: MutBorrowLoc[3](loc2: BCS)
	12: Call bcs::peel_vec_u8(&mut BCS): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: MutBorrowLoc[3](loc2: BCS)
	15: Call bcs::peel_u8(&mut BCS): u8
	16: StLoc[7](loc6: u8)
	17: MutBorrowLoc[3](loc2: BCS)
	18: Call peel_u64_be(&mut BCS): u64
	19: StLoc[2](loc1: u64)
	20: CopyLoc[6](loc5: u8)
	21: Call chain_ids::assert_valid_chain_id(u8)
	22: MoveLoc[3](loc2: BCS)
	23: Call bcs::into_remainder_bytes(BCS): vector<u8>
	24: StLoc[1](loc0: vector<u8>)
	25: ImmBorrowLoc[1](loc0: vector<u8>)
	26: Call vector::is_empty<u8>(&vector<u8>): bool
	27: BrFalse(29)
B1:
	28: Branch(31)
B2:
	29: LdConst[2](u64: 0)
	30: Abort
B3:
	31: MoveLoc[4](loc3: vector<u8>)
	32: MoveLoc[6](loc5: u8)
	33: MoveLoc[5](loc4: vector<u8>)
	34: MoveLoc[7](loc6: u8)
	35: MoveLoc[2](loc1: u64)
	36: Pack[2](TokenTransferPayload)
	37: Ret
}

public extract_emergency_op_payload(Arg0: &BridgeMessage): EmergencyOp {
B0:
	0: CopyLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: VecLen(17)
	3: LdU64(1)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &BridgeMessage)
	8: Pop
	9: LdConst[2](u64: 0)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &BridgeMessage)
	12: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	13: LdU64(0)
	14: VecImmBorrow(17)
	15: ReadRef
	16: Pack[3](EmergencyOp)
	17: Ret
}

public extract_blocklist_payload(Arg0: &BridgeMessage): Blocklist {
L1:	loc0: vector<u8>
L2:	loc1: vector<u8>
L3:	loc2: u8
L4:	loc3: BCS
L5:	loc4: u8
L6:	loc5: u64
L7:	loc6: vector<vector<u8>>
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Call bcs::new(vector<u8>): BCS
	4: StLoc[4](loc3: BCS)
	5: MutBorrowLoc[4](loc3: BCS)
	6: Call bcs::peel_u8(&mut BCS): u8
	7: StLoc[5](loc4: u8)
	8: MutBorrowLoc[4](loc3: BCS)
	9: Call bcs::peel_u8(&mut BCS): u8
	10: StLoc[3](loc2: u8)
	11: CopyLoc[3](loc2: u8)
	12: LdU8(0)
	13: Neq
	14: BrFalse(16)
B1:
	15: Branch(18)
B2:
	16: LdConst[4](u64: 2)
	17: Abort
B3:
	18: LdConst[10](vector<vector<u8>>: 00)
	19: StLoc[7](loc6: vector<vector<u8>>)
B4:
	20: CopyLoc[3](loc2: u8)
	21: LdU8(0)
	22: Gt
	23: BrFalse(50)
B5:
	24: LdConst[11](vector<u8>: "" /..)
	25: LdU64(0)
	26: StLoc[6](loc5: u64)
	27: StLoc[2](loc1: vector<u8>)
	28: Branch(29)
B6:
	29: CopyLoc[6](loc5: u64)
	30: LdConst[1](u64: 20)
	31: Lt
	32: BrFalse(42)
B7:
	33: MutBorrowLoc[2](loc1: vector<u8>)
	34: MutBorrowLoc[4](loc3: BCS)
	35: Call bcs::peel_u8(&mut BCS): u8
	36: VecPushBack(17)
	37: MoveLoc[6](loc5: u64)
	38: LdU64(1)
	39: Add
	40: StLoc[6](loc5: u64)
	41: Branch(29)
B8:
	42: MutBorrowLoc[7](loc6: vector<vector<u8>>)
	43: MoveLoc[2](loc1: vector<u8>)
	44: VecPushBack(8)
	45: MoveLoc[3](loc2: u8)
	46: LdU8(1)
	47: Sub
	48: StLoc[3](loc2: u8)
	49: Branch(20)
B9:
	50: MoveLoc[4](loc3: BCS)
	51: Call bcs::into_remainder_bytes(BCS): vector<u8>
	52: StLoc[1](loc0: vector<u8>)
	53: ImmBorrowLoc[1](loc0: vector<u8>)
	54: Call vector::is_empty<u8>(&vector<u8>): bool
	55: BrFalse(57)
B10:
	56: Branch(59)
B11:
	57: LdConst[2](u64: 0)
	58: Abort
B12:
	59: MoveLoc[5](loc4: u8)
	60: MoveLoc[7](loc6: vector<vector<u8>>)
	61: Pack[4](Blocklist)
	62: Ret
}

public extract_update_bridge_limit(Arg0: &BridgeMessage): UpdateBridgeLimit {
L1:	loc0: vector<u8>
L2:	loc1: BCS
L3:	loc2: u64
L4:	loc3: u8
B0:
	0: CopyLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Call bcs::new(vector<u8>): BCS
	4: StLoc[2](loc1: BCS)
	5: MutBorrowLoc[2](loc1: BCS)
	6: Call bcs::peel_u8(&mut BCS): u8
	7: StLoc[4](loc3: u8)
	8: MutBorrowLoc[2](loc1: BCS)
	9: Call peel_u64_be(&mut BCS): u64
	10: StLoc[3](loc2: u64)
	11: CopyLoc[4](loc3: u8)
	12: Call chain_ids::assert_valid_chain_id(u8)
	13: MoveLoc[2](loc1: BCS)
	14: Call bcs::into_remainder_bytes(BCS): vector<u8>
	15: StLoc[1](loc0: vector<u8>)
	16: ImmBorrowLoc[1](loc0: vector<u8>)
	17: Call vector::is_empty<u8>(&vector<u8>): bool
	18: BrFalse(20)
B1:
	19: Branch(24)
B2:
	20: MoveLoc[0](Arg0: &BridgeMessage)
	21: Pop
	22: LdConst[2](u64: 0)
	23: Abort
B3:
	24: MoveLoc[0](Arg0: &BridgeMessage)
	25: ImmBorrowField[1](BridgeMessage.source_chain: u8)
	26: ReadRef
	27: MoveLoc[4](loc3: u8)
	28: MoveLoc[3](loc2: u64)
	29: Pack[5](UpdateBridgeLimit)
	30: Ret
}

public extract_update_asset_price(Arg0: &BridgeMessage): UpdateAssetPrice {
L1:	loc0: vector<u8>
L2:	loc1: BCS
L3:	loc2: u64
L4:	loc3: u8
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Call bcs::new(vector<u8>): BCS
	4: StLoc[2](loc1: BCS)
	5: MutBorrowLoc[2](loc1: BCS)
	6: Call bcs::peel_u8(&mut BCS): u8
	7: StLoc[4](loc3: u8)
	8: MutBorrowLoc[2](loc1: BCS)
	9: Call peel_u64_be(&mut BCS): u64
	10: StLoc[3](loc2: u64)
	11: MoveLoc[2](loc1: BCS)
	12: Call bcs::into_remainder_bytes(BCS): vector<u8>
	13: StLoc[1](loc0: vector<u8>)
	14: ImmBorrowLoc[1](loc0: vector<u8>)
	15: Call vector::is_empty<u8>(&vector<u8>): bool
	16: BrFalse(18)
B1:
	17: Branch(20)
B2:
	18: LdConst[2](u64: 0)
	19: Abort
B3:
	20: MoveLoc[4](loc3: u8)
	21: MoveLoc[3](loc2: u64)
	22: Pack[6](UpdateAssetPrice)
	23: Ret
}

public extract_add_tokens_on_safe(Arg0: &BridgeMessage): AddTokenOnSafe {
L1:	loc0: vector<u8>
L2:	loc1: BCS
L3:	loc2: u64
L4:	loc3: bool
L5:	loc4: vector<u8>
L6:	loc5: vector<u64>
L7:	loc6: vector<String>
L8:	loc7: vector<vector<u8>>
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Call bcs::new(vector<u8>): BCS
	4: StLoc[2](loc1: BCS)
	5: MutBorrowLoc[2](loc1: BCS)
	6: Call bcs::peel_bool(&mut BCS): bool
	7: StLoc[4](loc3: bool)
	8: MutBorrowLoc[2](loc1: BCS)
	9: Call bcs::peel_vec_u8(&mut BCS): vector<u8>
	10: StLoc[5](loc4: vector<u8>)
	11: MutBorrowLoc[2](loc1: BCS)
	12: Call bcs::peel_vec_vec_u8(&mut BCS): vector<vector<u8>>
	13: StLoc[8](loc7: vector<vector<u8>>)
	14: MutBorrowLoc[2](loc1: BCS)
	15: Call bcs::peel_vec_u64(&mut BCS): vector<u64>
	16: StLoc[6](loc5: vector<u64>)
	17: LdU64(0)
	18: StLoc[3](loc2: u64)
	19: VecPack(39, 0)
	20: StLoc[7](loc6: vector<String>)
B1:
	21: CopyLoc[3](loc2: u64)
	22: ImmBorrowLoc[8](loc7: vector<vector<u8>>)
	23: VecLen(8)
	24: Lt
	25: BrFalse(39)
B2:
	26: Branch(27)
B3:
	27: MutBorrowLoc[7](loc6: vector<String>)
	28: ImmBorrowLoc[8](loc7: vector<vector<u8>>)
	29: CopyLoc[3](loc2: u64)
	30: VecImmBorrow(8)
	31: ReadRef
	32: Call ascii::string(vector<u8>): String
	33: VecPushBack(39)
	34: MoveLoc[3](loc2: u64)
	35: LdU64(1)
	36: Add
	37: StLoc[3](loc2: u64)
	38: Branch(21)
B4:
	39: MoveLoc[2](loc1: BCS)
	40: Call bcs::into_remainder_bytes(BCS): vector<u8>
	41: StLoc[1](loc0: vector<u8>)
	42: ImmBorrowLoc[1](loc0: vector<u8>)
	43: Call vector::is_empty<u8>(&vector<u8>): bool
	44: BrFalse(46)
B5:
	45: Branch(48)
B6:
	46: LdConst[2](u64: 0)
	47: Abort
B7:
	48: MoveLoc[4](loc3: bool)
	49: MoveLoc[5](loc4: vector<u8>)
	50: MoveLoc[7](loc6: vector<String>)
	51: MoveLoc[6](loc5: vector<u64>)
	52: Pack[7](AddTokenOnSafe)
	53: Ret
}

public serialize_message(Arg0: BridgeMessage): vector<u8> {
L1:	loc0: vector<u8>
L2:	loc1: vector<u8>
L3:	loc2: u64
L4:	loc3: u8
B0:
	0: MoveLoc[0](Arg0: BridgeMessage)
	1: Unpack[0](BridgeMessage)
	2: StLoc[2](loc1: vector<u8>)
	3: StLoc[4](loc3: u8)
	4: StLoc[3](loc2: u64)
	5: VecPack(17, 2)
	6: StLoc[1](loc0: vector<u8>)
	7: MutBorrowLoc[1](loc0: vector<u8>)
	8: ImmBorrowLoc[3](loc2: u64)
	9: Call bcs::to_bytes<u64>(&u64): vector<u8>
	10: Call reverse_bytes(vector<u8>): vector<u8>
	11: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	12: MutBorrowLoc[1](loc0: vector<u8>)
	13: MoveLoc[4](loc3: u8)
	14: VecPushBack(17)
	15: MutBorrowLoc[1](loc0: vector<u8>)
	16: MoveLoc[2](loc1: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	18: MoveLoc[1](loc0: vector<u8>)
	19: Ret
}

public create_token_bridge_message(Arg0: u8, Arg1: u64, Arg2: vector<u8>, Arg3: u8, Arg4: vector<u8>, Arg5: u8, Arg6: u64): BridgeMessage {
L7:	loc0: vector<u8>
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: CopyLoc[3](Arg3: u8)
	3: Call chain_ids::assert_valid_chain_id(u8)
	4: LdConst[11](vector<u8>: "" /..)
	5: StLoc[7](loc0: vector<u8>)
	6: MutBorrowLoc[7](loc0: vector<u8>)
	7: ImmBorrowLoc[2](Arg2: vector<u8>)
	8: VecLen(17)
	9: CastU8
	10: VecPushBack(17)
	11: MutBorrowLoc[7](loc0: vector<u8>)
	12: MoveLoc[2](Arg2: vector<u8>)
	13: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	14: MutBorrowLoc[7](loc0: vector<u8>)
	15: MoveLoc[3](Arg3: u8)
	16: VecPushBack(17)
	17: MutBorrowLoc[7](loc0: vector<u8>)
	18: ImmBorrowLoc[4](Arg4: vector<u8>)
	19: VecLen(17)
	20: CastU8
	21: VecPushBack(17)
	22: MutBorrowLoc[7](loc0: vector<u8>)
	23: MoveLoc[4](Arg4: vector<u8>)
	24: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	25: MutBorrowLoc[7](loc0: vector<u8>)
	26: MoveLoc[5](Arg5: u8)
	27: VecPushBack(17)
	28: MutBorrowLoc[7](loc0: vector<u8>)
	29: ImmBorrowLoc[6](Arg6: u64)
	30: Call bcs::to_bytes<u64>(&u64): vector<u8>
	31: Call reverse_bytes(vector<u8>): vector<u8>
	32: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	33: ImmBorrowLoc[7](loc0: vector<u8>)
	34: VecLen(17)
	35: LdU64(64)
	36: Eq
	37: BrFalse(39)
B1:
	38: Branch(41)
B2:
	39: LdConst[7](u64: 5)
	40: Abort
B3:
	41: Call message_types::token(): u8
	42: LdConst[0](u8: 1)
	43: MoveLoc[1](Arg1: u64)
	44: MoveLoc[0](Arg0: u8)
	45: MoveLoc[7](loc0: vector<u8>)
	46: Pack[0](BridgeMessage)
	47: Ret
}

public create_emergency_op_message(Arg0: u8, Arg1: u64, Arg2: u8): BridgeMessage {
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: Call message_types::emergency_op(): u8
	3: LdConst[0](u8: 1)
	4: MoveLoc[1](Arg1: u64)
	5: MoveLoc[0](Arg0: u8)
	6: MoveLoc[2](Arg2: u8)
	7: VecPack(17, 1)
	8: Pack[0](BridgeMessage)
	9: Ret
}

public create_blocklist_message(Arg0: u8, Arg1: u64, Arg2: u8, Arg3: vector<vector<u8>>): BridgeMessage {
L4:	loc0: vector<u8>
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: vector<u8>
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: ImmBorrowLoc[3](Arg3: vector<vector<u8>>)
	3: VecLen(8)
	4: StLoc[5](loc1: u64)
	5: MoveLoc[2](Arg2: u8)
	6: CopyLoc[5](loc1: u64)
	7: CastU8
	8: VecPack(17, 2)
	9: StLoc[7](loc3: vector<u8>)
	10: LdU64(0)
	11: StLoc[6](loc2: u64)
B1:
	12: CopyLoc[6](loc2: u64)
	13: CopyLoc[5](loc1: u64)
	14: Lt
	15: BrFalse(38)
B2:
	16: Branch(17)
B3:
	17: ImmBorrowLoc[3](Arg3: vector<vector<u8>>)
	18: CopyLoc[6](loc2: u64)
	19: VecImmBorrow(8)
	20: ReadRef
	21: StLoc[4](loc0: vector<u8>)
	22: ImmBorrowLoc[4](loc0: vector<u8>)
	23: VecLen(17)
	24: LdConst[1](u64: 20)
	25: Eq
	26: BrFalse(28)
B4:
	27: Branch(30)
B5:
	28: LdConst[3](u64: 1)
	29: Abort
B6:
	30: MutBorrowLoc[7](loc3: vector<u8>)
	31: MoveLoc[4](loc0: vector<u8>)
	32: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	33: MoveLoc[6](loc2: u64)
	34: LdU64(1)
	35: Add
	36: StLoc[6](loc2: u64)
	37: Branch(12)
B7:
	38: Call message_types::committee_blocklist(): u8
	39: LdConst[0](u8: 1)
	40: MoveLoc[1](Arg1: u64)
	41: MoveLoc[0](Arg0: u8)
	42: MoveLoc[7](loc3: vector<u8>)
	43: Pack[0](BridgeMessage)
	44: Ret
}

public create_update_bridge_limit_message(Arg0: u8, Arg1: u64, Arg2: u8, Arg3: u64): BridgeMessage {
L4:	loc0: vector<u8>
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: CopyLoc[2](Arg2: u8)
	3: Call chain_ids::assert_valid_chain_id(u8)
	4: MoveLoc[2](Arg2: u8)
	5: VecPack(17, 1)
	6: StLoc[4](loc0: vector<u8>)
	7: MutBorrowLoc[4](loc0: vector<u8>)
	8: ImmBorrowLoc[3](Arg3: u64)
	9: Call bcs::to_bytes<u64>(&u64): vector<u8>
	10: Call reverse_bytes(vector<u8>): vector<u8>
	11: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	12: Call message_types::update_bridge_limit(): u8
	13: LdConst[0](u8: 1)
	14: MoveLoc[1](Arg1: u64)
	15: MoveLoc[0](Arg0: u8)
	16: MoveLoc[4](loc0: vector<u8>)
	17: Pack[0](BridgeMessage)
	18: Ret
}

public create_update_asset_price_message(Arg0: u8, Arg1: u8, Arg2: u64, Arg3: u64): BridgeMessage {
L4:	loc0: vector<u8>
B0:
	0: CopyLoc[1](Arg1: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: MoveLoc[0](Arg0: u8)
	3: VecPack(17, 1)
	4: StLoc[4](loc0: vector<u8>)
	5: MutBorrowLoc[4](loc0: vector<u8>)
	6: ImmBorrowLoc[3](Arg3: u64)
	7: Call bcs::to_bytes<u64>(&u64): vector<u8>
	8: Call reverse_bytes(vector<u8>): vector<u8>
	9: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	10: Call message_types::update_asset_price(): u8
	11: LdConst[0](u8: 1)
	12: MoveLoc[2](Arg2: u64)
	13: MoveLoc[1](Arg1: u8)
	14: MoveLoc[4](loc0: vector<u8>)
	15: Pack[0](BridgeMessage)
	16: Ret
}

public create_add_tokens_on_safe_message(Arg0: u8, Arg1: u64, Arg2: bool, Arg3: vector<u8>, Arg4: vector<String>, Arg5: vector<u64>): BridgeMessage {
L6:	loc0: vector<u8>
B0:
	0: CopyLoc[0](Arg0: u8)
	1: Call chain_ids::assert_valid_chain_id(u8)
	2: ImmBorrowLoc[2](Arg2: bool)
	3: Call bcs::to_bytes<bool>(&bool): vector<u8>
	4: StLoc[6](loc0: vector<u8>)
	5: MutBorrowLoc[6](loc0: vector<u8>)
	6: ImmBorrowLoc[3](Arg3: vector<u8>)
	7: Call bcs::to_bytes<vector<u8>>(&vector<u8>): vector<u8>
	8: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	9: MutBorrowLoc[6](loc0: vector<u8>)
	10: ImmBorrowLoc[4](Arg4: vector<String>)
	11: Call bcs::to_bytes<vector<String>>(&vector<String>): vector<u8>
	12: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	13: MutBorrowLoc[6](loc0: vector<u8>)
	14: ImmBorrowLoc[5](Arg5: vector<u64>)
	15: Call bcs::to_bytes<vector<u64>>(&vector<u64>): vector<u8>
	16: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	17: Call message_types::add_tokens_on_safe(): u8
	18: LdConst[0](u8: 1)
	19: MoveLoc[1](Arg1: u64)
	20: MoveLoc[0](Arg0: u8)
	21: MoveLoc[6](loc0: vector<u8>)
	22: Pack[0](BridgeMessage)
	23: Ret
}

public create_key(Arg0: u8, Arg1: u8, Arg2: u64): BridgeMessageKey {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: u8)
	2: MoveLoc[2](Arg2: u64)
	3: Pack[1](BridgeMessageKey)
	4: Ret
}

public key(Arg0: &BridgeMessage): BridgeMessageKey {
B0:
	0: CopyLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[1](BridgeMessage.source_chain: u8)
	2: ReadRef
	3: CopyLoc[0](Arg0: &BridgeMessage)
	4: ImmBorrowField[2](BridgeMessage.message_type: u8)
	5: ReadRef
	6: MoveLoc[0](Arg0: &BridgeMessage)
	7: ImmBorrowField[3](BridgeMessage.seq_num: u64)
	8: ReadRef
	9: Call create_key(u8, u8, u64): BridgeMessageKey
	10: Ret
}

public message_version(Arg0: &BridgeMessage): u8 {
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[4](BridgeMessage.message_version: u8)
	2: ReadRef
	3: Ret
}

public message_type(Arg0: &BridgeMessage): u8 {
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[2](BridgeMessage.message_type: u8)
	2: ReadRef
	3: Ret
}

public seq_num(Arg0: &BridgeMessage): u64 {
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[3](BridgeMessage.seq_num: u64)
	2: ReadRef
	3: Ret
}

public source_chain(Arg0: &BridgeMessage): u8 {
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[1](BridgeMessage.source_chain: u8)
	2: ReadRef
	3: Ret
}

public payload(Arg0: &BridgeMessage): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &BridgeMessage)
	1: ImmBorrowField[0](BridgeMessage.payload: vector<u8>)
	2: ReadRef
	3: Ret
}

public token_target_chain(Arg0: &TokenTransferPayload): u8 {
B0:
	0: MoveLoc[0](Arg0: &TokenTransferPayload)
	1: ImmBorrowField[5](TokenTransferPayload.target_chain: u8)
	2: ReadRef
	3: Ret
}

public token_target_address(Arg0: &TokenTransferPayload): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &TokenTransferPayload)
	1: ImmBorrowField[6](TokenTransferPayload.target_address: vector<u8>)
	2: ReadRef
	3: Ret
}

public token_type(Arg0: &TokenTransferPayload): u8 {
B0:
	0: MoveLoc[0](Arg0: &TokenTransferPayload)
	1: ImmBorrowField[7](TokenTransferPayload.token_type: u8)
	2: ReadRef
	3: Ret
}

public token_amount(Arg0: &TokenTransferPayload): u64 {
B0:
	0: MoveLoc[0](Arg0: &TokenTransferPayload)
	1: ImmBorrowField[8](TokenTransferPayload.amount: u64)
	2: ReadRef
	3: Ret
}

public emergency_op_type(Arg0: &EmergencyOp): u8 {
B0:
	0: MoveLoc[0](Arg0: &EmergencyOp)
	1: ImmBorrowField[9](EmergencyOp.op_type: u8)
	2: ReadRef
	3: Ret
}

public blocklist_type(Arg0: &Blocklist): u8 {
B0:
	0: MoveLoc[0](Arg0: &Blocklist)
	1: ImmBorrowField[10](Blocklist.blocklist_type: u8)
	2: ReadRef
	3: Ret
}

public blocklist_validator_addresses(Arg0: &Blocklist): &vector<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &Blocklist)
	1: ImmBorrowField[11](Blocklist.validator_eth_addresses: vector<vector<u8>>)
	2: Ret
}

public update_bridge_limit_payload_sending_chain(Arg0: &UpdateBridgeLimit): u8 {
B0:
	0: MoveLoc[0](Arg0: &UpdateBridgeLimit)
	1: ImmBorrowField[12](UpdateBridgeLimit.sending_chain: u8)
	2: ReadRef
	3: Ret
}

public update_bridge_limit_payload_receiving_chain(Arg0: &UpdateBridgeLimit): u8 {
B0:
	0: MoveLoc[0](Arg0: &UpdateBridgeLimit)
	1: ImmBorrowField[13](UpdateBridgeLimit.receiving_chain: u8)
	2: ReadRef
	3: Ret
}

public update_bridge_limit_payload_limit(Arg0: &UpdateBridgeLimit): u64 {
B0:
	0: MoveLoc[0](Arg0: &UpdateBridgeLimit)
	1: ImmBorrowField[14](UpdateBridgeLimit.limit: u64)
	2: ReadRef
	3: Ret
}

public update_asset_price_payload_token_id(Arg0: &UpdateAssetPrice): u8 {
B0:
	0: MoveLoc[0](Arg0: &UpdateAssetPrice)
	1: ImmBorrowField[15](UpdateAssetPrice.token_id: u8)
	2: ReadRef
	3: Ret
}

public update_asset_price_payload_new_price(Arg0: &UpdateAssetPrice): u64 {
B0:
	0: MoveLoc[0](Arg0: &UpdateAssetPrice)
	1: ImmBorrowField[16](UpdateAssetPrice.new_price: u64)
	2: ReadRef
	3: Ret
}

public is_native(Arg0: &AddTokenOnSafe): bool {
B0:
	0: MoveLoc[0](Arg0: &AddTokenOnSafe)
	1: ImmBorrowField[17](AddTokenOnSafe.native_token: bool)
	2: ReadRef
	3: Ret
}

public token_ids(Arg0: &AddTokenOnSafe): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &AddTokenOnSafe)
	1: ImmBorrowField[18](AddTokenOnSafe.token_ids: vector<u8>)
	2: ReadRef
	3: Ret
}

public token_type_names(Arg0: &AddTokenOnSafe): vector<String> {
B0:
	0: MoveLoc[0](Arg0: &AddTokenOnSafe)
	1: ImmBorrowField[19](AddTokenOnSafe.token_type_names: vector<String>)
	2: ReadRef
	3: Ret
}

public token_prices(Arg0: &AddTokenOnSafe): vector<u64> {
B0:
	0: MoveLoc[0](Arg0: &AddTokenOnSafe)
	1: ImmBorrowField[20](AddTokenOnSafe.token_prices: vector<u64>)
	2: ReadRef
	3: Ret
}

public emergency_op_pause(): u8 {
B0:
	0: LdConst[9](u8: 0)
	1: Ret
}

public emergency_op_unpause(): u8 {
B0:
	0: LdConst[0](u8: 1)
	1: Ret
}

public required_voting_power(Arg0: &BridgeMessage): u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u8
L8:	loc7: EmergencyOp
B0:
	0: CopyLoc[0](Arg0: &BridgeMessage)
	1: Call message_type(&BridgeMessage): u8
	2: StLoc[7](loc6: u8)
	3: CopyLoc[7](loc6: u8)
	4: Call message_types::token(): u8
	5: Eq
	6: BrFalse(12)
B1:
	7: MoveLoc[0](Arg0: &BridgeMessage)
	8: Pop
	9: LdU64(3334)
	10: StLoc[6](loc5: u64)
	11: Branch(82)
B2:
	12: CopyLoc[7](loc6: u8)
	13: Call message_types::emergency_op(): u8
	14: Eq
	15: BrFalse(42)
B3:
	16: MoveLoc[0](Arg0: &BridgeMessage)
	17: Call extract_emergency_op_payload(&BridgeMessage): EmergencyOp
	18: StLoc[8](loc7: EmergencyOp)
	19: ImmBorrowLoc[8](loc7: EmergencyOp)
	20: ImmBorrowField[9](EmergencyOp.op_type: u8)
	21: ReadRef
	22: LdConst[9](u8: 0)
	23: Eq
	24: BrFalse(28)
B4:
	25: LdU64(450)
	26: StLoc[1](loc0: u64)
	27: Branch(39)
B5:
	28: ImmBorrowLoc[8](loc7: EmergencyOp)
	29: ImmBorrowField[9](EmergencyOp.op_type: u8)
	30: ReadRef
	31: LdConst[0](u8: 1)
	32: Eq
	33: BrFalse(35)
B6:
	34: Branch(37)
B7:
	35: LdConst[6](u64: 4)
	36: Abort
B8:
	37: LdU64(5001)
	38: StLoc[1](loc0: u64)
B9:
	39: MoveLoc[1](loc0: u64)
	40: StLoc[5](loc4: u64)
	41: Branch(80)
B10:
	42: MoveLoc[0](Arg0: &BridgeMessage)
	43: Pop
	44: CopyLoc[7](loc6: u8)
	45: Call message_types::committee_blocklist(): u8
	46: Eq
	47: BrFalse(51)
B11:
	48: LdU64(5001)
	49: StLoc[4](loc3: u64)
	50: Branch(78)
B12:
	51: CopyLoc[7](loc6: u8)
	52: Call message_types::update_asset_price(): u8
	53: Eq
	54: BrFalse(58)
B13:
	55: LdU64(5001)
	56: StLoc[3](loc2: u64)
	57: Branch(76)
B14:
	58: CopyLoc[7](loc6: u8)
	59: Call message_types::update_bridge_limit(): u8
	60: Eq
	61: BrFalse(65)
B15:
	62: LdU64(5001)
	63: StLoc[2](loc1: u64)
	64: Branch(74)
B16:
	65: MoveLoc[7](loc6: u8)
	66: Call message_types::add_tokens_on_safe(): u8
	67: Eq
	68: BrFalse(70)
B17:
	69: Branch(72)
B18:
	70: LdConst[5](u64: 3)
	71: Abort
B19:
	72: LdU64(5001)
	73: StLoc[2](loc1: u64)
B20:
	74: MoveLoc[2](loc1: u64)
	75: StLoc[3](loc2: u64)
B21:
	76: MoveLoc[3](loc2: u64)
	77: StLoc[4](loc3: u64)
B22:
	78: MoveLoc[4](loc3: u64)
	79: StLoc[5](loc4: u64)
B23:
	80: MoveLoc[5](loc4: u64)
	81: StLoc[6](loc5: u64)
B24:
	82: MoveLoc[6](loc5: u64)
	83: Ret
}

public to_parsed_token_transfer_message(Arg0: &BridgeMessage): ParsedTokenTransferMessage {
L1:	loc0: TokenTransferPayload
B0:
	0: CopyLoc[0](Arg0: &BridgeMessage)
	1: Call message_type(&BridgeMessage): u8
	2: Call message_types::token(): u8
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &BridgeMessage)
	7: Pop
	8: LdConst[8](u64: 6)
	9: Abort
B3:
	10: CopyLoc[0](Arg0: &BridgeMessage)
	11: Call extract_token_bridge_payload(&BridgeMessage): TokenTransferPayload
	12: StLoc[1](loc0: TokenTransferPayload)
	13: CopyLoc[0](Arg0: &BridgeMessage)
	14: Call message_version(&BridgeMessage): u8
	15: CopyLoc[0](Arg0: &BridgeMessage)
	16: Call seq_num(&BridgeMessage): u64
	17: CopyLoc[0](Arg0: &BridgeMessage)
	18: Call source_chain(&BridgeMessage): u8
	19: MoveLoc[0](Arg0: &BridgeMessage)
	20: Call payload(&BridgeMessage): vector<u8>
	21: MoveLoc[1](loc0: TokenTransferPayload)
	22: Pack[8](ParsedTokenTransferMessage)
	23: Ret
}

reverse_bytes(Arg0: vector<u8>): vector<u8> {
B0:
	0: MutBorrowLoc[0](Arg0: vector<u8>)
	1: Call vector::reverse<u8>(&mut vector<u8>)
	2: MoveLoc[0](Arg0: vector<u8>)
	3: Ret
}

peel_u64_be(Arg0: &mut BCS): u64 {
L1:	loc0: u64
L2:	loc1: u8
L3:	loc2: u64
B0:
	0: LdU64(0)
	1: LdU8(64)
	2: StLoc[2](loc1: u8)
	3: StLoc[3](loc2: u64)
B1:
	4: CopyLoc[2](loc1: u8)
	5: LdU8(0)
	6: Gt
	7: BrFalse(24)
B2:
	8: Branch(9)
B3:
	9: MoveLoc[2](loc1: u8)
	10: LdU8(8)
	11: Sub
	12: StLoc[2](loc1: u8)
	13: CopyLoc[0](Arg0: &mut BCS)
	14: Call bcs::peel_u8(&mut BCS): u8
	15: CastU64
	16: StLoc[1](loc0: u64)
	17: MoveLoc[3](loc2: u64)
	18: MoveLoc[1](loc0: u64)
	19: CopyLoc[2](loc1: u8)
	20: Shl
	21: Add
	22: StLoc[3](loc2: u64)
	23: Branch(4)
B4:
	24: MoveLoc[0](Arg0: &mut BCS)
	25: Pop
	26: MoveLoc[3](loc2: u64)
	27: Ret
}

Constants [
	0 => u8: 1
	1 => u64: 20
	2 => u64: 0
	3 => u64: 1
	4 => u64: 2
	5 => u64: 3
	6 => u64: 4
	7 => u64: 5
	8 => u64: 6
	9 => u8: 0
	10 => vector<vector<u8>>: 00
	11 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module b.message_types {

public token(): u8 {
B0:
	0: LdConst[0](u8: 0)
	1: Ret
}

public committee_blocklist(): u8 {
B0:
	0: LdConst[1](u8: 1)
	1: Ret
}

public emergency_op(): u8 {
B0:
	0: LdConst[2](u8: 2)
	1: Ret
}

public update_bridge_limit(): u8 {
B0:
	0: LdConst[3](u8: 3)
	1: Ret
}

public update_asset_price(): u8 {
B0:
	0: LdConst[4](u8: 4)
	1: Ret
}

public add_tokens_on_safe(): u8 {
B0:
	0: LdConst[5](u8: 6)
	1: Ret
}

Constants [
	0 => u8: 0
	1 => u8: 1
	2 => u8: 2
	3 => u8: 3
	4 => u8: 4
	5 => u8: 6
]
}

// Move bytecode v6
module b.treasury {
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::hex;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::object_bag;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;

struct BridgeTreasury has store {
	treasuries: ObjectBag,
	supported_tokens: VecMap<TypeName, BridgeTokenMetadata>,
	id_token_type_map: VecMap<u8, TypeName>,
	waiting_room: Bag
}

struct BridgeTokenMetadata has copy, drop, store {
	id: u8,
	decimal_multiplier: u64,
	notional_value: u64,
	native_token: bool
}

struct ForeignTokenRegistration has store {
	type_name: TypeName,
	uc: UpgradeCap,
	decimal: u8
}

struct UpdateTokenPriceEvent has copy, drop {
	token_id: u8,
	new_price: u64
}

struct NewTokenEvent has copy, drop {
	token_id: u8,
	type_name: TypeName,
	native_token: bool,
	decimal_multiplier: u64,
	notional_value: u64
}

struct TokenRegistrationEvent has copy, drop {
	type_name: TypeName,
	decimal: u8,
	native_token: bool
}

public token_id<Ty0>(Arg0: &BridgeTreasury): u8 {
L1:	loc0: BridgeTokenMetadata
B0:
	0: MoveLoc[0](Arg0: &BridgeTreasury)
	1: Call get_token_metadata<Ty0>(&BridgeTreasury): BridgeTokenMetadata
	2: StLoc[1](loc0: BridgeTokenMetadata)
	3: ImmBorrowLoc[1](loc0: BridgeTokenMetadata)
	4: ImmBorrowField[0](BridgeTokenMetadata.id: u8)
	5: ReadRef
	6: Ret
}

public decimal_multiplier<Ty0>(Arg0: &BridgeTreasury): u64 {
L1:	loc0: BridgeTokenMetadata
B0:
	0: MoveLoc[0](Arg0: &BridgeTreasury)
	1: Call get_token_metadata<Ty0>(&BridgeTreasury): BridgeTokenMetadata
	2: StLoc[1](loc0: BridgeTokenMetadata)
	3: ImmBorrowLoc[1](loc0: BridgeTokenMetadata)
	4: ImmBorrowField[1](BridgeTokenMetadata.decimal_multiplier: u64)
	5: ReadRef
	6: Ret
}

public notional_value<Ty0>(Arg0: &BridgeTreasury): u64 {
L1:	loc0: BridgeTokenMetadata
B0:
	0: MoveLoc[0](Arg0: &BridgeTreasury)
	1: Call get_token_metadata<Ty0>(&BridgeTreasury): BridgeTokenMetadata
	2: StLoc[1](loc0: BridgeTokenMetadata)
	3: ImmBorrowLoc[1](loc0: BridgeTokenMetadata)
	4: ImmBorrowField[2](BridgeTokenMetadata.notional_value: u64)
	5: ReadRef
	6: Ret
}

public(friend) register_foreign_token<Ty0>(Arg0: &mut BridgeTreasury, Arg1: TreasuryCap<Ty0>, Arg2: UpgradeCap, Arg3: &CoinMetadata<Ty0>) {
L4:	loc0: ID
L5:	loc1: address
L6:	loc2: ForeignTokenRegistration
L7:	loc3: TypeName
B0:
	0: ImmBorrowLoc[1](Arg1: TreasuryCap<Ty0>)
	1: Call coin::total_supply<Ty0>(&TreasuryCap<Ty0>): u64
	2: LdU64(0)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[0](Arg0: &mut BridgeTreasury)
	7: Pop
	8: MoveLoc[3](Arg3: &CoinMetadata<Ty0>)
	9: Pop
	10: LdConst[2](u64: 3)
	11: Abort
B3:
	12: Call type_name::get<Ty0>(): TypeName
	13: StLoc[7](loc3: TypeName)
	14: ImmBorrowLoc[7](loc3: TypeName)
	15: Call type_name::get_address(&TypeName): String
	16: Call ascii::into_bytes(String): vector<u8>
	17: Call hex::decode(vector<u8>): vector<u8>
	18: Call address::from_bytes(vector<u8>): address
	19: StLoc[5](loc1: address)
	20: ImmBorrowLoc[2](Arg2: UpgradeCap)
	21: Call package::upgrade_package(&UpgradeCap): ID
	22: StLoc[4](loc0: ID)
	23: ImmBorrowLoc[4](loc0: ID)
	24: Call object::id_to_address(&ID): address
	25: MoveLoc[5](loc1: address)
	26: Eq
	27: BrFalse(29)
B4:
	28: Branch(35)
B5:
	29: MoveLoc[0](Arg0: &mut BridgeTreasury)
	30: Pop
	31: MoveLoc[3](Arg3: &CoinMetadata<Ty0>)
	32: Pop
	33: LdConst[1](u64: 2)
	34: Abort
B6:
	35: CopyLoc[7](loc3: TypeName)
	36: MoveLoc[2](Arg2: UpgradeCap)
	37: CopyLoc[3](Arg3: &CoinMetadata<Ty0>)
	38: Call coin::get_decimals<Ty0>(&CoinMetadata<Ty0>): u8
	39: Pack[2](ForeignTokenRegistration)
	40: StLoc[6](loc2: ForeignTokenRegistration)
	41: CopyLoc[0](Arg0: &mut BridgeTreasury)
	42: MutBorrowField[3](BridgeTreasury.waiting_room: Bag)
	43: CopyLoc[7](loc3: TypeName)
	44: Call type_name::into_string(TypeName): String
	45: MoveLoc[6](loc2: ForeignTokenRegistration)
	46: Call bag::add<String, ForeignTokenRegistration>(&mut Bag, String, ForeignTokenRegistration)
	47: MoveLoc[0](Arg0: &mut BridgeTreasury)
	48: MutBorrowField[4](BridgeTreasury.treasuries: ObjectBag)
	49: CopyLoc[7](loc3: TypeName)
	50: MoveLoc[1](Arg1: TreasuryCap<Ty0>)
	51: Call object_bag::add<TypeName, TreasuryCap<Ty0>>(&mut ObjectBag, TypeName, TreasuryCap<Ty0>)
	52: MoveLoc[7](loc3: TypeName)
	53: MoveLoc[3](Arg3: &CoinMetadata<Ty0>)
	54: Call coin::get_decimals<Ty0>(&CoinMetadata<Ty0>): u8
	55: LdFalse
	56: Pack[5](TokenRegistrationEvent)
	57: Call event::emit<TokenRegistrationEvent>(TokenRegistrationEvent)
	58: Ret
}

public(friend) add_new_token(Arg0: &mut BridgeTreasury, Arg1: String, Arg2: u8, Arg3: bool, Arg4: u64) {
L5:	loc0: u8
L6:	loc1: u64
L7:	loc2: TypeName
L8:	loc3: UpgradeCap
B0:
	0: CopyLoc[3](Arg3: bool)
	1: Not
	2: BrFalse(48)
B1:
	3: CopyLoc[4](Arg4: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B2:
	7: Branch(12)
B3:
	8: MoveLoc[0](Arg0: &mut BridgeTreasury)
	9: Pop
	10: LdConst[3](u64: 4)
	11: Abort
B4:
	12: CopyLoc[0](Arg0: &mut BridgeTreasury)
	13: MutBorrowField[3](BridgeTreasury.waiting_room: Bag)
	14: MoveLoc[1](Arg1: String)
	15: Call bag::remove<String, ForeignTokenRegistration>(&mut Bag, String): ForeignTokenRegistration
	16: Unpack[2](ForeignTokenRegistration)
	17: StLoc[5](loc0: u8)
	18: StLoc[8](loc3: UpgradeCap)
	19: StLoc[7](loc2: TypeName)
	20: LdU64(10)
	21: MoveLoc[5](loc0: u8)
	22: Call u64::pow(u64, u8): u64
	23: StLoc[6](loc1: u64)
	24: CopyLoc[0](Arg0: &mut BridgeTreasury)
	25: MutBorrowField[5](BridgeTreasury.supported_tokens: VecMap<TypeName, BridgeTokenMetadata>)
	26: CopyLoc[7](loc2: TypeName)
	27: CopyLoc[2](Arg2: u8)
	28: CopyLoc[6](loc1: u64)
	29: CopyLoc[4](Arg4: u64)
	30: CopyLoc[3](Arg3: bool)
	31: Pack[1](BridgeTokenMetadata)
	32: Call vec_map::insert<TypeName, BridgeTokenMetadata>(&mut VecMap<TypeName, BridgeTokenMetadata>, TypeName, BridgeTokenMetadata)
	33: MoveLoc[0](Arg0: &mut BridgeTreasury)
	34: MutBorrowField[6](BridgeTreasury.id_token_type_map: VecMap<u8, TypeName>)
	35: CopyLoc[2](Arg2: u8)
	36: CopyLoc[7](loc2: TypeName)
	37: Call vec_map::insert<u8, TypeName>(&mut VecMap<u8, TypeName>, u8, TypeName)
	38: MoveLoc[8](loc3: UpgradeCap)
	39: Call transfer::public_freeze_object<UpgradeCap>(UpgradeCap)
	40: MoveLoc[2](Arg2: u8)
	41: MoveLoc[7](loc2: TypeName)
	42: MoveLoc[3](Arg3: bool)
	43: MoveLoc[6](loc1: u64)
	44: MoveLoc[4](Arg4: u64)
	45: Pack[4](NewTokenEvent)
	46: Call event::emit<NewTokenEvent>(NewTokenEvent)
	47: Branch(50)
B5:
	48: MoveLoc[0](Arg0: &mut BridgeTreasury)
	49: Pop
B6:
	50: Ret
}

public(friend) create(Arg0: &mut TxContext): BridgeTreasury {
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object_bag::new(&mut TxContext): ObjectBag
	2: Call vec_map::empty<TypeName, BridgeTokenMetadata>(): VecMap<TypeName, BridgeTokenMetadata>
	3: Call vec_map::empty<u8, TypeName>(): VecMap<u8, TypeName>
	4: MoveLoc[0](Arg0: &mut TxContext)
	5: Call bag::new(&mut TxContext): Bag
	6: Pack[0](BridgeTreasury)
	7: Ret
}

public(friend) burn<Ty0>(Arg0: &mut BridgeTreasury, Arg1: Coin<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: &mut BridgeTreasury)
	1: MutBorrowField[4](BridgeTreasury.treasuries: ObjectBag)
	2: Call type_name::get<Ty0>(): TypeName
	3: Call object_bag::borrow_mut<TypeName, TreasuryCap<Ty0>>(&mut ObjectBag, TypeName): &mut TreasuryCap<Ty0>
	4: MoveLoc[1](Arg1: Coin<Ty0>)
	5: Call coin::burn<Ty0>(&mut TreasuryCap<Ty0>, Coin<Ty0>): u64
	6: Pop
	7: Ret
}

public(friend) mint<Ty0>(Arg0: &mut BridgeTreasury, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut BridgeTreasury)
	1: MutBorrowField[4](BridgeTreasury.treasuries: ObjectBag)
	2: Call type_name::get<Ty0>(): TypeName
	3: Call object_bag::borrow_mut<TypeName, TreasuryCap<Ty0>>(&mut ObjectBag, TypeName): &mut TreasuryCap<Ty0>
	4: MoveLoc[1](Arg1: u64)
	5: MoveLoc[2](Arg2: &mut TxContext)
	6: Call coin::mint<Ty0>(&mut TreasuryCap<Ty0>, u64, &mut TxContext): Coin<Ty0>
	7: Ret
}

public(friend) update_asset_notional_price(Arg0: &mut BridgeTreasury, Arg1: u8, Arg2: u64) {
L3:	loc0: &mut BridgeTokenMetadata
L4:	loc1: Option<TypeName>
L5:	loc2: TypeName
B0:
	0: CopyLoc[0](Arg0: &mut BridgeTreasury)
	1: ImmBorrowField[6](BridgeTreasury.id_token_type_map: VecMap<u8, TypeName>)
	2: ImmBorrowLoc[1](Arg1: u8)
	3: Call vec_map::try_get<u8, TypeName>(&VecMap<u8, TypeName>, &u8): Option<TypeName>
	4: StLoc[4](loc1: Option<TypeName>)
	5: ImmBorrowLoc[4](loc1: Option<TypeName>)
	6: Call option::is_some<TypeName>(&Option<TypeName>): bool
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut BridgeTreasury)
	10: Pop
	11: LdConst[0](u64: 1)
	12: Abort
B3:
	13: CopyLoc[2](Arg2: u64)
	14: LdU64(0)
	15: Gt
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[0](Arg0: &mut BridgeTreasury)
	19: Pop
	20: LdConst[3](u64: 4)
	21: Abort
B6:
	22: MoveLoc[4](loc1: Option<TypeName>)
	23: Call option::destroy_some<TypeName>(Option<TypeName>): TypeName
	24: StLoc[5](loc2: TypeName)
	25: MoveLoc[0](Arg0: &mut BridgeTreasury)
	26: MutBorrowField[5](BridgeTreasury.supported_tokens: VecMap<TypeName, BridgeTokenMetadata>)
	27: ImmBorrowLoc[5](loc2: TypeName)
	28: Call vec_map::get_mut<TypeName, BridgeTokenMetadata>(&mut VecMap<TypeName, BridgeTokenMetadata>, &TypeName): &mut BridgeTokenMetadata
	29: StLoc[3](loc0: &mut BridgeTokenMetadata)
	30: CopyLoc[2](Arg2: u64)
	31: MoveLoc[3](loc0: &mut BridgeTokenMetadata)
	32: MutBorrowField[2](BridgeTokenMetadata.notional_value: u64)
	33: WriteRef
	34: MoveLoc[1](Arg1: u8)
	35: MoveLoc[2](Arg2: u64)
	36: Pack[3](UpdateTokenPriceEvent)
	37: Call event::emit<UpdateTokenPriceEvent>(UpdateTokenPriceEvent)
	38: Ret
}

get_token_metadata<Ty0>(Arg0: &BridgeTreasury): BridgeTokenMetadata {
L1:	loc0: TypeName
L2:	loc1: Option<BridgeTokenMetadata>
B0:
	0: Call type_name::get<Ty0>(): TypeName
	1: StLoc[1](loc0: TypeName)
	2: MoveLoc[0](Arg0: &BridgeTreasury)
	3: ImmBorrowField[5](BridgeTreasury.supported_tokens: VecMap<TypeName, BridgeTokenMetadata>)
	4: ImmBorrowLoc[1](loc0: TypeName)
	5: Call vec_map::try_get<TypeName, BridgeTokenMetadata>(&VecMap<TypeName, BridgeTokenMetadata>, &TypeName): Option<BridgeTokenMetadata>
	6: StLoc[2](loc1: Option<BridgeTokenMetadata>)
	7: ImmBorrowLoc[2](loc1: Option<BridgeTokenMetadata>)
	8: Call option::is_some<BridgeTokenMetadata>(&Option<BridgeTokenMetadata>): bool
	9: BrFalse(11)
B1:
	10: Branch(13)
B2:
	11: LdConst[0](u64: 1)
	12: Abort
B3:
	13: MoveLoc[2](loc1: Option<BridgeTokenMetadata>)
	14: Call option::destroy_some<BridgeTokenMetadata>(Option<BridgeTokenMetadata>): BridgeTokenMetadata
	15: Ret
}

Constants [
	0 => u64: 1
	1 => u64: 2
	2 => u64: 3
	3 => u64: 4
]
}