refactoring

Signed-off-by: andreypfau <[email protected]>
ton-community · Feb 20, 2025 · 8f54a38 · 8f54a38
1 parent 98f3d7d
commit 8f54a38
Show file tree

Hide file tree

Showing 171 changed files with 1,009 additions and 1,051 deletions.
diff --git a/block-tlb/src/AccStatusChange.kt b/block-tlb/src/AccStatusChange.kt
@@ -47,26 +47,26 @@ private object AccStatusChangeTlbCombinator : TlbCombinator<AccStatusChange>(
 private object AccStatusChangeUnchangedTlbConstructor : TlbConstructor<AccStatusChange>(
     schema = "acst_unchanged\$0 = AccStatusChange;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccStatusChange) {
+    override fun storeTlb(builder: CellBuilder, value: AccStatusChange) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccStatusChange = AccStatusChange.UNCHANGED
+    override fun loadTlb(slice: CellSlice): AccStatusChange = AccStatusChange.UNCHANGED
 }
 
 private object AccStatusChangeFrozenTlbConstructor : TlbConstructor<AccStatusChange>(
     schema = "acst_frozen\$10 = AccStatusChange;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccStatusChange) {
+    override fun storeTlb(builder: CellBuilder, value: AccStatusChange) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccStatusChange = AccStatusChange.FROZEN
+    override fun loadTlb(slice: CellSlice): AccStatusChange = AccStatusChange.FROZEN
 }
 
 private object AccStatusChangeDeletedTlbConstructor : TlbConstructor<AccStatusChange>(
     schema = "acst_deleted\$11 = AccStatusChange;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccStatusChange) {
+    override fun storeTlb(builder: CellBuilder, value: AccStatusChange) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccStatusChange = AccStatusChange.DELETED
+    override fun loadTlb(slice: CellSlice): AccStatusChange = AccStatusChange.DELETED
 }
diff --git a/block-tlb/src/AccountFrozen.kt b/block-tlb/src/AccountFrozen.kt
@@ -29,16 +29,16 @@ private object AccountFrozenTlbConstructor : TlbConstructor<AccountFrozen>(
     schema = "account_frozen\$01 state_hash:bits256 = AccountState;"
 ) {
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: AccountFrozen
-    ) = cellBuilder {
-        storeBits(value.stateHash)
+    ) = builder {
+        storeBitString(value.stateHash)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): AccountFrozen = cellSlice {
-        val stateHash = loadBits(256)
+        slice: CellSlice
+    ): AccountFrozen = slice {
+        val stateHash = loadBitString(256)
         AccountFrozen(stateHash)
     }
 }
