wallet

package
v0.29.0-beta.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 1, 2019 License: MPL-2.0 Imports: 24 Imported by: 0

README

Wallet

Wallet service starts a loop that watches for new transfers (eth and erc20). To correctly start the service two values need to be changed in the config:

  1. Set Enable to true in WalletConfig
{
  "WalletConfig": {
    "Enabled": true,
  }
}
  1. And expose wallet API with APIModules
{
  APIModules: "eth,net,web3,peer,wallet",
}

API

wallet_getTransfers

Returns avaiable transfers in a given range.

Parameters
  • start: BIGINT - start of the range
  • end: BIGINT - end of the range. if nil query will return all transfers from start.
Examples
{"jsonrpc":"2.0","id":14,"method":"wallet_getTransfers","params":[0,20]}
{"jsonrpc":"2.0","id":14,"method":"wallet_getTransfers","params":[0,null]}
{"jsonrpc":"2.0","id":13,"method":"wallet_getTransfers","params":[0]}
Returns

List of objects like:

[
  {
    "type": "erc20",
    "address": "0x5dc6108dc6296b052bbd33000553afe0ea576b5e",
    "blockNumber": 5687981,
    "blockhash": "0xcc4553f125be0bc6cc974518368145fcf1344f41e5de238205db0a1c185ea2fc",
    "transaction": {
      "nonce": "0x57",
      "gasPrice": "0x3b9aca00",
      "gas": "0x44ba8",
      "to": "0xc55cf4b03948d7ebc8b9e8bad92643703811d162",
      "value": "0x0",
      "input": "0xcae9ca5100000000000000000000000039d16cdb56b5a6a89e1a397a13fe48034694316e0000000000000000000000000000000000000000000000015af1d78b58c40000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000449134709e00000000000000000000000000000000000000000000000000000000000000010000000000000000000000005dc6108dc6296b052bbd33000553afe0ea576b5e00000000000000000000000000000000000000000000000000000000",
      "v": "0x29",
      "r": "0x124587e9c1d16d8bd02fda1221aefbfca8e2f4cd6300ed2077ebf736789179ab",
      "s": "0x4309fddc1226dacb877488221a439c4f97d77dc2c3f5c8ea51f34f42417d3bda",
      "hash": "0x259dd45c9c4d52137f32b7787e6e1fb6c9faf70ba40b8137bf66ba03abc0da00"
    },
    "receipt": {
      "root": "0x",
      "status": "0x1",
      "cumulativeGasUsed": "0x389e1e",
      "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000200000000020000000000000000000000000000000000004000000000000000200000000000000020000000000008000000000000000000000000000000000000000000000000020000000000002000000800000000100000000000000010000000000000000000400000000000000001000000000040000000400000000400000000020000000000000008000000000020000000010000000002000000000000020000000002000000000000000000000000000000000200000000000000000020000010000000000000000000000400000000000000000000000000000000000000",
      "logs": [
        {
          "address": "0xc55cf4b03948d7ebc8b9e8bad92643703811d162",
          "topics": [
            "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
            "0x0000000000000000000000005dc6108dc6296b052bbd33000553afe0ea576b5e",
            "0x00000000000000000000000039d16cdb56b5a6a89e1a397a13fe48034694316e"
          ],
          "data": "0x0000000000000000000000000000000000000000000000015af1d78b58c40000",
          "blockNumber": "0x56caad",
          "transactionHash": "0x259dd45c9c4d52137f32b7787e6e1fb6c9faf70ba40b8137bf66ba03abc0da00",
          "transactionIndex": "0x10",
          "blockHash": "0xcc4553f125be0bc6cc974518368145fcf1344f41e5de238205db0a1c185ea2fc",
          "logIndex": "0xd",
          "removed": false
        },
        {
          "address": "0xc55cf4b03948d7ebc8b9e8bad92643703811d162",
          "topics": [
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
            "0x0000000000000000000000005dc6108dc6296b052bbd33000553afe0ea576b5e",
            "0x000000000000000000000000ee55b1661fd24c4760d92026cedb252a5a0f2a4e"
          ],
          "data": "0x0000000000000000000000000000000000000000000000015af1d78b58c40000",
          "blockNumber": "0x56caad",
          "transactionHash": "0x259dd45c9c4d52137f32b7787e6e1fb6c9faf70ba40b8137bf66ba03abc0da00",
          "transactionIndex": "0x10",
          "blockHash": "0xcc4553f125be0bc6cc974518368145fcf1344f41e5de238205db0a1c185ea2fc",
          "logIndex": "0xe",
          "removed": false
        },
        {
          "address": "0x39d16cdb56b5a6a89e1a397a13fe48034694316e",
          "topics": [
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
            "0x0000000000000000000000000000000000000000000000000000000000000000",
            "0x0000000000000000000000005dc6108dc6296b052bbd33000553afe0ea576b5e",
            "0x0000000000000000000000000000000000000000000000000000000000000044"
          ],
          "data": "0x",
          "blockNumber": "0x56caad",
          "transactionHash": "0x259dd45c9c4d52137f32b7787e6e1fb6c9faf70ba40b8137bf66ba03abc0da00",
          "transactionIndex": "0x10",
          "blockHash": "0xcc4553f125be0bc6cc974518368145fcf1344f41e5de238205db0a1c185ea2fc",
          "logIndex": "0xf",
          "removed": false
        }
      ],
      "transactionHash": "0x259dd45c9c4d52137f32b7787e6e1fb6c9faf70ba40b8137bf66ba03abc0da00",
      "contractAddress": "0x0000000000000000000000000000000000000000",
      "gasUsed": "0x34f42"
    }
  }
]
Examples
{"jsonrpc":"2.0","id":14,"method":"wallet_getTransfers","params":[0,20]}
{"jsonrpc":"2.0","id":14,"method":"wallet_getTransfers","params":[0,null]}
{"jsonrpc":"2.0","id":13,"method":"wallet_getTransfers","params":[0]}
wallet_getTransfersByAddress

