blob

Module0xfa65…814e

Move path: 0xfdc8…ea77::blob
Functions: 2718 public, 0 entry
Structs: 2
Friend modules: system_state_inner

blob

Bytecode665 lines

The on-chain disassembly. Offsets are instruction numbers within each function.

// Move bytecode v7

module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.blob {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000002::bcs;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::hash;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::encoding;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::messages;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::metadata;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_resource;

struct Blob has store, key {

id: UID,

registered_epoch: u32,

blob_id: u256,

size: u64,

encoding_type: u8,

certified_epoch: Option<u32>,

storage: Storage,

deletable: bool

}

struct BlobIdDerivation has drop {

encoding_type: u8,

size: u64,

root_hash: u256

}

public object_id(Arg0: &Blob): ID {

B0:

0MoveLoc[0](Arg0: &Blob)

1Call object::id<Blob>(&Blob): ID

2Ret

}

public registered_epoch(Arg0: &Blob): u32 {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[0](Blob.registered_epoch: u32)

2ReadRef

3Ret

}

public blob_id(Arg0: &Blob): u256 {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[1](Blob.blob_id: u256)

2ReadRef

3Ret

}

public size(Arg0: &Blob): u64 {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[2](Blob.size: u64)

2ReadRef

3Ret

}

public encoding_type(Arg0: &Blob): u8 {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[3](Blob.encoding_type: u8)

2ReadRef

3Ret

}

public certified_epoch(Arg0: &Blob): &Option<u32> {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[4](Blob.certified_epoch: Option<u32>)

2Ret

}

public storage(Arg0: &Blob): &Storage {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[5](Blob.storage: Storage)

2Ret

}

public is_deletable(Arg0: &Blob): bool {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[6](Blob.deletable: bool)

2ReadRef

3Ret

}

public encoded_size(Arg0: &Blob, Arg1: u16): u64 {

B0:

0CopyLoc[0](Arg0: &Blob)

1ImmBorrowField[2](Blob.size: u64)

2ReadRef

3MoveLoc[0](Arg0: &Blob)

4ImmBorrowField[3](Blob.encoding_type: u8)

5ReadRef

6MoveLoc[1](Arg1: u16)

7Call encoding::encoded_blob_length(u64, u8, u16): u64

8Ret

}

public(friend) storage_mut(Arg0: &mut Blob): &mut Storage {

B0:

0MoveLoc[0](Arg0: &mut Blob)

1MutBorrowField[5](Blob.storage: Storage)

2Ret

}

public end_epoch(Arg0: &Blob): u32 {

B0:

0MoveLoc[0](Arg0: &Blob)

1ImmBorrowField[5](Blob.storage: Storage)

2Call storage_resource::end_epoch(&Storage): u32

3Ret

}

public(friend) assert_certified_not_expired(Arg0: &Blob, Arg1: u32) {

B0:

0CopyLoc[0](Arg0: &Blob)

1ImmBorrowField[4](Blob.certified_epoch: Option<u32>)

2Call option::is_some<u32>(&Option<u32>): bool

3BrFalse(5)

B1:

4Branch(9)

B2:

5MoveLoc[0](Arg0: &Blob)

6Pop

7LdConst[0](u64: 0)

8Abort

B3:

9MoveLoc[1](Arg1: u32)

10MoveLoc[0](Arg0: &Blob)

11ImmBorrowField[5](Blob.storage: Storage)

12Call storage_resource::end_epoch(&Storage): u32

13Lt

14BrFalse(16)

B4:

15Branch(18)

B5:

16LdConst[2](u64: 2)

17Abort

B6:

18Ret

}

public derive_blob_id(Arg0: u256, Arg1: u8, Arg2: u64): u256 {

L3: loc0: BlobIdDerivation

L4: loc1: BCS

L5: loc2: vector<u8>

B0:

0MoveLoc[1](Arg1: u8)

1MoveLoc[2](Arg2: u64)

2MoveLoc[0](Arg0: u256)

3Pack[1](BlobIdDerivation)

4StLoc[3](loc0: BlobIdDerivation)

5ImmBorrowLoc[3](loc0: BlobIdDerivation)

6Call bcs::to_bytes<BlobIdDerivation>(&BlobIdDerivation): vector<u8>

7StLoc[5](loc2: vector<u8>)

8ImmBorrowLoc[5](loc2: vector<u8>)

9Call hash::blake2b256(&vector<u8>): vector<u8>

10Call bcs::new(vector<u8>): BCS

11StLoc[4](loc1: BCS)

12MutBorrowLoc[4](loc1: BCS)

13Call bcs::peel_u256(&mut BCS): u256

14Ret

}

public(friend) new(Arg0: Storage, Arg1: u256, Arg2: u256, Arg3: u64, Arg4: u8, Arg5: bool, Arg6: u32, Arg7: u16, Arg8: &mut TxContext): Blob {

L9: loc0: UID

B0:

0MoveLoc[8](Arg8: &mut TxContext)

1Call object::new(&mut TxContext): UID

2StLoc[9](loc0: UID)

3CopyLoc[6](Arg6: u32)

4ImmBorrowLoc[0](Arg0: Storage)

5Call storage_resource::start_epoch(&Storage): u32

6Ge

7BrFalse(9)

B1:

8Branch(11)

B2:

9LdConst[2](u64: 2)

10Abort

B3:

11CopyLoc[6](Arg6: u32)

12ImmBorrowLoc[0](Arg0: Storage)

13Call storage_resource::end_epoch(&Storage): u32

14Lt

15BrFalse(17)

B4:

16Branch(19)

B5:

17LdConst[2](u64: 2)

18Abort

B6:

19CopyLoc[3](Arg3: u64)

20CopyLoc[4](Arg4: u8)

21MoveLoc[7](Arg7: u16)

22Call encoding::encoded_blob_length(u64, u8, u16): u64

23ImmBorrowLoc[0](Arg0: Storage)

24Call storage_resource::size(&Storage): u64

25Le

26BrFalse(28)

B7:

27Branch(30)

B8:

28LdConst[3](u64: 3)

29Abort

B9:

30MoveLoc[2](Arg2: u256)

31CopyLoc[4](Arg4: u8)

32CopyLoc[3](Arg3: u64)

33Call derive_blob_id(u256, u8, u64): u256

34CopyLoc[1](Arg1: u256)

35Eq

36BrFalse(38)

B10:

37Branch(40)

B11:

38LdConst[5](u64: 6)

39Abort

B12:

40CopyLoc[6](Arg6: u32)

41CopyLoc[1](Arg1: u256)

42CopyLoc[3](Arg3: u64)

43CopyLoc[4](Arg4: u8)

44ImmBorrowLoc[0](Arg0: Storage)

45Call storage_resource::end_epoch(&Storage): u32

46CopyLoc[5](Arg5: bool)

47ImmBorrowLoc[9](loc0: UID)

48Call object::uid_to_inner(&UID): ID

49Call events::emit_blob_registered(u32, u256, u64, u8, u32, bool, ID)

50MoveLoc[9](loc0: UID)

51MoveLoc[6](Arg6: u32)

52MoveLoc[1](Arg1: u256)

53MoveLoc[3](Arg3: u64)

54MoveLoc[4](Arg4: u8)

55Call option::none<u32>(): Option<u32>

56MoveLoc[0](Arg0: Storage)

57MoveLoc[5](Arg5: bool)

58Pack[0](Blob)

59Ret

}

public(friend) certify_with_certified_msg(Arg0: &mut Blob, Arg1: u32, Arg2: CertifiedBlobMessage) {

L3: loc0: BlobPersistenceType

L4: loc1: bool

L5: loc2: BlobPersistenceType

B0:

0CopyLoc[0](Arg0: &mut Blob)

1FreezeRef

2Call blob_id(&Blob): u256

3ImmBorrowLoc[2](Arg2: CertifiedBlobMessage)

4Call messages::certified_blob_id(&CertifiedBlobMessage): u256

5Eq

6BrFalse(8)

B1:

7Branch(12)

B2:

8MoveLoc[0](Arg0: &mut Blob)

9Pop

10LdConst[5](u64: 6)

11Abort

B3:

12CopyLoc[0](Arg0: &mut Blob)

13ImmBorrowField[4](Blob.certified_epoch: Option<u32>)

14Call option::is_some<u32>(&Option<u32>): bool

15Not

16BrFalse(18)

B4:

17Branch(22)

B5:

18MoveLoc[0](Arg0: &mut Blob)

19Pop

20LdConst[4](u64: 5)

21Abort

B6:

22CopyLoc[1](Arg1: u32)

23CopyLoc[0](Arg0: &mut Blob)

24ImmBorrowField[5](Blob.storage: Storage)

25Call storage_resource::end_epoch(&Storage): u32

26Lt

27BrFalse(29)

B7:

28Branch(33)

B8:

29MoveLoc[0](Arg0: &mut Blob)

30Pop

31LdConst[2](u64: 2)

32Abort

B9:

33CopyLoc[0](Arg0: &mut Blob)

34ImmBorrowField[6](Blob.deletable: bool)

35ReadRef

36StLoc[4](loc1: bool)

37ImmBorrowLoc[2](Arg2: CertifiedBlobMessage)

38Call messages::blob_persistence_type(&CertifiedBlobMessage): BlobPersistenceType

39StLoc[3](loc0: BlobPersistenceType)

40MoveLoc[4](loc1: bool)

41ImmBorrowLoc[3](loc0: BlobPersistenceType)

42Call messages::is_deletable(&BlobPersistenceType): bool

43Eq

44BrFalse(46)

B10:

45Branch(50)

B11:

46MoveLoc[0](Arg0: &mut Blob)

47Pop

48LdConst[8](u64: 9)

49Abort

B12:

50CopyLoc[0](Arg0: &mut Blob)

51ImmBorrowField[6](Blob.deletable: bool)

52ReadRef

53BrFalse(69)

B13:

54ImmBorrowLoc[2](Arg2: CertifiedBlobMessage)

55Call messages::blob_persistence_type(&CertifiedBlobMessage): BlobPersistenceType

56StLoc[5](loc2: BlobPersistenceType)

57ImmBorrowLoc[5](loc2: BlobPersistenceType)

58Call messages::object_id(&BlobPersistenceType): ID

59CopyLoc[0](Arg0: &mut Blob)

60FreezeRef

61Call object::id<Blob>(&Blob): ID

62Eq

63BrFalse(65)

B14:

64Branch(69)

B15:

65MoveLoc[0](Arg0: &mut Blob)

66Pop

67LdConst[9](u64: 10)

68Abort

B16:

69CopyLoc[0](Arg0: &mut Blob)

70MutBorrowField[4](Blob.certified_epoch: Option<u32>)

71MoveLoc[1](Arg1: u32)

72Call option::fill<u32>(&mut Option<u32>, u32)

73MoveLoc[0](Arg0: &mut Blob)

74FreezeRef

75LdFalse

76Call emit_certified(&Blob, bool)

77Ret

}

public(friend) delete(Arg0: Blob, Arg1: u32): Storage {

L2: loc0: u256

L3: loc1: Option<u32>

L4: loc2: bool

L5: loc3: UID

L6: loc4: ID

L7: loc5: Storage

B0:

0MutBorrowLoc[0](Arg0: Blob)

1MutBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::remove_opt<vector<u8>, Metadata>(&mut UID, vector<u8>): Option<Metadata>

4Pop

5MoveLoc[0](Arg0: Blob)

6Unpack[0](Blob)

7StLoc[4](loc2: bool)

8StLoc[7](loc5: Storage)

9StLoc[3](loc1: Option<u32>)

10Pop

11Pop

12StLoc[2](loc0: u256)

13Pop

14StLoc[5](loc3: UID)

15MoveLoc[4](loc2: bool)

16BrFalse(18)

B1:

17Branch(20)

B2:

18LdConst[1](u64: 1)

19Abort

B3:

20ImmBorrowLoc[7](loc5: Storage)

21Call storage_resource::end_epoch(&Storage): u32

22CopyLoc[1](Arg1: u32)

23Gt

24BrFalse(26)

B4:

25Branch(28)

B5:

26LdConst[2](u64: 2)

27Abort

B6:

28ImmBorrowLoc[5](loc3: UID)

29Call object::uid_to_inner(&UID): ID

30StLoc[6](loc4: ID)

31MoveLoc[5](loc3: UID)

32Call object::delete(UID)

33MoveLoc[1](Arg1: u32)

34MoveLoc[2](loc0: u256)

35ImmBorrowLoc[7](loc5: Storage)

36Call storage_resource::end_epoch(&Storage): u32

37MoveLoc[6](loc4: ID)

38ImmBorrowLoc[3](loc1: Option<u32>)

39Call option::is_some<u32>(&Option<u32>): bool

40Call events::emit_blob_deleted(u32, u256, u32, ID, bool)

41MoveLoc[7](loc5: Storage)

42Ret

}

public burn(Arg0: Blob) {

L1: loc0: Storage

B0:

0MutBorrowLoc[0](Arg0: Blob)

1MutBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::remove_opt<vector<u8>, Metadata>(&mut UID, vector<u8>): Option<Metadata>

4Pop

5MoveLoc[0](Arg0: Blob)

6Unpack[0](Blob)

7Pop

8StLoc[1](loc0: Storage)

9Pop

10Pop

11Pop

12Pop

13Pop

14Call object::delete(UID)

15MoveLoc[1](loc0: Storage)

16Call storage_resource::destroy(Storage)

17Ret

}

public(friend) extend_with_resource(Arg0: &mut Blob, Arg1: Storage, Arg2: u32) {

B0:

0CopyLoc[0](Arg0: &mut Blob)

1FreezeRef

2MoveLoc[2](Arg2: u32)

3Call assert_certified_not_expired(&Blob, u32)

4ImmBorrowLoc[1](Arg1: Storage)

5Call storage_resource::end_epoch(&Storage): u32

6CopyLoc[0](Arg0: &mut Blob)

7ImmBorrowField[5](Blob.storage: Storage)

8Call storage_resource::end_epoch(&Storage): u32

9Gt

10BrFalse(12)

B1:

11Branch(16)

B2:

12MoveLoc[0](Arg0: &mut Blob)

13Pop

14LdConst[2](u64: 2)

15Abort

B3:

16CopyLoc[0](Arg0: &mut Blob)

17MutBorrowField[5](Blob.storage: Storage)

18MoveLoc[1](Arg1: Storage)

19Call storage_resource::fuse_periods(&mut Storage, Storage)

20MoveLoc[0](Arg0: &mut Blob)

21FreezeRef

22LdTrue

23Call emit_certified(&Blob, bool)

24Ret

}

public(friend) emit_certified(Arg0: &Blob, Arg1: bool) {

B0:

0CopyLoc[0](Arg0: &Blob)

1ImmBorrowField[4](Blob.certified_epoch: Option<u32>)

2Call option::borrow<u32>(&Option<u32>): &u32

3ReadRef

4CopyLoc[0](Arg0: &Blob)

5ImmBorrowField[1](Blob.blob_id: u256)

6ReadRef

7CopyLoc[0](Arg0: &Blob)

8ImmBorrowField[5](Blob.storage: Storage)

9Call storage_resource::end_epoch(&Storage): u32

10CopyLoc[0](Arg0: &Blob)

11ImmBorrowField[6](Blob.deletable: bool)

12ReadRef

13MoveLoc[0](Arg0: &Blob)

14ImmBorrowField[7](Blob.id: UID)

15Call object::uid_to_inner(&UID): ID

16MoveLoc[1](Arg1: bool)

17Call events::emit_blob_certified(u32, u256, u32, bool, ID, bool)

18Ret

}

public add_metadata(Arg0: &mut Blob, Arg1: Metadata) {

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4Not

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut Blob)

8Pop

9LdConst[6](u64: 7)

10Abort

B3:

11MoveLoc[0](Arg0: &mut Blob)

12MutBorrowField[7](Blob.id: UID)

13LdConst[10](vector<u8>: "met..)

14MoveLoc[1](Arg1: Metadata)

15Call dynamic_field::add<vector<u8>, Metadata>(&mut UID, vector<u8>, Metadata)

16Ret

}

public add_or_replace_metadata(Arg0: &mut Blob, Arg1: Metadata): Option<Metadata> {

L2: loc0: Option<Metadata>

L3: loc1: Option<Metadata>

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4BrFalse(10)

B1:

5CopyLoc[0](Arg0: &mut Blob)

6Call take_metadata(&mut Blob): Metadata

7Call option::some<Metadata>(Metadata): Option<Metadata>

8StLoc[2](loc0: Option<Metadata>)

9Branch(12)

B2:

10Call option::none<Metadata>(): Option<Metadata>

11StLoc[2](loc0: Option<Metadata>)

B3:

12MoveLoc[2](loc0: Option<Metadata>)

13StLoc[3](loc1: Option<Metadata>)

14MoveLoc[0](Arg0: &mut Blob)

15MoveLoc[1](Arg1: Metadata)

16Call add_metadata(&mut Blob, Metadata)

17MoveLoc[3](loc1: Option<Metadata>)

18Ret

}

public take_metadata(Arg0: &mut Blob): Metadata {

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut Blob)

7Pop

8LdConst[7](u64: 8)

9Abort

B3:

10MoveLoc[0](Arg0: &mut Blob)

11MutBorrowField[7](Blob.id: UID)

12LdConst[10](vector<u8>: "met..)

13Call dynamic_field::remove<vector<u8>, Metadata>(&mut UID, vector<u8>): Metadata

14Ret

}

metadata(Arg0: &mut Blob): &mut Metadata {

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut Blob)

7Pop

8LdConst[7](u64: 8)

9Abort

B3:

10MoveLoc[0](Arg0: &mut Blob)

11MutBorrowField[7](Blob.id: UID)

12LdConst[10](vector<u8>: "met..)

13Call dynamic_field::borrow_mut<vector<u8>, Metadata>(&mut UID, vector<u8>): &mut Metadata

14Ret

}

metadata_or_create(Arg0: &mut Blob): &mut Metadata {

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4Not

5BrFalse(9)

B1:

6CopyLoc[0](Arg0: &mut Blob)

7Call metadata::new(): Metadata

8Call add_metadata(&mut Blob, Metadata)

B2:

9MoveLoc[0](Arg0: &mut Blob)

10MutBorrowField[7](Blob.id: UID)

11LdConst[10](vector<u8>: "met..)

12Call dynamic_field::borrow_mut<vector<u8>, Metadata>(&mut UID, vector<u8>): &mut Metadata

13Ret

}

public insert_or_update_metadata_pair(Arg0: &mut Blob, Arg1: String, Arg2: String) {

B0:

0MoveLoc[0](Arg0: &mut Blob)

1Call metadata_or_create(&mut Blob): &mut Metadata

2MoveLoc[1](Arg1: String)

3MoveLoc[2](Arg2: String)

4Call metadata::insert_or_update(&mut Metadata, String, String)

5Ret

}

public remove_metadata_pair(Arg0: &mut Blob, Arg1: &String): String * String {

B0:

0MoveLoc[0](Arg0: &mut Blob)

1Call metadata(&mut Blob): &mut Metadata

2MoveLoc[1](Arg1: &String)

3Call metadata::remove(&mut Metadata, &String): String * String

4Ret

}

public remove_metadata_pair_if_exists(Arg0: &mut Blob, Arg1: &String): Option<String> {

L2: loc0: Option<String>

B0:

0CopyLoc[0](Arg0: &mut Blob)

1ImmBorrowField[7](Blob.id: UID)

2LdConst[10](vector<u8>: "met..)

3Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool

4Not

5BrFalse(13)

B1:

6MoveLoc[0](Arg0: &mut Blob)

7Pop

8MoveLoc[1](Arg1: &String)

9Pop

10Call option::none<String>(): Option<String>

11StLoc[2](loc0: Option<String>)

12Branch(18)

B2:

13MoveLoc[0](Arg0: &mut Blob)

14Call metadata(&mut Blob): &mut Metadata

15MoveLoc[1](Arg1: &String)

16Call metadata::remove_if_exists(&mut Metadata, &String): Option<String>

17StLoc[2](loc0: Option<String>)

B3:

18MoveLoc[2](loc0: Option<String>)

19Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 5

5 => u64: 6

6 => u64: 7

7 => u64: 8

8 => u64: 9

9 => u64: 10

10 => vector<u8>: "metadata" // interpreted as UTF8 string

]

}