client

func (*Proxy) ElasticClient ¶

func (cp *Proxy) ElasticClient() *elasticsearch.Client

func (*Proxy) GetGenesisHeight ¶

func (cp *Proxy) GetGenesisHeight() uint64

GetGeneisisBlock parse the specific block as genesis block

func (*Proxy) LatestHeight ¶

func (cp *Proxy) LatestHeight() (int64, error)

LatestHeight returns the latest block height on the active chain. An error is returned if the query fails.

func (Proxy) RestRequestGet ¶

func (cp Proxy) RestRequestGet(endpoint string, values map[string]string) ([]byte, error)

QueryLCD queries the LCD at the given endpoint, and deserializes the result into the given pointer. If an error is raised, returns the error.

func (Proxy) RestRequestGetDecoded ¶

func (cp Proxy) RestRequestGetDecoded(endpoint string, values map[string]string, ptr interface{}) error

func (*Proxy) Stop ¶

func (cp *Proxy) Stop()

Txs queries for all the transactions in a block. Transactions are returned in the TransactionResult format which internally contains an array of Transactions. An error is returned if any query fails.

 func (cp *Proxy) Txs(block *flow.Block) (types.Txs, error) {

	var transactionIDs []flow.Identifier
	collections := cp.Collections(block)
	for _, collection := range collections {
		transactionIDs = append(transactionIDs, (collection.TransactionIds)...)
	}

	txResponses := make([]types.Tx, len(transactionIDs))
	for i, txID := range transactionIDs {
		transaction, err := cp.flowClient.GetTransaction(cp.ctx, txID)
		if err != nil {
			return nil, err
		}

		authoriser := make([]string, len(transaction.Authorizers))
		for i, auth := range transaction.Authorizers {
			authoriser[i] = auth.String()
		}

		payloadSignitures, err := json.Marshal(transaction.PayloadSignatures)
		if err != nil {
			return nil, err
		}

		envelopeSigniture, err := json.Marshal(transaction.EnvelopeSignatures)
		if err != nil {
			return nil, err
		}

		tx := types.NewTx(block.Height, txID.String(), transaction.Script, transaction.Arguments,
			transaction.ReferenceBlockID.String(), transaction.GasLimit, transaction.ProposalKey.Address.String(), transaction.Payer.String(),
			authoriser, payloadSignitures, envelopeSigniture)

		txResponses[i] = tx
	}
	return txResponses, nil
}

func (cp *Proxy) TransactionResult(transactionIds []flow.Identifier) ([]types.TransactionResult, error) {
	if len(transactionIds) == 0 {
		return nil, nil
	}

	txResults := make([]types.TransactionResult, len(transactionIds))
	for i, txid := range transactionIds {
		result, err := cp.flowClient.GetTransactionResult(cp.ctx, txid)
		if err != nil {
			return nil, err
		}
		errStr := ""
		if result.Error != nil {
			errStr = result.Error.Error()
		}
		txResults[i] = types.NewTransactionResult(txid.String(), result.Status.String(), errStr)
	}
	return txResults, nil
}

func (cp *Proxy) EventsInBlock(block *flow.Block) ([]types.Event, error) {
	txs, err := cp.Txs(block)
	if err != nil {
		return nil, err
	}
	var event []types.Event
	for _, tx := range txs {
		ev, err := cp.Events(tx.TransactionID, int(tx.Height))
		if err != nil {
			return []types.Event{}, err
		}
		event = append(event, ev...)
	}
	return event, nil
}

func (cp *Proxy) EventsInTransaction(tx types.Tx) ([]types.Event, error) {
	var event []types.Event

	ev, err := cp.Events(tx.TransactionID, int(tx.Height))
	if err != nil {
		return []types.Event{}, err
	}
	event = append(event, ev...)
	return event, nil
}

// Events get events from a transaction ID

func (cp *Proxy) Events(transactionID string, height int) ([]types.Event, error) {
	transactionResult, err := cp.flowClient.GetTransactionResult(cp.ctx, flow.HexToID(transactionID))
	if err != nil {
		return []types.Event{}, err
	}

	ev := make([]types.Event, len(transactionResult.Events))
	for i, event := range transactionResult.Events {
		ev[i] = types.NewEvent(height, event.Type, event.TransactionID.String(), event.TransactionIndex,
			event.EventIndex, event.Value)
	}
	return ev, nil
}

Stop defers the node stop execution to the RPC client.