Returns avaiable transfers in a given range.

Parameters
  • address: HEX - ethereum address encoded in hex
  • start: BIGINT - start of the range
  • end: BIGINT - end of the range. if nil query will return all transfers from start.
Examples
{"jsonrpc":"2.0","id":7,"method":"wallet_getTransfersByAddress","params":["0xb81a6845649fa8c042dfaceb3f7a684873406993","0x0"]}
Returns

Objects in the same format.

Signals

Two signals can be emitted:

  1. newblock signal

Emitted when transfers from new block were added to the database. In this case block number if the number of this new block. Client expected to request transfers starting from received block.

{
  "type": "wallet",
  "event": {
    "type": "newblock",
    "blockNumber": 0,
    "accounts": [
      "0x42c8f505b4006d417dd4e0ba0e880692986adbd8",
      "0x3129mdasmeo132128391fml1130410k312312mll"
    ]
  }
}
  1. reorg signal.

Emitted when part of blocks were removed. Starting from a given block number all transfers were removed. Client expected to request new transfers from received block and replace transfers that were received previously.

{
  "type": "wallet",
  "event": {
    "type": "reorg",
    "blockNumber": 0,
    "accounts": [
      "0x42c8f505b4006d417dd4e0ba0e880692986adbd8"
    ]
  }
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type API 

type API struct {
	// contains filtered or unexported fields
}

API is class with methods available over RPC.

func NewAPI 

func NewAPI(s *Service) *API

func (*API) GetTransfers 

func (api *API) GetTransfers(ctx context.Context, start, end *hexutil.Big) ([]Transfer, error)

GetTransfers returns transfers in range of blocks. If `end` is nil all transfers from `start` will be returned. TODO(dshulyak) benchmark loading many transfers from database. We can avoid json unmarshal/marshal if we will read header, tx and receipt as a raw json.

func (*API) GetTransfersByAddress 

func (api *API) GetTransfersByAddress(ctx context.Context, address common.Address, start, end *hexutil.Big) ([]Transfer, error)

GetTransfersByAddress returns transfers for a single address between two blocks.

type AtomicGroup 

type AtomicGroup struct {
	// contains filtered or unexported fields
}

AtomicGroup terminates as soon as first goroutine terminates..

func NewAtomicGroup 

func NewAtomicGroup(parent context.Context) *AtomicGroup

func (*AtomicGroup) Add 

func (d *AtomicGroup) Add(cmd Command)

Go spawns function in a goroutine and stores results or errors.

func (*AtomicGroup) Error 

func (d *AtomicGroup) Error() error

Error stores an error that was reported by any of the downloader. Should be called after Wait.

func (*AtomicGroup) Stop 

func (d *AtomicGroup) Stop()

func (*AtomicGroup) Wait 

func (d *AtomicGroup) Wait()

Wait for all downloaders to finish.

func (*AtomicGroup) WaitAsync 

func (d *AtomicGroup) WaitAsync() <-chan struct{}

type BalanceReader 

type BalanceReader interface {
	BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
}

BalanceReader interface for reading balance at a specifeid address.

type BatchDownloader 

type BatchDownloader interface {
	GetTransfersInRange(ctx context.Context, from, to *big.Int) ([]Transfer, error)
}

BatchDownloader interface for loading transfers in batches in speificed range of blocks.

type Command 

type Command func(context.Context) error

type ConcurrentDownloader 

type ConcurrentDownloader struct {
	*AtomicGroup
	*Result
}

func NewConcurrentDownloader 

func NewConcurrentDownloader(ctx context.Context) *ConcurrentDownloader

NewConcurrentDownloader creates ConcurrentDownloader instance.

type DBHeader 

type DBHeader struct {
	Number *big.Int
	Hash   common.Hash
	// Head is true if the block was a head at the time it was pulled from chain.
	Head bool
}

DBHeader fields from header that are stored in database.

type Database 

type Database struct {
	// contains filtered or unexported fields
}

Database sql wrapper for operations with wallet objects.

func InitializeDB 

func InitializeDB(path, password string) (*Database, error)

InitializeDB creates db file at a given path and applies migrations.

func (Database) Close 

func (db Database) Close() error

Close closes database.

func (*Database) GetHeaderByNumber 

func (db *Database) GetHeaderByNumber(number *big.Int) (header *DBHeader, err error)

GetHeaderByNumber selects header using block number.

func (*Database) GetLastHead 

func (db *Database) GetLastHead() (header *DBHeader, err error)

func (*Database) GetLatestSynced 

func (db *Database) GetLatestSynced(address common.Address, option SyncOption) (header *DBHeader, err error)

GetLatestSynced downloads last synced block with a given option.

func (*Database) GetTransfers 

func (db *Database) GetTransfers(start, end *big.Int) (rst []Transfer, err error)

GetTransfers load transfers transfer betweeen two blocks.

func (*Database) GetTransfersByAddress 

func (db *Database) GetTransfersByAddress(address common.Address, start, end *big.Int) (rst []Transfer, err error)

GetTransfersByAddress loads transfers for a given address between two blocks.

func (*Database) HeaderExists 

func (db *Database) HeaderExists(hash common.Hash) (bool, error)

HeaderExists checks if header with hash exists in db.

func (Database) ProcessTranfers 

func (db Database) ProcessTranfers(transfers []Transfer, accounts []common.Address, added, removed []*DBHeader, option SyncOption) (err error)

ProcessTranfers atomically adds/removes blocks and adds new tranfers.

func (*Database) SaveHeader 

func (db *Database) SaveHeader(header *types.Header) error

SaveHeader stores a single header.

func (*Database) SaveHeaders 

func (db *Database) SaveHeaders(headers []*types.Header) (err error)

SaveHeaders stores a list of headers atomically.

func (*Database) SaveSyncedHeader 

func (db *Database) SaveSyncedHeader(address common.Address, header *types.Header, option SyncOption) (err error)

type ERC20TransfersDownloader 

type ERC20TransfersDownloader struct {
	// contains filtered or unexported fields
}

ERC20TransfersDownloader is a downloader for erc20 tokens transfers.

func NewERC20TransfersDownloader 

func NewERC20TransfersDownloader(client *ethclient.Client, accounts []common.Address) *ERC20TransfersDownloader

NewERC20TransfersDownloader returns new instance.

func (*ERC20TransfersDownloader) GetTransfers 

func (d *ERC20TransfersDownloader) GetTransfers(ctx context.Context, header *DBHeader) ([]Transfer, error)

GetTransfers for erc20 uses eth_getLogs rpc with Transfer event signature and our address acount.

func (*ERC20TransfersDownloader) GetTransfersInRange 

func (d *ERC20TransfersDownloader) GetTransfersInRange(parent context.Context, from, to *big.Int) ([]Transfer, error)

GetTransfersInRange returns transfers between two blocks. time to get logs for 100000 blocks = 1.144686979s. with 249 events in the result set.

type ETHTransferDownloader 

type ETHTransferDownloader struct {
	// contains filtered or unexported fields
}

ETHTransferDownloader downloads regular eth transfers.

func (*ETHTransferDownloader) GetTransfers 

func (d *ETHTransferDownloader) GetTransfers(ctx context.Context, header *DBHeader) (rst []Transfer, err error)

GetTransfers checks if the balance was changed between two blocks. If so it downloads transaction that transfer ethereum from that block.

func (*ETHTransferDownloader) GetTransfersByNumber 

func (d *ETHTransferDownloader) GetTransfersByNumber(ctx context.Context, number *big.Int) ([]Transfer, error)

type Event 

type Event struct {
	Type        EventType        `json:"type"`
	BlockNumber *big.Int         `json:"blockNumber"`
	Accounts    []common.Address `json:"accounts"`
}

Event is a type for wallet events.

type EventType 

type EventType string

EventType type for event types. 

const (
	// EventNewBlock emitted when new block was added to the same canonical chan.
	EventNewBlock EventType = "newblock"
	// EventReorg emitted when canonical chain was changed. In this case, BlockNumber will be an earliest added block.
	EventReorg EventType = "reorg"
	// EventNewHistory emitted if transfer from older block was added.
	EventNewHistory EventType = "history"
)

type FiniteCommand 

type FiniteCommand struct {
	Interval time.Duration
	Runable  func(context.Context) error
}

FiniteCommand terminates when error is nil.

func (FiniteCommand) Run 

func (c FiniteCommand) Run(ctx context.Context) error

type Group 

type Group struct {
	// contains filtered or unexported fields
}

func NewGroup 

func NewGroup(parent context.Context) *Group

func (*Group) Add 

func (g *Group) Add(cmd Command)

func (*Group) Stop 

func (g *Group) Stop()

func (*Group) Wait 

func (g *Group) Wait()

func (*Group) WaitAsync 

func (g *Group) WaitAsync() <-chan struct{}

type HeaderReader 

type HeaderReader interface {
	HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)
	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
}