diff --git a/block-tlb/src/AccountStatus.kt b/block-tlb/src/AccountStatus.kt
@@ -52,35 +52,35 @@ private object AccountStatusTlbCombinator : TlbCombinator<AccountStatus>(
 private object AccountStatusUninitTlbConstructor : TlbConstructor<AccountStatus>(
     schema = "acc_state_uninit\$00 = AccountStatus;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccountStatus) {
+    override fun storeTlb(builder: CellBuilder, value: AccountStatus) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccountStatus = AccountStatus.UNINIT
+    override fun loadTlb(slice: CellSlice): AccountStatus = AccountStatus.UNINIT
 }
 
 private object AccountStatusFrozenTlbConstructor : TlbConstructor<AccountStatus>(
     schema = "acc_state_frozen\$01 = AccountStatus;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccountStatus) {
+    override fun storeTlb(builder: CellBuilder, value: AccountStatus) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccountStatus = AccountStatus.FROZEN
+    override fun loadTlb(slice: CellSlice): AccountStatus = AccountStatus.FROZEN
 }
 
 private object AccountStatusActiveTlbConstructor : TlbConstructor<AccountStatus>(
     schema = "acc_state_active\$10 = AccountStatus;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccountStatus) {
+    override fun storeTlb(builder: CellBuilder, value: AccountStatus) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccountStatus = AccountStatus.ACTIVE
+    override fun loadTlb(slice: CellSlice): AccountStatus = AccountStatus.ACTIVE
 }
 
 private object AccountStatusNonExistTlbConstructor : TlbConstructor<AccountStatus>(
     schema = "acc_state_nonexist\$11 = AccountStatus;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccountStatus) {
+    override fun storeTlb(builder: CellBuilder, value: AccountStatus) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccountStatus = AccountStatus.NONEXIST
+    override fun loadTlb(slice: CellSlice): AccountStatus = AccountStatus.NONEXIST
 }
diff --git a/block-tlb/src/AccountStorage.kt b/block-tlb/src/AccountStorage.kt
@@ -1,11 +1,12 @@
+@file:Suppress("DEPRECATION")
+
 package org.ton.block
 
 import kotlinx.serialization.SerialName
 import org.ton.cell.CellBuilder
 import org.ton.cell.CellSlice
 import org.ton.cell.invoke
 import org.ton.tlb.*
-import org.ton.tlb.TlbConstructor
 import org.ton.tlb.providers.TlbConstructorProvider
 import kotlin.jvm.JvmName
 
@@ -39,18 +40,18 @@ private object AccountStorageTlbConstructor : TlbConstructor<AccountStorage>(
             "balance:CurrencyCollection state:AccountState = AccountStorage;"
 ) {
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: AccountStorage
-    ) = cellBuilder {
-        storeUInt64(value.lastTransLt)
+    ) = builder {
+        storeULong(value.lastTransLt)
         storeTlb(CurrencyCollection, value.balance)
         storeTlb(AccountState, value.state)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): AccountStorage = cellSlice {
-        val lastTransLt = loadUInt64()
+        slice: CellSlice
+    ): AccountStorage = slice {
+        val lastTransLt = loadULong()
         val balance = loadTlb(CurrencyCollection)
         val state = loadTlb(AccountState)
         AccountStorage(lastTransLt, balance, state)

diff --git a/block-tlb/src/AccountUninit.kt b/block-tlb/src/AccountUninit.kt
@@ -15,10 +15,10 @@ public object AccountUninit : AccountState, TlbConstructorProvider<AccountUninit
 private object AccountUninitTlbConstructor : TlbConstructor<AccountUninit>(
     schema = "account_uninit\$00 = AccountState;"
 ) {
-    override fun storeTlb(cellBuilder: CellBuilder, value: AccountUninit) {
+    override fun storeTlb(builder: CellBuilder, value: AccountUninit) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AccountUninit {
+    override fun loadTlb(slice: CellSlice): AccountUninit {
         return AccountUninit
     }
 }
diff --git a/block-tlb/src/AddrNone.kt b/block-tlb/src/AddrNone.kt
@@ -12,12 +12,12 @@ private object AddrNoneTlbConstructor : TlbConstructor<AddrNone>(
     schema = "addr_none\$00 = MsgAddressExt;"
 ) {
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: AddrNone
     ) {
     }
 
-    override fun loadTlb(cellSlice: CellSlice): AddrNone {
+    override fun loadTlb(slice: CellSlice): AddrNone {
         return AddrNone
     }
 }
diff --git a/block-tlb/src/BinTreeFork.kt b/block-tlb/src/BinTreeFork.kt
@@ -5,7 +5,6 @@ import org.ton.cell.CellBuilder
 import org.ton.cell.CellSlice
 import org.ton.cell.invoke
 import org.ton.tlb.*
-import org.ton.tlb.TlbConstructor
 import kotlin.jvm.JvmStatic
 
 
@@ -15,8 +14,8 @@ public data class BinTreeFork<X>(
     val right: CellRef<BinTree<X>>
 ) : BinTree<X> {
     override fun nodes(): Sequence<X> = sequence {
-        yieldAll(left.value.nodes())
-        yieldAll(right.value.nodes())
+        yieldAll(left.load().nodes())
+        yieldAll(right.load().nodes())
     }
 
     override fun print(printer: TlbPrettyPrinter): TlbPrettyPrinter = printer {
@@ -46,16 +45,16 @@ private class BinTreeForkTlbConstructor<X>(
     }
 
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BinTreeFork<X>
-    ) = cellBuilder {
+    ) = builder {
         storeRef(binTree, value.left)
         storeRef(binTree, value.right)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BinTreeFork<X> = cellSlice {
+        slice: CellSlice
+    ): BinTreeFork<X> = slice {
         val left = loadRef(binTree)
         val right = loadRef(binTree)
         BinTreeFork(left, right)

diff --git a/block-tlb/src/BinTreeLeaf.kt b/block-tlb/src/BinTreeLeaf.kt
@@ -5,7 +5,6 @@ import org.ton.cell.CellBuilder
 import org.ton.cell.CellSlice
 import org.ton.cell.invoke
 import org.ton.tlb.*
-import org.ton.tlb.TlbConstructor
 import kotlin.jvm.JvmStatic
 
 
@@ -39,15 +38,15 @@ private class BinTreeTlbConstructor<X>(
     schema = "bt_leaf\$0 {X:Type} leaf:X = BinTree X;"
 ) {
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BinTreeLeaf<X>
-    ) = cellBuilder {
+    ) = builder {
         storeTlb(x, value.leaf)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BinTreeLeaf<X> = cellSlice {
+        slice: CellSlice
+    ): BinTreeLeaf<X> = slice {
         val leaf = loadTlb(x)
         BinTreeLeaf(leaf)
     }

diff --git a/block-tlb/src/BlkMasterInfo.kt b/block-tlb/src/BlkMasterInfo.kt
@@ -5,7 +5,6 @@ import org.ton.cell.CellBuilder
 import org.ton.cell.CellSlice
 import org.ton.cell.invoke
 import org.ton.tlb.*
-import org.ton.tlb.TlbConstructor
 
 @SerialName("master_info")
 
@@ -25,15 +24,15 @@ private object BlkMasterInfoTlbConstructor : TlbConstructor<BlkMasterInfo>(
     schema = "master_info\$_ master:ExtBlkRef = BlkMasterInfo;"
 ) {
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BlkMasterInfo
-    ) = cellBuilder {
+    ) = builder {
         storeTlb(ExtBlkRef, value.master)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BlkMasterInfo = cellSlice {
+        slice: CellSlice
+    ): BlkMasterInfo = slice {
         val master = loadTlb(ExtBlkRef)
         BlkMasterInfo(master)
     }

diff --git a/block-tlb/src/Block.kt b/block-tlb/src/Block.kt
@@ -5,6 +5,8 @@ import org.ton.cell.CellBuilder
 import org.ton.cell.CellSlice
 import org.ton.cell.parse
 import org.ton.kotlin.cell.CellContext
+import org.ton.kotlin.message.address.MsgAddressInt
+import org.ton.kotlin.shard.ShardState
 import org.ton.kotlin.transaction.Transaction
 import org.ton.tlb.CellRef
 import org.ton.tlb.TlbCodec

diff --git a/block-tlb/src/BlockCreateStatsExt.kt b/block-tlb/src/BlockCreateStatsExt.kt
@@ -1,3 +1,5 @@
+@file:Suppress("DEPRECATION")
+
 package org.ton.block
 
 import kotlinx.serialization.SerialName
@@ -32,15 +34,15 @@ private object BlockCreateStateExtTlbConstructor : TlbConstructor<BlockCreateSta
     val counters = HashmapAugE.tlbCodec(256, CreatorStats, UInt.tlbConstructor())
 
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BlockCreateStatsExt
-    ) = cellBuilder {
+    ) = builder {
         storeTlb(counters, value.counters)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BlockCreateStatsExt = cellSlice {
+        slice: CellSlice
+    ): BlockCreateStatsExt = slice {
         val counters = loadTlb(counters)
         BlockCreateStatsExt(counters)
     }

diff --git a/block-tlb/src/BlockCreateStatsRegular.kt b/block-tlb/src/BlockCreateStatsRegular.kt
@@ -31,15 +31,15 @@ private object BlockCreateStatsRegularTlbConstructor : TlbConstructor<BlockCreat
     val hashmapE = HashMapE.tlbCodec(256, CreatorStats)
 
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BlockCreateStatsRegular
-    ) = cellBuilder {
+    ) = builder {
         storeTlb(hashmapE, value.counters)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BlockCreateStatsRegular = cellSlice {
+        slice: CellSlice
+    ): BlockCreateStatsRegular = slice {
         val counters = loadTlb(hashmapE)
         BlockCreateStatsRegular(counters)
     }

diff --git a/block-tlb/src/BlockInfo.kt b/block-tlb/src/BlockInfo.kt
@@ -99,18 +99,18 @@ private object BlockInfoTlbConstructor : TlbConstructor<BlockInfo>(
     private val blkPrevInfoVert = CellRef.tlbCodec(BlkPrevInfo.tlbCodec(0))
 
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: BlockInfo
-    ) = cellBuilder {
+    ) = builder {
         storeUInt32(value.version)
-        storeBit(value.notMaster)
-        storeBit(value.afterMerge)
-        storeBit(value.beforeSplit)
-        storeBit(value.afterSplit)
-        storeBit(value.wantSplit)
-        storeBit(value.wantMerge)
-        storeBit(value.keyBlock)
-        storeBit(value.vertSeqnoIncr)
+        storeBoolean(value.notMaster)
+        storeBoolean(value.afterMerge)
+        storeBoolean(value.beforeSplit)
+        storeBoolean(value.afterSplit)
+        storeBoolean(value.wantSplit)
+        storeBoolean(value.wantMerge)
+        storeBoolean(value.keyBlock)
+        storeBoolean(value.vertSeqnoIncr)
         storeInt(value.flags, 8)
         storeInt(value.seqNo, 32)
         storeInt(value.vertSeqNo, 32)
@@ -135,17 +135,17 @@ private object BlockInfoTlbConstructor : TlbConstructor<BlockInfo>(
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): BlockInfo = cellSlice {
+        slice: CellSlice
+    ): BlockInfo = slice {
         val version = loadUInt32()
-        val notMaster = loadBit()
-        val afterMerge = loadBit()
-        val beforeSplit = loadBit()
-        val afterSplit = loadBit()
-        val wantSplit = loadBit()
-        val wantMerge = loadBit()
-        val keyBlock = loadBit()
-        val verSeqnoIncr = loadBit()
+        val notMaster = loadBoolean()
+        val afterMerge = loadBoolean()
+        val beforeSplit = loadBoolean()
+        val afterSplit = loadBoolean()
+        val wantSplit = loadBoolean()
+        val wantMerge = loadBoolean()
+        val keyBlock = loadBoolean()
+        val verSeqnoIncr = loadBoolean()
         val flags = loadInt(8).toInt()
         val seqNo = loadUInt32().toInt()
         val vertSeqNo = loadUInt32().toInt()

diff --git a/block-tlb/src/Certificate.kt b/block-tlb/src/Certificate.kt
@@ -24,17 +24,17 @@ private object CertificateTlbConstructor : TlbConstructor<Certificate>(
 ) {
 
     override fun storeTlb(
-        cellBuilder: CellBuilder,
+        builder: CellBuilder,
         value: Certificate
-    ) = cellBuilder {
+    ) = builder {
         storeTlb(SigPubKey, value.temp_key)
         storeUInt32(value.valid_since)
         storeUInt32(value.valid_until)
     }
 
     override fun loadTlb(
-        cellSlice: CellSlice
-    ): Certificate = cellSlice {
+        slice: CellSlice
+    ): Certificate = slice {
         val tempKey = loadTlb(SigPubKey)
         val validSince = loadUInt32()
         val validUntil = loadUInt32()