storage_pool

Module0xa9ac…bf1e

Move path: 0xfdc8…ea77::storage_pool
Functions: 4317 public, 0 entry
Structs: 3
Friend modules: system_state_inner

storage_pool

Bytecode1024 lines

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

// Move bytecode v7

module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.storage_pool {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::object_table;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::blob;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::encoding;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::messages;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::metadata;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_resource;

struct StoragePool has store, key {

id: UID,

version: u64

}

struct StoragePoolInnerV1 has store {

storage: Storage,

used_encoded_bytes: u64,

blob_count: u64,

blobs: ObjectTable<u256, PooledBlob>

}

struct PooledBlob has store, key {

id: UID,

registered_epoch: u32,

blob_id: u256,

unencoded_size: u64,

encoding_type: u8,

certified_epoch: Option<u32>,

storage_pool_id: ID,

deletable: bool

}

public start_epoch(Arg0: &StoragePool): u32 {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

4Ret

}

public end_epoch(Arg0: &StoragePool): u32 {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

4Ret

}

public reserved_encoded_capacity_bytes(Arg0: &StoragePool): u64 {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

4Ret

}

public used_encoded_bytes(Arg0: &StoragePool): u64 {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

3ReadRef

4Ret

}

public available_encoded_bytes(Arg0: &StoragePool): u64 {

L1: loc0: &StoragePoolInnerV1

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2StLoc[1](loc0: &StoragePoolInnerV1)

3CopyLoc[1](loc0: &StoragePoolInnerV1)

4ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

6MoveLoc[1](loc0: &StoragePoolInnerV1)

7ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

8ReadRef

9Sub

10Ret

}

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

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

3Ret

}

public blob_count(Arg0: &StoragePool): u64 {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[2](StoragePoolInnerV1.blob_count: u64)

3ReadRef

4Ret

}

public contains_blob(Arg0: &StoragePool, Arg1: u256): bool {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

3MoveLoc[1](Arg1: u256)

4Call object_table::contains<u256, PooledBlob>(&ObjectTable<u256, PooledBlob>, u256): bool

5Ret

}

public(friend) borrow_blob(Arg0: &StoragePool, Arg1: u256): &PooledBlob {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

3MoveLoc[1](Arg1: u256)

4Call object_table::borrow<u256, PooledBlob>(&ObjectTable<u256, PooledBlob>, u256): &PooledBlob

5Ret

}

public blob_object_id(Arg0: &StoragePool, Arg1: u256): ID {

B0:

0MoveLoc[0](Arg0: &StoragePool)

1Call inner(&StoragePool): &StoragePoolInnerV1

2ImmBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

3MoveLoc[1](Arg1: u256)

4Call object_table::borrow<u256, PooledBlob>(&ObjectTable<u256, PooledBlob>, u256): &PooledBlob

5Call object::id<PooledBlob>(&PooledBlob): ID

6Ret

}

public(friend) create(Arg0: Storage, Arg1: &mut TxContext): StoragePool {

L2: loc0: StoragePool

B0:

0CopyLoc[1](Arg1: &mut TxContext)

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

2LdConst[1](u64: 1)

3Pack[0](StoragePool)

4StLoc[2](loc0: StoragePool)

5MutBorrowLoc[2](loc0: StoragePool)

6MutBorrowField[4](StoragePool.id: UID)

7LdConst[1](u64: 1)

8MoveLoc[0](Arg0: Storage)

9LdU64(0)

10LdU64(0)

11MoveLoc[1](Arg1: &mut TxContext)

12Call object_table::new<u256, PooledBlob>(&mut TxContext): ObjectTable<u256, PooledBlob>

13Pack[1](StoragePoolInnerV1)

14Call dynamic_field::add<u64, StoragePoolInnerV1>(&mut UID, u64, StoragePoolInnerV1)

15MoveLoc[2](loc0: StoragePool)

16Ret

}

inner(Arg0: &StoragePool): &StoragePoolInnerV1 {

B0:

0CopyLoc[0](Arg0: &StoragePool)

1ImmBorrowField[5](StoragePool.version: u64)

2ReadRef

3LdConst[1](u64: 1)

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &StoragePool)

