github.com/status-im/status-go@v1.1.0/services/wallet/transfer/query.go

package transfer

import (
	"bytes"
	"database/sql"
	"fmt"
	"math/big"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/status-im/status-go/services/wallet/bigint"
	w_common "github.com/status-im/status-go/services/wallet/common"
)

const baseTransfersQuery = "SELECT hash, type, blk_hash, blk_number, timestamp, address, tx, sender, receipt, log, network_id, base_gas_fee, COALESCE(multi_transaction_id, 0) %s FROM transfers"
const preloadedTransfersQuery = "SELECT hash, type, address, log, token_id, amount_padded128hex FROM transfers"

type transfersQuery struct {
	buf        *bytes.Buffer
	args       []interface{}
	whereAdded bool
	subQuery   bool
}

func newTransfersQuery() *transfersQuery {
	newQuery := newEmptyQuery()
	transfersQueryString := fmt.Sprintf(baseTransfersQuery, "")
	newQuery.buf.WriteString(transfersQueryString)
	return newQuery
}

func newTransfersQueryForPreloadedTransactions() *transfersQuery {
	newQuery := newEmptyQuery()
	newQuery.buf.WriteString(preloadedTransfersQuery)
	return newQuery
}

func newSubQuery() *transfersQuery {
	newQuery := newEmptyQuery()
	newQuery.subQuery = true
	return newQuery
}

func newEmptyQuery() *transfersQuery {
	buf := bytes.NewBuffer(nil)
	return &transfersQuery{buf: buf}
}

func (q *transfersQuery) addWhereSeparator(separator SeparatorType) {
	if !q.whereAdded {
		if !q.subQuery {
			q.buf.WriteString(" WHERE")
		}
		q.whereAdded = true
	} else if separator == OrSeparator {
		q.buf.WriteString(" OR")
	} else if separator == AndSeparator {
		q.buf.WriteString(" AND")
	} else if separator != NoSeparator {
		panic("Unknown separator. Need to handle current SeparatorType value")
	}
}

type SeparatorType int

// Beware: please update addWhereSeparator if changing this enum
const (
	NoSeparator SeparatorType = iota + 1
	OrSeparator
	AndSeparator
)

// addSubQuery adds where clause formed as: WHERE/<separator> (<subQuery>)
func (q *transfersQuery) addSubQuery(subQuery *transfersQuery, separator SeparatorType) *transfersQuery {
	q.addWhereSeparator(separator)
	q.buf.WriteString(" (")
	q.buf.Write(subQuery.buf.Bytes())
	q.buf.WriteString(")")
	q.args = append(q.args, subQuery.args...)
	return q
}

func (q *transfersQuery) FilterStart(start *big.Int) *transfersQuery {
	if start != nil {
		q.addWhereSeparator(AndSeparator)
		q.buf.WriteString(" blk_number >= ?")
		q.args = append(q.args, (*bigint.SQLBigInt)(start))
	}
	return q
}

func (q *transfersQuery) FilterEnd(end *big.Int) *transfersQuery {
	if end != nil {
		q.addWhereSeparator(AndSeparator)
		q.buf.WriteString(" blk_number <= ?")
		q.args = append(q.args, (*bigint.SQLBigInt)(end))
	}
	return q
}

func (q *transfersQuery) FilterLoaded(loaded int) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" loaded = ? ")
	q.args = append(q.args, loaded)

	return q
}

func (q *transfersQuery) FilterNetwork(network uint64) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" network_id = ?")
	q.args = append(q.args, network)
	return q
}

func (q *transfersQuery) FilterAddress(address common.Address) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" address = ?")
	q.args = append(q.args, address)
	return q
}

func (q *transfersQuery) FilterTransactionID(hash common.Hash) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" hash = ?")
	q.args = append(q.args, hash)
	return q
}

func (q *transfersQuery) FilterTransactionHash(hash common.Hash) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" tx_hash = ?")
	q.args = append(q.args, hash)
	return q
}