HeaderReader interface for reading headers using block number or hash.

type InfiniteCommand 

type InfiniteCommand struct {
	Interval time.Duration
	Runable  func(context.Context) error
}

InfiniteCommand runs until context is closed.

func (InfiniteCommand) Run 

func (c InfiniteCommand) Run(ctx context.Context) error

type IterativeDownloader 

type IterativeDownloader struct {
	// contains filtered or unexported fields
}

IterativeDownloader downloads batches of transfers in a specified size.

func SetupIterativeDownloader 

func SetupIterativeDownloader(
	db *Database, client HeaderReader, address common.Address, option SyncOption,
	downloader BatchDownloader, size *big.Int, to *DBHeader) (*IterativeDownloader, error)

SetupIterativeDownloader configures IterativeDownloader with last known synced block.

func (*IterativeDownloader) Finished 

func (d *IterativeDownloader) Finished() bool

Finished true when earliest block with given sync option is zero.

func (*IterativeDownloader) Header 

func (d *IterativeDownloader) Header() *DBHeader

Header return last synced header.

func (*IterativeDownloader) Next 

func (d *IterativeDownloader) Next(parent context.Context) ([]Transfer, error)

Next moves closer to the end on every new iteration.

func (*IterativeDownloader) Revert 

func (d *IterativeDownloader) Revert()