8Pop

9LdConst[10](u64: 10)

10Abort

B3:

11CopyLoc[0](Arg0: &StoragePool)

12ImmBorrowField[4](StoragePool.id: UID)

13MoveLoc[0](Arg0: &StoragePool)

14ImmBorrowField[5](StoragePool.version: u64)

15ReadRef

16Call dynamic_field::borrow<u64, StoragePoolInnerV1>(&UID, u64): &StoragePoolInnerV1

17Ret

}

inner_mut(Arg0: &mut StoragePool): &mut StoragePoolInnerV1 {

B0:

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

1ImmBorrowField[5](StoragePool.version: u64)

2ReadRef

3LdConst[1](u64: 1)

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9LdConst[10](u64: 10)

10Abort

B3:

11CopyLoc[0](Arg0: &mut StoragePool)

12MutBorrowField[4](StoragePool.id: UID)

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

14ImmBorrowField[5](StoragePool.version: u64)

15ReadRef

16Call dynamic_field::borrow_mut<u64, StoragePoolInnerV1>(&mut UID, u64): &mut StoragePoolInnerV1

17Ret

}

public object_id(Arg0: &StoragePool): ID {

B0:

0MoveLoc[0](Arg0: &StoragePool)

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

2Ret

}

public(friend) extend_end_epoch(Arg0: &mut StoragePool, Arg1: u32) {

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2MutBorrowField[0](StoragePoolInnerV1.storage: Storage)

3MoveLoc[1](Arg1: u32)

4Call storage_resource::extend_end_epoch(&mut Storage, u32)

5Ret

}

public(friend) increase_reserved_encoded_capacity(Arg0: &mut StoragePool, Arg1: u64) {

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2MutBorrowField[0](StoragePoolInnerV1.storage: Storage)

3MoveLoc[1](Arg1: u64)

4Call storage_resource::increase_size(&mut Storage, u64)

5Ret

}

public(friend) add_blob(Arg0: &mut StoragePool, Arg1: PooledBlob, Arg2: u64) {

L3: loc0: &mut StoragePoolInnerV1

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2StLoc[3](loc0: &mut StoragePoolInnerV1)

3CopyLoc[3](loc0: &mut StoragePoolInnerV1)

4ImmBorrowField[2](StoragePoolInnerV1.blob_count: u64)

5ReadRef

6LdU64(1)

7Add

8CopyLoc[3](loc0: &mut StoragePoolInnerV1)

9MutBorrowField[2](StoragePoolInnerV1.blob_count: u64)

10WriteRef

11CopyLoc[3](loc0: &mut StoragePoolInnerV1)

12ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

13ReadRef

14MoveLoc[2](Arg2: u64)

15Add

16CopyLoc[3](loc0: &mut StoragePoolInnerV1)

17MutBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

18WriteRef

19CopyLoc[3](loc0: &mut StoragePoolInnerV1)

20ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

21ReadRef

22CopyLoc[3](loc0: &mut StoragePoolInnerV1)

23ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

25Le

26BrFalse(28)

B1:

27Branch(32)

B2:

28MoveLoc[3](loc0: &mut StoragePoolInnerV1)

29Pop

30LdConst[6](u64: 6)

31Abort

B3:

32MoveLoc[3](loc0: &mut StoragePoolInnerV1)

33MutBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

34ImmBorrowLoc[1](Arg1: PooledBlob)

35ImmBorrowField[6](PooledBlob.blob_id: u256)

36ReadRef

37MoveLoc[1](Arg1: PooledBlob)

38Call object_table::add<u256, PooledBlob>(&mut ObjectTable<u256, PooledBlob>, u256, PooledBlob)

39Ret

}

