Skip to content

Commit

Permalink
Fetch indexes for cmd
Browse files Browse the repository at this point in the history
  • Loading branch information
Agusx1211 committed Feb 11, 2024
1 parent 97b1cff commit b87eead
Show file tree
Hide file tree
Showing 4 changed files with 387 additions and 7 deletions.
176 changes: 176 additions & 0 deletions compressor/cmd/czip-compressor/indexes.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,176 @@
package main

import (
"context"
"encoding/json"
"fmt"
"os"

"github.com/0xsequence/czip/compressor"
"github.com/0xsequence/ethkit/go-ethereum/common"
)

func LoadCachedData(path string) (*compressor.Indexes, error) {
// See if the file exists, if it doesn't, return a new Indexes obj.
if _, err := os.Stat(path); os.IsNotExist(err) {
return &compressor.Indexes{
AddressIndexes: make(map[string]uint),
Bytes32Indexes: make(map[string]uint),
}, nil
}

// Load the file
dat, err := os.ReadFile(path)
if err != nil {
return nil, err
}

// Parse the JSON
tmp := &compressor.Indexes{
AddressIndexes: make(map[string]uint),
Bytes32Indexes: make(map[string]uint),
}

err = json.Unmarshal(dat, tmp)
if err != nil {
return nil, err
}

return fromHumanReadable(tmp), nil
}

func SaveCachedData(path string, data *compressor.Indexes) error {
// Convert to human readable
tmp := toHumanReadable(data)

// Marshal the JSON
dat, err := json.Marshal(tmp)
if err != nil {
return err
}

// Write the file
return os.WriteFile(path, dat, 0644)
}

func fromHumanReadable(from *compressor.Indexes) *compressor.Indexes {
next := &compressor.Indexes{
AddressIndexes: make(map[string]uint),
Bytes32Indexes: make(map[string]uint),
}

for k, v := range from.AddressIndexes {
next.AddressIndexes[string(common.FromHex(k))] = v
}

for k, v := range from.Bytes32Indexes {
next.Bytes32Indexes[string(common.FromHex(k))] = v
}

return next
}

func toHumanReadable(from *compressor.Indexes) *compressor.Indexes {
next := &compressor.Indexes{
AddressIndexes: make(map[string]uint),
Bytes32Indexes: make(map[string]uint),
}

for k, v := range from.AddressIndexes {
next.AddressIndexes[common.Bytes2Hex([]byte(k))] = v
}

for k, v := range from.Bytes32Indexes {
next.Bytes32Indexes[common.Bytes2Hex([]byte(k))] = v
}

return next
}

func UseIndexes(ctx context.Context, args *ParsedArgs) (*compressor.Indexes, error) {
var indexes *compressor.Indexes

if ParseUseStorage(args) {
provider, err := ParseProvider(args)
if err != nil {
return nil, err
}

if provider == nil {
return nil, fmt.Errorf("provider is required")
}

chainId, err := provider.ChainID(ctx)
if err != nil {
return nil, err
}

// Load the cache file
var path string
if flag, ok := args.Flags["cache-file"]; ok {
path = flag
} else {
path = fmt.Sprintf("/tmp/czip-indexes-%d.json", chainId)
}

indexes, err = LoadCachedData(path)
if err != nil {
return nil, err
}

contract, err := ParseContractAddress(args)
if err != nil {
return nil, err
}

if contract == (common.Address{}) {
return nil, fmt.Errorf("contract address is required")
}

// Get the highest indexes for addresses and bytes32
var maxAddressIndex uint
var maxBytes32Index uint

for _, v := range indexes.AddressIndexes {
if v > maxAddressIndex {
maxAddressIndex = v
}
}

for _, v := range indexes.Bytes32Indexes {
if v > maxBytes32Index {
maxBytes32Index = v
}
}

// Fetch the state
_, ra, _, rb, err := compressor.LoadState(ctx, provider, contract, 2048, maxAddressIndex, maxBytes32Index, 0)
if err != nil {
return nil, err
}

// Update the indexes
for k, v := range ra {
indexes.AddressIndexes[k] = v
}

for k, v := range rb {
indexes.Bytes32Indexes[k] = v
}

// Save the cache file
err = SaveCachedData(path, indexes)
if err != nil {
return nil, err
}
} else {
indexes = &compressor.Indexes{
AddressIndexes: make(map[string]uint),
Bytes32Indexes: make(map[string]uint),
}
}

indexes.Bytes4Indexes = compressor.LoadBytes4()

return indexes, nil
}
33 changes: 27 additions & 6 deletions compressor/cmd/czip-compressor/main.go
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
package main

