Pruned resolver

boc/cell.go

@@ -436,5 +436,37 @@ func (c *Cell) GetMerkleRoot() ([32]byte, error) {
  var hash [32]byte
  copy(hash[:], bytes[1:])
  return hash, nil
+}
+
+// TODO: move to deserializer
+func (c *Cell) isValidMerkleProofCell() bool {
+ return c.cellType == MerkleProofCell && c.RefsSize() == 1 && c.BitSize() == 280
+}
+
+func (c *Cell) CalculateMerkleProofMeta() (int, [32]byte, error) {
+ if !c.isValidMerkleProofCell() {
+ return 0, [32]byte{}, errors.New("not valid merkle proof cell")
+ }
+ imc, err := newImmutableCell(c.Refs()[0], map[*Cell]*immutableCell{})
+ if err != nil {
+ return 0, [32]byte{}, fmt.Errorf("get immutable cell: %w", err)
+ }
+ h := imc.Hash(0)
+ var hash [32]byte
+ copy(hash[:], h)
+ depth := imc.Depth(0)
+ return depth, hash, nil
+}
 
+// TODO: or add level as optional parameter to Hash256()
+func (c *Cell) Hash256WithLevel(level int) ([32]byte, error) {
+ // TODO: or check for pruned cell and read hash directly from cell
+ imc, err := newImmutableCell(c, map[*Cell]*immutableCell{})
+ if err != nil {
+ return [32]byte{}, err
+ }
+ b := imc.Hash(level)
+ var h [32]byte
+ copy(h[:], b)
+ return h, nil
 }

liteapi/account.go

