status-im/status-go

package sqlite

import (
    "database/sql/driver"
    "encoding/json"
    "errors"
    "fmt"
    "math"
    "math/big"
    "reflect"
)

// JSONBlob type for marshaling/unmarshaling inner type to json.
type JSONBlob struct {
    Data  interface{}
    Valid bool
}

// Scan implements interface.
func (blob *JSONBlob) Scan(value interface{}) error {
    dataVal := reflect.ValueOf(blob.Data)
    blob.Valid = false
    if value == nil || dataVal.Kind() == reflect.Ptr && dataVal.IsNil() {
        return nil
    }

    var bytes []byte
    ok := true
    switch v := value.(type) {
    case []byte:
        bytes, ok = value.([]byte)
    case string:
        bytes = []byte(v)
    default:
        ok = false
    }
    if !ok {
        return errors.New("not a byte slice or string")
    }
    if len(bytes) == 0 {
        return nil
    }
    err := json.Unmarshal(bytes, blob.Data)
    blob.Valid = err == nil
    return err
}

// Value implements interface.
func (blob *JSONBlob) Value() (driver.Value, error) {
    dataVal := reflect.ValueOf(blob.Data)
    if (blob.Data == nil) || (dataVal.Kind() == reflect.Ptr && dataVal.IsNil()) {
        return nil, nil
    }

    switch dataVal.Kind() {
    case reflect.Slice, reflect.Array, reflect.Map:
        if dataVal.Len() == 0 {
            return nil, nil
        }
    }

    return json.Marshal(blob.Data)
}

func BigIntToClampedInt64(val *big.Int) *int64 {
    if val == nil {
        return nil
    }
    var v int64
    if val.IsInt64() {
        v = val.Int64()
    } else {
        v = math.MaxInt64
    }
    return &v
}

// BigIntToPadded128BitsStr converts a big.Int to a string, padding it with 0 to account for 128 bits size
// Returns nil if input val is nil
// This should work to sort and compare big.Ints values in SQLite
func BigIntToPadded128BitsStr(val *big.Int) *string {
    if val == nil {
        return nil
    }
    hexStr := val.Text(16)
    res := new(string)
    *res = fmt.Sprintf("%032s", hexStr)
    return res
}

func Int64ToPadded128BitsStr(val int64) *string {
    res := fmt.Sprintf("%032x", val)
    return &res
}