import (
"context"
"fmt"
"os"

Expand Down Expand Up @@ -49,14 +50,19 @@ func main() {
}

func encodeAny(args *ParsedArgs) (string, error) {
buf := compressor.NewBuffer(compressor.METHOD_DECODE_ANY, nil, ParseAllowOpcodes(args), ParseUseStorage(args))
indexes, err := UseIndexes(context.Background(), args)
if err != nil {
return "", err
}

buf := compressor.NewBuffer(compressor.METHOD_DECODE_ANY, indexes, ParseAllowOpcodes(args), ParseUseStorage(args))

if len(args.Positional) < 2 {
return "", fmt.Errorf("usage: encode_any <hex>")
}

input := common.FromHex(args.Positional[1])
_, err := buf.WriteBytesOptimized(input, true)
_, err = buf.WriteBytesOptimized(input, true)
if err != nil {
return "", err
}
Expand Down Expand Up @@ -95,8 +101,13 @@ func encodeCalls(args *ParsedArgs) (string, error) {
addrs[i/2-1] = common.HexToAddress(args.Positional[i+1]).Bytes()
}

buf := compressor.NewBuffer(method, nil, ParseAllowOpcodes(args), ParseUseStorage(args))
_, err := buf.WriteCalls(addrs, datas)
indexes, err := UseIndexes(context.Background(), args)
if err != nil {
return "", err
}

buf := compressor.NewBuffer(method, indexes, ParseAllowOpcodes(args), ParseUseStorage(args))
_, err = buf.WriteCalls(addrs, datas)
if err != nil {
return "", err
}
Expand All @@ -119,7 +130,12 @@ func encodeCall(args *ParsedArgs) (string, error) {
method = compressor.METHOD_EXECUTE_CALL_RETURN
}

buf := compressor.NewBuffer(method, nil, ParseAllowOpcodes(args), ParseUseStorage(args))
indexes, err := UseIndexes(context.Background(), args)
if err != nil {
return "", err
}

buf := compressor.NewBuffer(method, indexes, ParseAllowOpcodes(args), ParseUseStorage(args))
_, err = buf.WriteCall(addr, data)
if err != nil {
return "", err
Expand Down Expand Up @@ -148,7 +164,12 @@ func encodeSequenceTx(args *ParsedArgs) (string, error) {
return "", fmt.Errorf("unsupported action: %s", action)
}

buf := compressor.NewBuffer(method, nil, ParseAllowOpcodes(args), ParseUseStorage(args))
indexes, err := UseIndexes(context.Background(), args)
if err != nil {
return "", err
}

buf := compressor.NewBuffer(method, indexes, ParseAllowOpcodes(args), ParseUseStorage(args))
_, err = buf.WriteSequenceExecute(addr, &sequence.Transaction{
Nonce: nonce,
Transactions: txs,
Expand Down
27 changes: 26 additions & 1 deletion compressor/cmd/czip-compressor/utils.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,8 @@ import (
"strings"

encoder "github.com/0xsequence/czip/compressor"
"github.com/0xsequence/ethkit/ethrpc"
"github.com/0xsequence/ethkit/go-ethereum/common"
)

type ParsedArgs struct {
Expand Down Expand Up @@ -70,7 +72,7 @@ func ParseUseStorage(args *ParsedArgs) bool {

switch val {
case "":
return true
return false
case "true":
return true
case "false":
Expand All @@ -82,6 +84,29 @@ func ParseUseStorage(args *ParsedArgs) bool {
return false
}

func ParseProvider(args *ParsedArgs) (*ethrpc.Provider, error) {
val := args.Flags["provider"]
if val == "" {
return nil, nil
}

provider, err := ethrpc.NewProvider(val)
if err != nil {
return nil, err
}

return provider, nil
}

func ParseContractAddress(args *ParsedArgs) (common.Address, error) {
val := args.Flags["contract"]
if val == "" {
return common.Address{}, fmt.Errorf("missing contract address")
}

return common.HexToAddress(val), nil
}

func ParseAllowOpcodes(args *ParsedArgs) *encoder.AllowOpcodes {
// Two possible flags `--allow-opcodes` and `--disallow-opcodes`
// values are separated by commas, and expressed as strings
Expand Down
Loading

0 comments on commit b87eead

Please sign in to comment.