public(friend) remove_blob(Arg0: &mut StoragePool, Arg1: u256, Arg2: u16): PooledBlob {

L3: loc0: &PooledBlob

L4: loc1: u64

L5: loc2: &mut StoragePoolInnerV1

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2StLoc[5](loc2: &mut StoragePoolInnerV1)

3CopyLoc[5](loc2: &mut StoragePoolInnerV1)

4ImmBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

5CopyLoc[1](Arg1: u256)

6Call object_table::borrow<u256, PooledBlob>(&ObjectTable<u256, PooledBlob>, u256): &PooledBlob

7StLoc[3](loc0: &PooledBlob)

8CopyLoc[3](loc0: &PooledBlob)

9ImmBorrowField[7](PooledBlob.unencoded_size: u64)

10ReadRef

11MoveLoc[3](loc0: &PooledBlob)

12ImmBorrowField[8](PooledBlob.encoding_type: u8)

13ReadRef

14MoveLoc[2](Arg2: u16)

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

16StLoc[4](loc1: u64)

17CopyLoc[5](loc2: &mut StoragePoolInnerV1)

18ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

19ReadRef

20CopyLoc[4](loc1: u64)

21Ge

22BrFalse(24)

B1:

23Branch(28)

B2:

24MoveLoc[5](loc2: &mut StoragePoolInnerV1)

25Pop

26LdConst[8](u64: 8)

27Abort

B3:

28CopyLoc[5](loc2: &mut StoragePoolInnerV1)

29ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

30ReadRef

31MoveLoc[4](loc1: u64)

32Sub

33CopyLoc[5](loc2: &mut StoragePoolInnerV1)

34MutBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

35WriteRef

36CopyLoc[5](loc2: &mut StoragePoolInnerV1)

37ImmBorrowField[2](StoragePoolInnerV1.blob_count: u64)

38ReadRef

39LdU64(1)

40Ge

41BrFalse(43)

B4:

42Branch(47)

B5:

43MoveLoc[5](loc2: &mut StoragePoolInnerV1)

44Pop

45LdConst[9](u64: 9)

46Abort

B6:

47CopyLoc[5](loc2: &mut StoragePoolInnerV1)

48ImmBorrowField[2](StoragePoolInnerV1.blob_count: u64)

49ReadRef

50LdU64(1)

51Sub

52CopyLoc[5](loc2: &mut StoragePoolInnerV1)

53MutBorrowField[2](StoragePoolInnerV1.blob_count: u64)

54WriteRef

55MoveLoc[5](loc2: &mut StoragePoolInnerV1)

56MutBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

57MoveLoc[1](Arg1: u256)

58Call object_table::remove<u256, PooledBlob>(&mut ObjectTable<u256, PooledBlob>, u256): PooledBlob

59Ret

}

public(friend) borrow_blob_mut(Arg0: &mut StoragePool, Arg1: u256): &mut PooledBlob {

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2MutBorrowField[3](StoragePoolInnerV1.blobs: ObjectTable<u256, PooledBlob>)

3MoveLoc[1](Arg1: u256)

4Call object_table::borrow_mut<u256, PooledBlob>(&mut ObjectTable<u256, PooledBlob>, u256): &mut PooledBlob

5Ret

}

public(friend) increase_capacity_with_storage(Arg0: &mut StoragePool, Arg1: Storage, Arg2: u32) {

L3: loc0: &mut StoragePoolInnerV1

B0:

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

1Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

2StLoc[3](loc0: &mut StoragePoolInnerV1)

3ImmBorrowLoc[1](Arg1: Storage)

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

5MoveLoc[2](Arg2: u32)

6Le

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[3](loc0: &mut StoragePoolInnerV1)

10Pop

11LdConst[1](u64: 1)

12Abort

B3:

13ImmBorrowLoc[1](Arg1: Storage)

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

15CopyLoc[3](loc0: &mut StoragePoolInnerV1)

16ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

18Eq

19BrFalse(21)

B4:

20Branch(25)

B5:

21MoveLoc[3](loc0: &mut StoragePoolInnerV1)

22Pop

23LdConst[11](u64: 11)

24Abort

B6:

25MoveLoc[3](loc0: &mut StoragePoolInnerV1)

26MutBorrowField[0](StoragePoolInnerV1.storage: Storage)

27ImmBorrowLoc[1](Arg1: Storage)

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

29Call storage_resource::increase_size(&mut Storage, u64)

30MoveLoc[1](Arg1: Storage)

31Call storage_resource::destroy(Storage)

32Ret

}