@@ -0,0 +1,143 @@
+package liteapi
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "github.com/tonkeeper/tongo/boc"
+ "github.com/tonkeeper/tongo/tlb"
+ "github.com/tonkeeper/tongo/ton"
+)
+
+// GetAccountWithProof
+// For safe operation, always use GetAccountWithProof with WithBlock(proofedBlock ton.BlockIDExt), as the proof of masterchain cashed blocks is not implemented yet!
+func (c *Client) GetAccountWithProof(ctx context.Context, accountID ton.AccountID) (*tlb.ShardAccount, *tlb.ShardStateUnsplit, error) {
+ res, err := c.GetAccountStateRaw(ctx, accountID) // TODO: add proof check for masterHead
+ if err != nil {
+ return nil, nil, err
+ }
+ blockID := res.Id.ToBlockIdExt()
+ if len(res.Proof) == 0 {
+ return nil, nil, errors.New("empty proof")
+ }
+
+ var blockHash ton.Bits256
+ if (accountID.Workchain == -1 && blockID.Workchain == -1) || blockID == res.Shardblk.ToBlockIdExt() {
+ blockHash = blockID.RootHash
+ } else {
+ if len(res.ShardProof) == 0 {
+ return nil, nil, errors.New("empty shard proof")
+ }
+ if res.Shardblk.RootHash == [32]byte{} { // TODO: how to check for empty shard?
+ return nil, nil, errors.New("shard block not passed")
+ }
+ shardHash := ton.Bits256(res.Shardblk.RootHash)
+ if err := checkShardInMasterProof(blockID, res.ShardProof, accountID.Workchain, shardHash); err != nil {
+ return nil, nil, fmt.Errorf("shard proof is incorrect: %w", err)
+ }
+ blockHash = shardHash
+ }
+ cellsMap := make(map[[32]byte]*boc.Cell)
+ if len(res.State) > 0 {
+ stateCells, err := boc.DeserializeBoc(res.State)
+ if err != nil {
+ return nil, nil, fmt.Errorf("state deserialization failed: %w", err)
+ }
+ hash, err := stateCells[0].Hash256()
+ if err != nil {
+ return nil, nil, fmt.Errorf("get hash err: %w", err)
+ }
+ cellsMap[hash] = stateCells[0]
+ }
+ shardState, err := checkBlockShardStateProof(res.Proof, blockHash, cellsMap)
+ if err != nil {
+ return nil, nil, fmt.Errorf("incorrect block proof: %w", err)
+ }
+ values := shardState.ShardStateUnsplit.Accounts.Values()
+ keys := shardState.ShardStateUnsplit.Accounts.Keys()
+ for i, k := range keys {
+ if k == accountID.Address {
+ return &values[i], shardState, nil
+ }
+ }
+ if len(res.State) == 0 {
+ return &tlb.ShardAccount{Account: tlb.Account{SumType: "AccountNone"}}, shardState, nil
+ }
+ return nil, nil, errors.New("invalid account state")
+}
+
+func checkShardInMasterProof(master ton.BlockIDExt, shardProof []byte, workchain int32, shardRootHash ton.Bits256) error {
+ shardState, err := checkBlockShardStateProof(shardProof, master.RootHash, nil)
+ if err != nil {
+ return fmt.Errorf("check block proof failed: %w", err)
+ }
+ if !shardState.ShardStateUnsplit.Custom.Exists {
+ return fmt.Errorf("not a masterchain block")
+ }
+ stateExtra := shardState.ShardStateUnsplit.Custom.Value.Value
+ keys := stateExtra.ShardHashes.Keys()
+ values := stateExtra.ShardHashes.Values()
+ for i, k := range keys {
+ binTreeValues := values[i].Value.BinTree.Values
+ for _, b := range binTreeValues {
+ switch b.SumType {
+ case "Old":
+ if int32(k) == workchain && ton.Bits256(b.Old.RootHash) == shardRootHash {
+ return nil
+ }
+ case "New":
+ if int32(k) == workchain && ton.Bits256(b.New.RootHash) == shardRootHash {
+ return nil
+ }
+ }
+ }
+ }
+ return fmt.Errorf("required shard hash not found in proof")
+}
+
+func checkBlockShardStateProof(proof []byte, blockRootHash ton.Bits256, cellsMap map[[32]byte]*boc.Cell) (*tlb.ShardStateUnsplit, error) {
+ proofCells, err := boc.DeserializeBoc(proof)
+ if err != nil {
+ return nil, err
+ }
+ if len(proofCells) != 2 {
+ return nil, errors.New("must be two root cells")
+ }
+ newStateHash, err := checkBlockProof(proofCells[0], blockRootHash)
+ if err != nil {
+ return nil, fmt.Errorf("incorrect block proof: %w", err)
+ }
+ var stateProof struct {
+ Proof tlb.MerkleProof[tlb.ShardStateUnsplit]
+ }
+ decoder := tlb.NewDecoder()
+ if cellsMap != nil {
+ decoder = decoder.WithPrunedResolver(func(hash tlb.Bits256) (*boc.Cell, error) {
+ cell, ok := cellsMap[hash]
+ if ok {
+ return cell, nil
+ }
+ return nil, errors.New("not found")
+ })
+ }
+ err = decoder.Unmarshal(proofCells[1], &stateProof)
+ if err != nil {
+ return nil, err
+ }
+ if stateProof.Proof.VirtualHash != *newStateHash {
+ return nil, errors.New("invalid virtual hash")
+ }
+ return &stateProof.Proof.VirtualRoot, nil
+}
+
+func checkBlockProof(proof *boc.Cell, blockRootHash ton.Bits256) (*tlb.Bits256, error) {
+ var res tlb.MerkleProof[tlb.Block]
+ err := tlb.Unmarshal(proof, &res) // merkle hash and depth checks inside
+ if err != nil {
+ return nil, fmt.Errorf("failed to unmarshal block proof: %w", err)
+ }
+ if ton.Bits256(res.VirtualHash) != blockRootHash {
+ return nil, fmt.Errorf("invalid block root hash")
+ }
+ return &res.VirtualRoot.StateUpdate.ToHash, nil // return new_hash field of MerkleUpdate of ShardState
+}

liteapi/account_test.go

