Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

composable_url

Module0x34a2…c82c
Move path
0xbc3d…e5f9::composable_url
Functions
1010 public, 0 entry
Structs
2
Friend modules
None
composable_url

Bytecode155 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v6
module bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9.composable_url {
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::attributes;
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::url;
use 859eb18bd5b5e8cc32deb6dfb1c39941008ab3c6e27f0b8ce2364be7102bb7cb::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::url as 0url;
 
struct ComposableUrl has store {
url: Url
}
 
struct Witness has drop {
dummy_field: bool
}
 
public new(): ComposableUrl {
B0:
0LdConst[2](vector<u8>: "" /..)
1Call 0url::new_unsafe_from_bytes(vector<u8>): Url
2Pack[0](ComposableUrl)
3Ret
}
 
public set_url<Ty0>(Arg0: &mut ComposableUrl, Arg1: Url) {
B0:
0MoveLoc[1](Arg1: Url)
1MoveLoc[0](Arg0: &mut ComposableUrl)
2MutBorrowField[0](ComposableUrl.url: Url)
3WriteRef
4Ret
}
 
public regenerate(Arg0: &mut UID) {
L1: loc0: vector<u8>
L2: loc1: vector<u8>
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call url::borrow_domain(&UID): &Url
3Call 0url::inner_url(&Url): String
4Call ascii::into_bytes(String): vector<u8>
5StLoc[2](loc1: vector<u8>)
6CopyLoc[0](Arg0: &mut UID)
7FreezeRef
8Call attributes::has_domain(&UID): bool
9BrFalse(19)
B1:
10MoveLoc[0](Arg0: &mut UID)
11FreezeRef
12Call attributes::borrow_domain(&UID): &Attributes
13Call attributes::as_url_parameters(&Attributes): vector<u8>
14StLoc[1](loc0: vector<u8>)
15MutBorrowLoc[2](loc1: vector<u8>)
16MoveLoc[1](loc0: vector<u8>)
17Call vector::append<u8>(&mut vector<u8>, vector<u8>)
18Branch(21)
B2:
19MoveLoc[0](Arg0: &mut UID)
20Pop
B3:
21Ret
}
 
public has_domain(Arg0: &UID): bool {
B0:
0MoveLoc[0](Arg0: &UID)
1Call utils::marker<ComposableUrl>(): Marker<ComposableUrl>
2Call dynamic_field::exists_with_type<Marker<ComposableUrl>, ComposableUrl>(&UID, Marker<ComposableUrl>): bool
3Ret
}
 
public borrow_domain(Arg0: &UID): &ComposableUrl {
B0:
0CopyLoc[0](Arg0: &UID)
1Call assert_composable_url(&UID)
2MoveLoc[0](Arg0: &UID)
3Call utils::marker<ComposableUrl>(): Marker<ComposableUrl>
4Call dynamic_field::borrow<Marker<ComposableUrl>, ComposableUrl>(&UID, Marker<ComposableUrl>): &ComposableUrl
5Ret
}
 
public borrow_domain_mut(Arg0: &mut UID): &mut ComposableUrl {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_composable_url(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<ComposableUrl>(): Marker<ComposableUrl>
5Call dynamic_field::borrow_mut<Marker<ComposableUrl>, ComposableUrl>(&mut UID, Marker<ComposableUrl>): &mut ComposableUrl
6Ret
}
 
public add_domain(Arg0: &mut UID, Arg1: ComposableUrl) {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_no_composable_url(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<ComposableUrl>(): Marker<ComposableUrl>
5MoveLoc[1](Arg1: ComposableUrl)
6Call dynamic_field::add<Marker<ComposableUrl>, ComposableUrl>(&mut UID, Marker<ComposableUrl>, ComposableUrl)
7Ret
}
 
public remove_domain(Arg0: &mut UID): ComposableUrl {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_composable_url(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<ComposableUrl>(): Marker<ComposableUrl>
5Call dynamic_field::remove<Marker<ComposableUrl>, ComposableUrl>(&mut UID, Marker<ComposableUrl>): ComposableUrl
6Ret
}
 
public assert_composable_url(Arg0: &UID) {
B0:
0MoveLoc[0](Arg0: &UID)
1Call has_domain(&UID): bool
2BrFalse(4)
B1:
3Branch(6)
B2:
4LdConst[0](u64: 1)
5Abort
B3:
6Ret
}
 
public assert_no_composable_url(Arg0: &UID) {
B0:
0MoveLoc[0](Arg0: &UID)
1Call has_domain(&UID): bool
2Not
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[1](u64: 2)
6Abort
B3:
7Ret
}
 
Constants [
0 => u64: 1
1 => u64: 2
2 => vector<u8>: "" // interpreted as UTF8 string
]
}