public(friend) decrease_capacity_by_size(Arg0: &mut StoragePool, Arg1: u64, Arg2: &mut TxContext): Option<Storage> {

L3: loc0: &mut StoragePoolInnerV1

L4: loc1: u64

B0:

0CopyLoc[1](Arg1: u64)

1LdU64(0)

2Eq

3BrFalse(10)

B1:

4MoveLoc[0](Arg0: &mut StoragePool)

5Pop

6MoveLoc[2](Arg2: &mut TxContext)

7Pop

8Call option::none<Storage>(): Option<Storage>

9Ret

B2:

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

11Call inner_mut(&mut StoragePool): &mut StoragePoolInnerV1

12StLoc[3](loc0: &mut StoragePoolInnerV1)

13CopyLoc[3](loc0: &mut StoragePoolInnerV1)

14ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

16CopyLoc[3](loc0: &mut StoragePoolInnerV1)

17ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

18ReadRef

19Sub

20CopyLoc[1](Arg1: u64)

21Ge

22BrFalse(24)

B3:

23Branch(30)

B4:

24MoveLoc[3](loc0: &mut StoragePoolInnerV1)

25Pop

26MoveLoc[2](Arg2: &mut TxContext)

27Pop

28LdConst[6](u64: 6)

29Abort

B5:

30CopyLoc[3](loc0: &mut StoragePoolInnerV1)

31ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

33MoveLoc[1](Arg1: u64)

34Sub

35StLoc[4](loc1: u64)

36MoveLoc[3](loc0: &mut StoragePoolInnerV1)

37MutBorrowField[0](StoragePoolInnerV1.storage: Storage)

38MoveLoc[4](loc1: u64)

39MoveLoc[2](Arg2: &mut TxContext)

40Call storage_resource::split_by_size(&mut Storage, u64, &mut TxContext): Storage

41Call option::some<Storage>(Storage): Option<Storage>

42Ret

}

public(friend) decrease_unused_capacity_by_percent(Arg0: &mut StoragePool, Arg1: u8, Arg2: &mut TxContext): Option<Storage> {

L3: loc0: u64

L4: loc1: &StoragePoolInnerV1

B0:

0CopyLoc[1](Arg1: u8)

1LdU8(100)

2Le

3BrFalse(5)

B1:

4Branch(11)

B2:

5MoveLoc[0](Arg0: &mut StoragePool)

6Pop

7MoveLoc[2](Arg2: &mut TxContext)

8Pop

9LdConst[14](u64: 14)

10Abort

B3:

11CopyLoc[0](Arg0: &mut StoragePool)

12FreezeRef

13Call inner(&StoragePool): &StoragePoolInnerV1

14StLoc[4](loc1: &StoragePoolInnerV1)

15CopyLoc[4](loc1: &StoragePoolInnerV1)

16ImmBorrowField[0](StoragePoolInnerV1.storage: Storage)

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

18MoveLoc[4](loc1: &StoragePoolInnerV1)

19ImmBorrowField[1](StoragePoolInnerV1.used_encoded_bytes: u64)

20ReadRef

21Sub

22CastU128

23MoveLoc[1](Arg1: u8)

24CastU128

25Mul

26LdU128(100)

27Div

28CastU64

29StLoc[3](loc0: u64)

30MoveLoc[0](Arg0: &mut StoragePool)

31MoveLoc[3](loc0: u64)

32MoveLoc[2](Arg2: &mut TxContext)

33Call decrease_capacity_by_size(&mut StoragePool, u64, &mut TxContext): Option<Storage>

34Ret

}