@@ -0,0 +1,171 @@
+package liteapi
+
+import (
+ "bytes"
+ "context"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "github.com/tonkeeper/tongo/boc"
+ "github.com/tonkeeper/tongo/tlb"
+ "github.com/tonkeeper/tongo/ton"
+ "testing"
+)
+
+func TestGetAccountWithProof(t *testing.T) {
+ api, err := NewClient(Testnet(), FromEnvs())
+ if err != nil {
+ t.Fatal(err)
+ }
+ testCases := []struct {
+ name string
+ accountID string
+ }{
+ {
+ name: "account from masterchain",
+ accountID: "-1:34517c7bdf5187c55af4f8b61fdc321588c7ab768dee24b006df29106458d7cf",
+ },
+ {
+ name: "active account from basechain",
+ accountID: "0:e33ed33a42eb2032059f97d90c706f8400bb256d32139ca707f1564ad699c7dd",
+ },
+ {
+ name: "nonexisted from basechain",
+ accountID: "0:5f00decb7da51881764dc3959cec60609045f6ca1b89e646bde49d492705d77c",
+ },
+ }
+ for _, tt := range testCases {
+ t.Run(tt.name, func(t *testing.T) {
+ accountID, err := ton.AccountIDFromRaw(tt.accountID)
+ if err != nil {
+ t.Fatal("AccountIDFromRaw() failed: %w", err)
+ }
+ acc, st, err := api.GetAccountWithProof(context.TODO(), accountID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ fmt.Printf("Account status: %v\n", acc.Account.Status())
+ fmt.Printf("Last proof utime: %v\n", st.ShardStateUnsplit.GenUtime)
+ })
+ }
+}
+
+func TestUnmarshallingProofWithPrunedResolver(t *testing.T) {
+ testCases := []struct {
+ name string
+ accountID string
+ state string
+ proof string
+ }{
+ {
+ name: "account from masterchain",
+ accountID: "-1:34517c7bdf5187c55af4f8b61fdc321588c7ab768dee24b006df29106458d7cf",
+ state: "te6ccgEBAQEANwAAac/zRRfHvfUYfFWvT4th/cMhWIx6t2je4ksAbfKRBkWNfPICV8MiQ7WQAAAnwcjbgQjD0JAE",
+ proof: "te6ccgECMQIABnwBAAlGAzm5ngf8wRtgCPSbEv1KYCOfL3YI9/HjNbeRsayNPbNBAcQCCUYDNjyZxQ6TS+uioSqhEmArXFMzcJ0iBgOO8gRScN1HDdQAFykkW5Ajr+L////9AP////8AAAAAAAAAAAFZWXUAAAAAZtWqnAAAFybEzYeEAVlZcmADBAUGKEgBAaHRVuPHjzLUmEYd44x/vzWcCD0Yz14taK8lFYkyYi16AAEiE4IRdMqOqEN5qjAHJyIzAAAAAAAAAAD//////////4RdMqOqEN5qiCgnKChIAQGSq4StFUmWS1wEONBSEQt3Wuup9Nhbdrp5fmk6oPx7cgAbIxMBCLplR1QhvNUYCAknIxMBCLADRttzmtl4CgsnKEgBASOab6P8maV1G2OhFqlTgNjoroG1i5MO5qtsoOqgY1ViAcAjEwEIqC8wZsH7ingMDScoSAEB6CVtOp/z9Kpj+SrDgasFP3kzGT7kZL/D7DV+kXZw3p4BwChIAQFIWAk+xGmmFk4X6v0lmgWpnk4YjEI/Tam9kXRPNLTjdgEPIhEA8MDW7kYtTOgODyhIAQFvFG13TDMvzWbO+0LVJbC2JHWAiHGL4nE6ztkqqPbefQENIhEA8BRymICH9QgQESIRAPAErnsrX9VoEhMoSAEB3EtPbrrXUOrrKC6PIjfYhj6sGE/sozDHyHhOqJco3MEAHShIAQEzaqPXOwDDYGRMpiB4f56Ep+oa0eJgHewJ3AzRahxDIgAaIhEA4GnDcXrbdIgUFSIRAOBpsy/ekzFIFhcoSAEBNEqqYfkIiFNMQLEWcnTl6stVZGy5ErSafIxVo9y43QYAGCINAKISMHbNyBgZKEgBAb3/C7yo+BlD9hObGRxmV/KM5e4Dx2dwvpYwbKHtaWxnABciDQChOnTEp4gaGyhIAQGefqFE75DubH/tAm07waI/ZJXXaUbA9TAjnJiXm5bFCQAYKEgBAWXR2cYWGVGOhRr0zx2IbfGvk/PYc1y+oSjg/RG7M23AABAiDQCgymlW3sgcHSINAKBa4jVqKB4fKEgBAScXOibV9zcakxfRicgWyCdTJFdgVU+FKgRvmF+aGkzaAAooSAEBgCBa9skgBATVk+IARArXssVqC0fkYdTeesmbGCNG2QIAEyIJAGHoSAggISIJAGHoSAgiIyhIAQG0d/c3vjpwCZ/skE9GxWaQW2p12p94naEbq+nI8BwxkAALIgkAYehICCQlKEgBAbcMTUahqWzuFpxMXlh6PQ1nbe5GZl+2H6cojgVpqdJGAAohl7xvj3vqMPirXp8Ww/uGQrEY9W7RvcSWANvlIgyLGvngMPQkBwpuh9/a8Q8liD7J/k6cDctwlpd7/wLfSj2ZkV3vQyWYAABPg5G3AgwmKEgBAdYv7OF3BCOejG/QrCN6d0U1gfBqoWUQPs3lCtkW0bqjAAgoSAEBfNH4EBmmQQpGeuMDQrdiJrcg1/foaCtvYt8A2eULqDYAAChIAQGyDjajs2pM3uYBEGxkLpBxiwpY2vIAdT27MYn5VrSUtgABKEgBAfXuY7WxrmX661SjWg783A5GU3G2ZUuk96jxo07FszvmAcAkEBHvVar////9KissLQGgm8ephwAAAAAEAQFZWXUAAAAAAP////8AAAAAAAAAAGbVqpwAABcmxM2HgAAAFybEzYeEjIe6qAAErqgBWVlyAVlQJsQAAAAIAAAAAAAAAe4uKEgBASkmYQFN/IwKZw+6jDvG7Hla0bypRJASLgCSLllgZYYxAAMqigQUxb9ElcbqpVZzQQGVtjJWkzZu/gqQV6cRwEqnJT7ljzm5ngf8wRtgCPSbEv1KYCOfL3YI9/HjNbeRsayNPbNBAcQBxC8wKEgBAfZANQckARh74l3KoHg6MIoIlCtXCklSokH5oFnYkvWaAAcAmAAAFybEvkVEAVlZdIw41mHg1tiTlZWmUEC5Zs1iJSaJiU/PG7sL/HsqfBj+zYXmULmtzn4TRGwnVVC5tKAhaIUDbFZrLZ+xVZ8cOhpojAEDFMW/RJXG6qVWc0EBlbYyVpM2bv4KkFenEcBKpyU+5Y+0LNwg0RHTx+GvVrTHWlXSAsJOr1Re1+VF1o0FxmRgmwHEABVojAEDObmeB/zBG2AI9JsS/UpgI58vdgj38eM1t5GxrI09s0EncQaO3Qwlxbnasj2PyljXoXXcs0VfOqaRU3MLD/XjOwHEABU=",
+ },
+ {
+ name: "active account from basechain",
+ accountID: "0:e33ed33a42eb2032059f97d90c706f8400bb256d32139ca707f1564ad699c7dd",
+ state: "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",
+ proof: "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",
+ },
+ }
+ for _, tt := range testCases {
+ t.Run(tt.name, func(t *testing.T) {
+ accountID, err := ton.AccountIDFromRaw(tt.accountID)
+ if err != nil {
+ t.Fatal("AccountIDFromRaw() failed: %w", err)
+ }
+ state, err := base64.StdEncoding.DecodeString(tt.state)
+ if err != nil {
+ t.Fatal("base64 decoding failed: %w", err)
+ }
+ proof, err := base64.StdEncoding.DecodeString(tt.proof)
+ if err != nil {
+ t.Fatal("base64 decoding failed: %w", err)
+ }
+ stateCells, err := boc.DeserializeBoc(state)
+ if err != nil {
+ t.Fatal("DeserializeBoc() failed: %w", err)
+ }
+ proofCells, err := boc.DeserializeBoc(proof)
+ if err != nil {
+ t.Fatal("DeserializeBoc() failed: %w", err)
+ }
+ hash, err := stateCells[0].Hash256()
+ if err != nil {
+ t.Fatal("Get hash failed: %w", err)
+ }
+ cellsMap := map[[32]byte]*boc.Cell{hash: stateCells[0]}
+ if err != nil {
+ t.Fatal("Get NonPrunedCells() failed: %w", err)
+ }
+ decoder := tlb.NewDecoder().WithDebug().WithPrunedResolver(func(hash tlb.Bits256) (*boc.Cell, error) {
+ cell, ok := cellsMap[hash]
+ if ok {
+ return cell, nil
+ }
+ return nil, errors.New("not found")
+ })
+ var stateProof struct {
+ Proof tlb.MerkleProof[tlb.ShardStateUnsplit]
+ }
+ err = decoder.Unmarshal(proofCells[1], &stateProof)
+ if err != nil {
+ t.Fatal("proof unmarshalling failed: %w", err)
+ }
+ values := stateProof.Proof.VirtualRoot.ShardStateUnsplit.Accounts.Values()
+ keys := stateProof.Proof.VirtualRoot.ShardStateUnsplit.Accounts.Keys()
+ for i, k := range keys {
+ if bytes.Equal(k[:], accountID.Address[:]) {
+ fmt.Printf("Account status: %v\n", values[i].Account.Status())
+ }
+ }
+ })
+ }
+}
+
+func TestGetAccountWithProofForBlock(t *testing.T) {
+ api, err := NewClient(Testnet(), FromEnvs())
+ if err != nil {
+ t.Fatal(err)
+ }
+ testCases := []struct {
+ name string
+ accountID string
+ block string
+ }{
+ {
+ name: "active account from basechain",
+ accountID: "0:e33ed33a42eb2032059f97d90c706f8400bb256d32139ca707f1564ad699c7dd",
+ block: "(0,e000000000000000,24681072)",
+ },
+ {
+ name: "account from masterchain",
+ accountID: "-1:34517c7bdf5187c55af4f8b61fdc321588c7ab768dee24b006df29106458d7cf",
+ block: "(-1,8000000000000000,23040403)",
+ },
+ }
+ for _, tt := range testCases {
+ t.Run(tt.name, func(t *testing.T) {
+ accountID, err := ton.AccountIDFromRaw(tt.accountID)
+ if err != nil {
+ t.Fatal("AccountIDFromRaw() failed: %w", err)
+ }
+ b, err := ton.ParseBlockID(tt.block)
+ if err != nil {
+ t.Fatal("ParseBlockID() failed: %w", err)
+ }
+ block, _, err := api.LookupBlock(context.TODO(), b, 1, nil, nil)
+ if err != nil {
+ t.Fatal("LookupBlock() failed: %w", err)
+ }
+ acc, st, err := api.WithBlock(block).GetAccountWithProof(context.TODO(), accountID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ fmt.Printf("Account status: %v\n", acc.Account.Status())
+ fmt.Printf("Last proof utime: %v\n", st.ShardStateUnsplit.GenUtime)
+ })
+ }
+}

liteapi/client.go

@@ -571,6 +571,9 @@ func (c *Client) GetAccountStateRaw(ctx context.Context, accountID ton.AccountID
  if err != nil {
  return liteclient.LiteServerAccountStateC{}, err
  }
+ if res.Id.ToBlockIdExt() != blockID {
+ return liteclient.LiteServerAccountStateC{}, errors.New("invalid block ID")
+ }
  return res, nil
 }
 

tlb/bintree.go

@@ -54,6 +54,13 @@ func (b *BinTree[T]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
  }
  b.Values = make([]T, 0, len(dec))
  for _, i := range dec {
+ if i.CellType() == boc.PrunedBranchCell {
+ cell := resolvePrunedCell(c, decoder.resolvePruned)
+ if cell == nil {
+ continue
+ }
+ i = cell
+ }
  var t T
  err := decoder.Unmarshal(i, &t)
  if err != nil {