Revert reverts last step progress. Should be used if application failed to process transfers. For example failed to persist them.

type JSONBlob 

type JSONBlob struct {
	// contains filtered or unexported fields
}

JSONBlob type for marshaling/unmarshaling inner type to json.

func (*JSONBlob) Scan 

func (blob *JSONBlob) Scan(value interface{}) error

Scan implements interface.

func (*JSONBlob) Value 

func (blob *JSONBlob) Value() (driver.Value, error)

Value implements interface.

type Reactor 

type Reactor struct {
	// contains filtered or unexported fields
}

Reactor listens to new blocks and stores transfers into the database.

func NewReactor 

func NewReactor(db *Database, feed *event.Feed, client *ethclient.Client, accounts []common.Address, chain *big.Int) *Reactor

NewReactor creates instance of the Reactor.

func (*Reactor) Start 

func (r *Reactor) Start() error

Start runs reactor loop in background.

func (*Reactor) Stop 

func (r *Reactor) Stop()

Stop stops reactor loop and waits till it exits.

type Result 

type Result struct {
	// contains filtered or unexported fields
}

func (*Result) Get 

func (r *Result) Get() []Transfer

func (*Result) Push 

func (r *Result) Push(transfers ...Transfer)

type SQLBigInt 

type SQLBigInt big.Int