public destroy(Arg0: StoragePool): Storage {

L1: loc0: u64

L2: loc1: ObjectTable<u256, PooledBlob>

L3: loc2: UID

L4: loc3: Storage

L5: loc4: u64

B0:

0MoveLoc[0](Arg0: StoragePool)

1Unpack[0](StoragePool)

2StLoc[5](loc4: u64)

3StLoc[3](loc2: UID)

4MutBorrowLoc[3](loc2: UID)

5MoveLoc[5](loc4: u64)

6Call dynamic_field::remove<u64, StoragePoolInnerV1>(&mut UID, u64): StoragePoolInnerV1

7Unpack[1](StoragePoolInnerV1)

8StLoc[2](loc1: ObjectTable<u256, PooledBlob>)

9StLoc[1](loc0: u64)

10Pop

11StLoc[4](loc3: Storage)

12MoveLoc[1](loc0: u64)

13LdU64(0)

14Eq

15BrFalse(17)

B1:

16Branch(19)

B2:

17LdConst[7](u64: 7)

18Abort

B3:

19MoveLoc[2](loc1: ObjectTable<u256, PooledBlob>)

20Call object_table::destroy_empty<u256, PooledBlob>(ObjectTable<u256, PooledBlob>)

21MoveLoc[3](loc2: UID)

22Call object::delete(UID)

23MoveLoc[4](loc3: Storage)

24Ret

}

public(friend) new_pooled_blob(Arg0: ID, Arg1: u256, Arg2: u256, Arg3: u64, Arg4: u8, Arg5: bool, Arg6: u32, Arg7: &mut TxContext): PooledBlob {

L8: loc0: UID

B0:

0MoveLoc[2](Arg2: u256)

1CopyLoc[4](Arg4: u8)

2CopyLoc[3](Arg3: u64)

3Call blob::derive_blob_id(u256, u8, u64): u256

4CopyLoc[1](Arg1: u256)

5Eq

6BrFalse(8)

B1:

7Branch(12)

B2:

8MoveLoc[7](Arg7: &mut TxContext)

9Pop

10LdConst[3](u64: 3)

11Abort

B3:

12MoveLoc[7](Arg7: &mut TxContext)

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

14StLoc[8](loc0: UID)

15CopyLoc[6](Arg6: u32)

16CopyLoc[1](Arg1: u256)

17CopyLoc[3](Arg3: u64)

18CopyLoc[4](Arg4: u8)

19CopyLoc[5](Arg5: bool)

20ImmBorrowLoc[8](loc0: UID)

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

22CopyLoc[0](Arg0: ID)

23Call events::emit_pooled_blob_registered(u32, u256, u64, u8, bool, ID, ID)

24MoveLoc[8](loc0: UID)

25MoveLoc[6](Arg6: u32)

26MoveLoc[1](Arg1: u256)

27MoveLoc[3](Arg3: u64)

28MoveLoc[4](Arg4: u8)

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

30MoveLoc[0](Arg0: ID)

31MoveLoc[5](Arg5: bool)

32Pack[2](PooledBlob)

33Ret

}