func (q *transfersQuery) FilterBlockHash(blockHash common.Hash) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" blk_hash = ?")
	q.args = append(q.args, blockHash)
	return q
}

func (q *transfersQuery) FilterBlockNumber(blockNumber *big.Int) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" blk_number = ?")
	q.args = append(q.args, (*bigint.SQLBigInt)(blockNumber))
	return q
}

func ascendingString(ascending bool) string {
	if ascending {
		return "ASC"
	}
	return "DESC"
}

func (q *transfersQuery) SortByBlockNumberAndHash() *transfersQuery {
	q.buf.WriteString(" ORDER BY blk_number DESC, hash ASC ")
	return q
}

func (q *transfersQuery) SortByTimestamp(ascending bool) *transfersQuery {
	q.buf.WriteString(fmt.Sprintf(" ORDER BY timestamp %s ", ascendingString(ascending)))
	return q
}

func (q *transfersQuery) Limit(pageSize int64) *transfersQuery {
	q.buf.WriteString(" LIMIT ?")
	q.args = append(q.args, pageSize)
	return q
}

func (q *transfersQuery) FilterType(txType w_common.Type) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" type = ?")
	q.args = append(q.args, txType)
	return q
}

func (q *transfersQuery) FilterTokenAddress(address common.Address) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" token_address = ?")
	q.args = append(q.args, address)
	return q
}

func (q *transfersQuery) FilterTokenID(tokenID *big.Int) *transfersQuery {
	q.addWhereSeparator(AndSeparator)
	q.buf.WriteString(" token_id = ?")
	q.args = append(q.args, (*bigint.SQLBigIntBytes)(tokenID))
	return q
}

func (q *transfersQuery) String() string {
	return q.buf.String()
}

func (q *transfersQuery) Args() []interface{} {
	return q.args
}

func (q *transfersQuery) TransferScan(rows *sql.Rows) (rst []Transfer, err error) {
	for rows.Next() {
		transfer := Transfer{
			BlockNumber: &big.Int{},
			Transaction: &types.Transaction{},
			Receipt:     &types.Receipt{},
			Log:         &types.Log{},
		}
		err = rows.Scan(
			&transfer.ID, &transfer.Type, &transfer.BlockHash,
			(*bigint.SQLBigInt)(transfer.BlockNumber), &transfer.Timestamp, &transfer.Address,
			&JSONBlob{transfer.Transaction}, &transfer.From, &JSONBlob{transfer.Receipt}, &JSONBlob{transfer.Log}, &transfer.NetworkID, &transfer.BaseGasFees, &transfer.MultiTransactionID)
		if err != nil {
			return nil, err
		}
		rst = append(rst, transfer)
	}

	return rst, nil
}

func (q *transfersQuery) PreloadedTransactionScan(rows *sql.Rows) (rst []*PreloadedTransaction, err error) {
	transfers := make([]Transfer, 0)
	for rows.Next() {
		transfer := Transfer{
			Log: &types.Log{},
		}
		tokenValue := sql.NullString{}
		tokenID := sql.RawBytes{}
		err = rows.Scan(
			&transfer.ID, &transfer.Type,
			&transfer.Address,
			&JSONBlob{transfer.Log},
			&tokenID, &tokenValue)

		if len(tokenID) > 0 {
			transfer.TokenID = new(big.Int).SetBytes(tokenID)
		}

		if tokenValue.Valid {
			var ok bool
			transfer.TokenValue, ok = new(big.Int).SetString(tokenValue.String, 16)
			if !ok {
				panic("failed to parse token value")
			}
		}

		if err != nil {
			return nil, err
		}
		transfers = append(transfers, transfer)
	}

	rst = make([]*PreloadedTransaction, 0, len(transfers))

	for _, transfer := range transfers {
		preloadedTransaction := &PreloadedTransaction{
			ID:      transfer.ID,
			Type:    transfer.Type,
			Address: transfer.Address,
			Log:     transfer.Log,
			TokenID: transfer.TokenID,
			Value:   transfer.TokenValue,
		}

		rst = append(rst, preloadedTransaction)
	}

	return rst, nil
}