SQLBigInt type for storing uint256 in the databse. FIXME(dshulyak) SQL big int is max 64 bits. Maybe store as bytes in big endian and hope that lexographical sorting will work.

func (*SQLBigInt) Scan 

func (i *SQLBigInt) Scan(value interface{}) error

Scan implements interface.

func (*SQLBigInt) Value 

func (i *SQLBigInt) Value() (driver.Value, error)

Value implements interface.

type Service 

type Service struct {
	// contains filtered or unexported fields
}

Service is a wallet service.

func NewService 

func NewService() *Service

NewService initializes service instance.

func (*Service) APIs 

func (s *Service) APIs() []rpc.API

APIs returns list of available RPC APIs.

func (*Service) Protocols 

func (s *Service) Protocols() []p2p.Protocol

Protocols returns list of p2p protocols.

func (*Service) Start 

func (s *Service) Start(*p2p.Server) error

Start signals transmitter.

func (*Service) StartReactor 

func (s *Service) StartReactor(dbpath, password string, client *ethclient.Client, accounts []common.Address, chain *big.Int) error

StartReactor separately because it requires known ethereum address, which will become available only after login.

func (*Service) Stop 

func (s *Service) Stop() error

Stop reactor, signals transmitter and close db.

func (*Service) StopReactor 

func (s *Service) StopReactor() error

StopReactor stops reactor and closes database.

type SignalsTransmitter 

type SignalsTransmitter struct {
	// contains filtered or unexported fields
}

SignalsTransmitter transmits received events as wallet signals.

func (*SignalsTransmitter) Start 

func (tmr *SignalsTransmitter) Start() error

Start runs loop in background.

func (*SignalsTransmitter) Stop 

func (tmr *SignalsTransmitter) Stop()

Stop stops the loop and waits till it exits.

type SyncOption 

type SyncOption uint

SyncOption is used to specify that application processed transfers for that block.

type Transfer 

type Transfer struct {
	Type        TransferType       `json:"type"`
	ID          common.Hash        `json:"-"`
	Address     common.Address     `json:"address"`
	BlockNumber *big.Int           `json:"blockNumber"`
	BlockHash   common.Hash        `json:"blockhash"`
	Transaction *types.Transaction `json:"transaction"`
	Receipt     *types.Receipt     `json:"receipt"`
}

Transfer stores information about transfer.

type TransferDownloader 

type TransferDownloader interface {
	GetTransfersByNumber(context.Context, *big.Int) ([]Transfer, error)
}

TransferDownloader downloads transfers from single block using number.

type TransferType 

type TransferType string

TransferType type of the asset that was transferred.

Source Files

View all Source files

Directories

Path Synopsis
sql

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.