public(friend) certify(Arg0: &mut PooledBlob, Arg1: u32, Arg2: u32, Arg3: CertifiedBlobMessage) {

L4: loc0: BlobPersistenceType

L5: loc1: bool

L6: loc2: BlobPersistenceType

B0:

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

1ImmBorrowField[6](PooledBlob.blob_id: u256)

2ReadRef

3ImmBorrowLoc[3](Arg3: CertifiedBlobMessage)

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

5Eq

6BrFalse(8)

B1:

7Branch(12)

B2:

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

9Pop

10LdConst[3](u64: 3)

11Abort

B3:

12CopyLoc[1](Arg1: u32)

13MoveLoc[2](Arg2: u32)

14Lt

15BrFalse(17)

B4:

16Branch(21)

B5:

17MoveLoc[0](Arg0: &mut PooledBlob)

18Pop

19LdConst[1](u64: 1)

20Abort

B6:

21CopyLoc[0](Arg0: &mut PooledBlob)

22ImmBorrowField[9](PooledBlob.certified_epoch: Option<u32>)

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

24Not

25BrFalse(27)

B7:

26Branch(31)

B8:

27MoveLoc[0](Arg0: &mut PooledBlob)

28Pop

29LdConst[2](u64: 2)

30Abort

B9:

31CopyLoc[1](Arg1: u32)

32Call option::some<u32>(u32): Option<u32>

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

34MutBorrowField[9](PooledBlob.certified_epoch: Option<u32>)

35WriteRef

36CopyLoc[0](Arg0: &mut PooledBlob)

37ImmBorrowField[10](PooledBlob.deletable: bool)

38ReadRef

39StLoc[5](loc1: bool)

40ImmBorrowLoc[3](Arg3: CertifiedBlobMessage)

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

42StLoc[4](loc0: BlobPersistenceType)

43MoveLoc[5](loc1: bool)

44ImmBorrowLoc[4](loc0: BlobPersistenceType)

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

46Eq

47BrFalse(49)

B10:

48Branch(53)

B11:

49MoveLoc[0](Arg0: &mut PooledBlob)

50Pop

51LdConst[4](u64: 4)

52Abort

B12:

53CopyLoc[0](Arg0: &mut PooledBlob)

54ImmBorrowField[10](PooledBlob.deletable: bool)

55ReadRef

56BrFalse(72)

B13:

57ImmBorrowLoc[3](Arg3: CertifiedBlobMessage)

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

59StLoc[6](loc2: BlobPersistenceType)

60ImmBorrowLoc[6](loc2: BlobPersistenceType)

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

62CopyLoc[0](Arg0: &mut PooledBlob)

63FreezeRef

64Call object::id<PooledBlob>(&PooledBlob): ID

65Eq

66BrFalse(68)

B14:

67Branch(72)

B15:

68MoveLoc[0](Arg0: &mut PooledBlob)

69Pop

70LdConst[5](u64: 5)

71Abort

B16:

72MoveLoc[1](Arg1: u32)

73CopyLoc[0](Arg0: &mut PooledBlob)

74ImmBorrowField[6](PooledBlob.blob_id: u256)

75ReadRef

76CopyLoc[0](Arg0: &mut PooledBlob)

77ImmBorrowField[10](PooledBlob.deletable: bool)

78ReadRef

79CopyLoc[0](Arg0: &mut PooledBlob)

80ImmBorrowField[11](PooledBlob.id: UID)

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

82MoveLoc[0](Arg0: &mut PooledBlob)

83ImmBorrowField[12](PooledBlob.storage_pool_id: ID)

84ReadRef

85Call events::emit_pooled_blob_certified(u32, u256, bool, ID, ID)

86Ret

}

public(friend) delete_blob_object(Arg0: PooledBlob, Arg1: u32) {

L2: loc0: u256

L3: loc1: Option<u32>

L4: loc2: bool

L5: loc3: UID

L6: loc4: ID

L7: loc5: ID

B0:

0MutBorrowLoc[0](Arg0: PooledBlob)

1MutBorrowField[11](PooledBlob.id: UID)

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

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

4Pop

5MoveLoc[0](Arg0: PooledBlob)

6Unpack[2](PooledBlob)

7StLoc[4](loc2: bool)

8StLoc[7](loc5: ID)

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[0](u64: 0)

19Abort

B3:

20ImmBorrowLoc[5](loc3: UID)

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

22StLoc[6](loc4: ID)

23MoveLoc[5](loc3: UID)

24Call object::delete(UID)

25MoveLoc[1](Arg1: u32)

26MoveLoc[2](loc0: u256)

27MoveLoc[6](loc4: ID)

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

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

30MoveLoc[7](loc5: ID)

31Call events::emit_pooled_blob_deleted(u32, u256, ID, bool, ID)

32Ret

}

public(friend) burn_blob_object(Arg0: PooledBlob) {

B0:

0MutBorrowLoc[0](Arg0: PooledBlob)

1MutBorrowField[11](PooledBlob.id: UID)

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

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

4Pop

5MoveLoc[0](Arg0: PooledBlob)

6Unpack[2](PooledBlob)

7Pop

8Pop

9Pop

10Pop

11Pop

12Pop

13Pop

14Call object::delete(UID)

15Ret

}

public(friend) is_deletable(Arg0: &PooledBlob): bool {

B0:

0MoveLoc[0](Arg0: &PooledBlob)

1ImmBorrowField[10](PooledBlob.deletable: bool)

2ReadRef

3Ret

}

public(friend) is_certified(Arg0: &PooledBlob): bool {

B0:

0MoveLoc[0](Arg0: &PooledBlob)

1ImmBorrowField[9](PooledBlob.certified_epoch: Option<u32>)

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

3Ret

}

add_metadata(Arg0: &mut PooledBlob, Arg1: Metadata) {

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4Not

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9LdConst[12](u64: 12)

10Abort

B3:

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

12MutBorrowField[11](PooledBlob.id: UID)

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

14MoveLoc[1](Arg1: Metadata)

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

16Ret

}

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

L2: loc0: Option<Metadata>

L3: loc1: Option<Metadata>

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4BrFalse(10)

B1:

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

6Call take_metadata(&mut PooledBlob): 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 PooledBlob)

15MoveLoc[1](Arg1: Metadata)

16Call add_metadata(&mut PooledBlob, Metadata)

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

18Ret

}

take_metadata(Arg0: &mut PooledBlob): Metadata {

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[13](u64: 13)

9Abort

B3:

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

11MutBorrowField[11](PooledBlob.id: UID)

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

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

14Ret

}

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

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[13](u64: 13)

9Abort

B3:

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

11MutBorrowField[11](PooledBlob.id: UID)

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

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

14Ret

}

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

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4Not

5BrFalse(9)

B1:

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

7Call metadata::new(): Metadata

8Call add_metadata(&mut PooledBlob, Metadata)

B2:

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

10MutBorrowField[11](PooledBlob.id: UID)

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

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

13Ret

}

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

B0:

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

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

2MoveLoc[1](Arg1: String)

3MoveLoc[2](Arg2: String)

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

5Ret

}

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

B0:

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

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

2MoveLoc[1](Arg1: &String)

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

4Ret

}

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

L2: loc0: Option<String>

B0:

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

1ImmBorrowField[11](PooledBlob.id: UID)

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

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

4Not

5BrFalse(13)

B1:

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

7Pop

8MoveLoc[1](Arg1: &String)

9Pop

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

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

12Branch(18)

B2:

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

14Call metadata(&mut PooledBlob): &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

}

public add_blob_metadata(Arg0: &mut StoragePool, Arg1: u256, Arg2: Metadata) {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3MoveLoc[2](Arg2: Metadata)

4Call add_metadata(&mut PooledBlob, Metadata)

5Ret

}

public add_or_replace_blob_metadata(Arg0: &mut StoragePool, Arg1: u256, Arg2: Metadata): Option<Metadata> {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3MoveLoc[2](Arg2: Metadata)

4Call add_or_replace_metadata(&mut PooledBlob, Metadata): Option<Metadata>

5Ret

}

public take_blob_metadata(Arg0: &mut StoragePool, Arg1: u256): Metadata {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3Call take_metadata(&mut PooledBlob): Metadata

4Ret

}

public insert_or_update_blob_metadata_pair(Arg0: &mut StoragePool, Arg1: u256, Arg2: String, Arg3: String) {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3MoveLoc[2](Arg2: String)

4MoveLoc[3](Arg3: String)

5Call insert_or_update_metadata_pair(&mut PooledBlob, String, String)

6Ret

}

public remove_blob_metadata_pair(Arg0: &mut StoragePool, Arg1: u256, Arg2: &String): String * String {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3MoveLoc[2](Arg2: &String)

4Call remove_metadata_pair(&mut PooledBlob, &String): String * String

5Ret

}

public remove_blob_metadata_pair_if_exists(Arg0: &mut StoragePool, Arg1: u256, Arg2: &String): Option<String> {

B0:

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

1MoveLoc[1](Arg1: u256)

2Call borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

3MoveLoc[2](Arg2: &String)

4Call remove_metadata_pair_if_exists(&mut PooledBlob, &String): Option<String>

5Ret

}

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 => u64: 10

11 => u64: 11

12 => u64: 12

13 => u64: 13

14 => u64: 14

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

]

}