rpc

package
v0.4.0 Latest Latest
Warning

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

 Go to latest Published: Jun 28, 2023 License: Apache-2.0 Imports: 10 Imported by: 4

README

Go Chia RPC

Library for interacting with Chia RPC. Supports both HTTP and Websocket communications.

Usage

When creating a new client, chia configuration will automatically be read from CHIA_ROOT. If chia is installed for the same user go-chia-rpc is running as, the config should be automatically discovered if it is in the default location. If the config is in a non-standard location, ensure CHIA_ROOT environment variable is set to the same value that is used for chia-blockchain.

HTTP Mode

To use HTTP mode, create a new client and specify ConnectionModeHTTP:

package main

import (
	"github.com/chia-network/go-chia-libs/pkg/rpc"
)

func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeHTTP, rpc.WithAutoConfig())
	if err != nil {
		// error happened
	}
}
HTTP Mode w/ Manual Config

To provide a manual config struct instead of using AutoConfig, use something like the following:

package main

import (
	"github.com/chia-network/go-chia-libs/pkg/config"
	"github.com/chia-network/go-chia-libs/pkg/rpc"
)

func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeHTTP, rpc.WithManualConfig(config.ChiaConfig{
		ChiaRoot: "/path/to/.chia",
		FullNode: config.FullNodeConfig{
			PortConfig: config.PortConfig{
				Port:    8444,
				RPCPort: 8555,
			},
			SSL: config.SSLConfig{
				PrivateCRT: "config/ssl/full_node/private_full_node.crt",
				PrivateKey: "config/ssl/full_node/private_full_node.key",
			},
		},
	}))
}
Websocket Mode

To use Websocket mode, specify ConnectionModeWebsocket when creating the client:

package main

import (
	"github.com/chia-network/go-chia-libs/pkg/rpc"
)

func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeWebsocket, rpc.WithAutoConfig())
	if err != nil {
		// error happened
	}
}

Websockets function asynchronously and as such, there are a few implementation differences compared to using the simpler HTTP request/response pattern. You must define a handler function to process responses received over the websocket connection, and you must also specifically subscribe to the events the handler should receive.

Handler Function

Handler functions must use the following signature: func handlerFunc(data *types.WebsocketResponse, err error). The function will be passed the data that was received from the websocket and an error.

Initializing a client, and defining and registering a handler function looks like the following:

package main

import (
	"log"
	"github.com/chia-network/go-chia-libs/pkg/rpc"
	"github.com/chia-network/go-chia-libs/pkg/types"
)

func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeWebsocket, rpc.WithAutoConfig())
	if err != nil {
		log.Fatalln(err.Error())
	}

	client.AddHandler(gotResponse)

	// Other application logic here
}

func gotResponse(data *types.WebsocketResponse, err error) {
	log.Printf("Received a `%s` command response\n", data.Command)
}

You may also use a blocking/synchronous handler function, if listening to websocket responses is all your main process is doing:

package main

import (
	"log"

	"github.com/chia-network/go-chia-libs/pkg/rpc"
	"github.com/chia-network/go-chia-libs/pkg/types"
)

func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeWebsocket, rpc.WithAutoConfig())
	if err != nil {
		log.Fatalln(err.Error())
	}

	client.ListenSync(gotResponse)

	// Other application logic here
}

func gotResponse(data *types.WebsocketResponse, err error) {
	log.Printf("Received a `%s` command response\n", data.Command)
}
Subscribing to Events

There are two helper functions to subscribe to events that come over the websocket.

client.SubscribeSelf() - Calling this method subscribes to response events for any requests made from this client

client.Subscribe(service) - Calling this method, with an appropriate service, subscribes to any events that chia may generate that are not necessarily in responses to requests made from this client (for instance, metrics events fire when relevant updates are available that may impact metrics services)

Get Transactions
HTTP Mode
client, err := rpc.NewClient(rpc.ConnectionModeHTTP, rpc.WithAutoConfig())
if err != nil {
	log.Fatal(err)
}

transactions, _, err := client.WalletService.GetTransactions(
	&rpc.GetWalletTransactionsOptions{
		WalletID: 1,
	},
)
if err != nil {
	log.Fatal(err)
}

if transactions.Transactions.IsPresent() {
    for _, transaction := range transactions.Transactions.MustGet() {
        log.Println(transaction.Name)
    }
}
Websocket Mode
func main() {
	client, err := rpc.NewClient(rpc.ConnectionModeWebsocket, rpc.WithAutoConfig())
	if err != nil {
		log.Fatalln(err.Error())
	}

	err = client.SubscribeSelf()
	if err != nil {
		log.Fatalln(err.Error())
	}

	client.AddHandler(gotResponse)

	client.WalletService.GetTransactions(
		&rpc.GetWalletTransactionsOptions{
			WalletID: 1,
		},
	)
}

func gotResponse(data *types.WebsocketResponse, err error) {
	log.Printf("Received a `%s` command response\n", data.Command)

	if data.Command == "get_transactions" {
		txns := &rpc.GetWalletTransactionsResponse{}
		err = json.Unmarshal(data.Data, txns)
		if err != nil {
			log.Fatalln(err.Error())
		}

		log.Printf("%+v", txns)
	}
}
Get Full Node Status
state, _, err := client.FullNodeService.GetBlockchainState()
if err != nil {
	log.Fatal(err)
}

if state.BlockchainState.IsPresent() {
    log.Println(state.BlockchainState.MustGet().Difficulty)	
}
Get Estimated Network Space

Gets the estimated network space and formats it to a readable version using FormatBytes utility function

//import (
//    "log"
//
//    "github.com/chia-network/go-chia-libs/pkg/rpc"
//    "github.com/chia-network/go-chia-libs/pkg/util"
//)

state, _, err := client.FullNodeService.GetBlockchainState()
if err != nil {
	log.Fatal(err)
}

if state.BlockchainState.IsPresent() {
    log.Println(state.BlockchainState.MustGet().Space)
}
Request Cache

When using HTTP mode, there is an optional request cache that can be enabled with a configurable cache duration. To use the cache, initialize the client with the rpc.WithCache() option like the following example:

client, err := rpc.NewClient(rpc.ConnectionModeHTTP, rpc.WithAutoConfig(), rpc.WithCache(60 * time.Second))
if err != nil {
	// error happened
}

This example sets the cache time to 60 seconds. Any identical requests within the 60 seconds will be served from the local cache rather than making another RPC call.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func WithAutoConfig added in v0.2.0 

func WithAutoConfig() rpcinterface.ConfigOptionFunc

WithAutoConfig automatically loads chia config from CHIA_ROOT

func WithBaseURL 

func WithBaseURL(url *url.URL) rpcinterface.ClientOptionFunc

WithBaseURL sets the host for RPC requests

func WithCache 

func WithCache(validTime time.Duration) rpcinterface.ClientOptionFunc

WithCache specify a duration http requests should be cached for If unset, cache will not be used

func WithManualConfig added in v0.2.0 

func WithManualConfig(cfg config.ChiaConfig) rpcinterface.ConfigOptionFunc

WithManualConfig allows supplying a manual configuration for the RPC client

func WithTimeout added in v0.0.20 

func WithTimeout(timeout time.Duration) rpcinterface.ClientOptionFunc

WithTimeout sets the timeout for the requests

Types

type AddKeyOptions added in v0.0.20 

type AddKeyOptions struct {
	Mnemonic []string `json:"mnemonic"`
}

AddKeyOptions options for the add_key endpoint

type AddKeyResponse added in v0.0.20 

type AddKeyResponse struct {
	Response
	Word        mo.Option[string] `json:"word,omitempty"` // This is part of a unique error response
	Fingerprint mo.Option[int]    `json:"fingerprint,omitempty"`
}

AddKeyResponse response from the add_key endpoint

type CatSpendOptions added in v0.0.4 

type CatSpendOptions struct {
	WalletID uint32 `json:"wallet_id"`
	Amount   uint64 `json:"amount"`
	Address  string `json:"inner_address"`
	Fee      uint64 `json:"fee"`
}

CatSpendOptions represents the options for cat_spend

type CatSpendResponse added in v0.0.4 

type CatSpendResponse struct {
	Response
	TransactionID mo.Option[string]                  `json:"transaction_id"`
	Transaction   mo.Option[types.TransactionRecord] `json:"transaction"`
}

CatSpendResponse represents the response from cat_spend

type Client 

type Client struct {

	// Services for the different chia services
	FullNodeService  *FullNodeService
	WalletService    *WalletService
	FarmerService    *FarmerService
	HarvesterService *HarvesterService
	CrawlerService   *CrawlerService
	DataLayerService *DataLayerService
	// contains filtered or unexported fields
}

Client is the RPC client

func NewClient 

func NewClient(connectionMode ConnectionMode, configOption rpcinterface.ConfigOptionFunc, options ...rpcinterface.ClientOptionFunc) (*Client, error)

NewClient returns a new RPC Client

Example 
package main

import (
	"bytes"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"fmt"
	"math/big"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"strconv"
	"testing"
	"time"

	"github.com/chia-network/go-chia-libs/pkg/config"
	"github.com/chia-network/go-chia-libs/pkg/types"
	"github.com/stretchr/testify/require"
)

var (
	tmpDir      string
	crtFilename = "host.crt"
	keyFilename = "host.key"
)

func setup(t *testing.T) (*http.ServeMux, *httptest.Server, *Client) {
	mux := http.NewServeMux()
	server := httptest.NewTLSServer(mux)

	// Get port from server
	u, err := url.Parse(server.URL)
	if err != nil {
		t.Fatal(err)
	}
	p, err := strconv.ParseUint(u.Port(), 10, 16)
	if err != nil {
		t.Fatal(err)
	}

	// Get temp directory used for this test back
	tmpDir, err = generateSSLFiles()
	if err != nil {
		t.Fatal(err)
	}

	// Set port config to the port of this test server
	portConf := config.PortConfig{
		RPCPort: uint16(p),
	}
	// Set SSL config for the fake cert and key we just made
	sslConf := config.SSLConfig{
		PrivateCRT: crtFilename,
		PrivateKey: keyFilename,
	}

	client, err := NewClient(ConnectionModeHTTP,
		WithManualConfig(config.ChiaConfig{
			ChiaRoot:   tmpDir,
			DaemonPort: portConf.RPCPort,
			DaemonSSL:  sslConf,
			Farmer: config.FarmerConfig{
				PortConfig: portConf,
				SSL:        sslConf,
			},
			FullNode: config.FullNodeConfig{
				PortConfig: portConf,
				SSL:        sslConf,
			},
			Harvester: config.HarvesterConfig{
				PortConfig: portConf,
				SSL:        sslConf,
			},
			Wallet: config.WalletConfig{
				PortConfig: portConf,
				SSL:        sslConf,
			},
			Seeder: config.SeederConfig{
				CrawlerConfig: config.CrawlerConfig{
					PortConfig: portConf,
					SSL:        sslConf,
				},
			},
			DataLayer: config.DataLayerConfig{
				PortConfig: portConf,
				SSL:        sslConf,
			},
		}))
	if err != nil {
		t.Fatal(err)
	}

	return mux, server, client
}

func generateSSLFiles() (string, error) {
	dir, err := os.MkdirTemp("", "*-chia")
	if err != nil {
		return "", err
	}

	key, crt, err := generateSSL()
	if err != nil {
		return dir, err
	}

	err = os.WriteFile(fmt.Sprintf("%s/%s", dir, keyFilename), key.Bytes(), 0755)
	if err != nil {
		return dir, err
	}
	err = os.WriteFile(fmt.Sprintf("%s/%s", dir, crtFilename), crt.Bytes(), 0755)
	if err != nil {
		return dir, err
	}

	return dir, nil
}

func generateSSL() (*bytes.Buffer, *bytes.Buffer, error) {
	crtTemplate := &x509.Certificate{
		SerialNumber: big.NewInt(2019),
		Subject: pkix.Name{
			Organization:  []string{"Testing, Inc."},
			Country:       []string{"US"},
			Province:      []string{"Missouri"},
			Locality:      []string{"St Louis"},
			StreetAddress: []string{"111 St Louis St"},
			PostalCode:    []string{"69420"},
		},
		IPAddresses:  []net.IP{net.IPv4(127, 0, 0, 1), net.IPv6loopback},
		NotBefore:    time.Now(),
		NotAfter:     time.Now().AddDate(10, 0, 0),
		SubjectKeyId: []byte{1, 2, 3, 4, 6},
		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
		KeyUsage:     x509.KeyUsageDigitalSignature,
	}

	key, err := rsa.GenerateKey(rand.Reader, 4096)
	if err != nil {
		return nil, nil, err
	}
	keyPEM := new(bytes.Buffer)
	err = pem.Encode(keyPEM, &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(key),
	})
	if err != nil {
		return nil, nil, err
	}

	crt, err := x509.CreateCertificate(rand.Reader, crtTemplate, crtTemplate, &key.PublicKey, key)
	if err != nil {
		return nil, nil, err
	}
	crtPEM := new(bytes.Buffer)
	err = pem.Encode(crtPEM, &pem.Block{
		Type:  "CERTIFICATE",
		Bytes: crt,
	})
	if err != nil {
		return nil, nil, err
	}

	return keyPEM, crtPEM, nil
}

func teardown(server *httptest.Server) {
	server.Close()
	err := os.RemoveAll(tmpDir)
	if err != nil {
		panic(err)
	}
}

func fixture(path string) string {
	b, err := os.ReadFile("testdata/" + path)
	if err != nil {
		panic(err)
	}
	return string(b)
}

func getBytesFromHexString(t *testing.T, hex string) types.Bytes {
	b, err := types.BytesFromHexString(hex)
	require.NoError(t, err)
	return b
}

func getBytes32FromHexString(t *testing.T, hex string) types.Bytes32 {
	b, err := types.Bytes32FromHexString(hex)
	require.NoError(t, err)
	return b
}

func main() {
	client, err := NewClient(ConnectionModeHTTP, WithAutoConfig())
	if err != nil {
		panic(err)
	}

	state, _, err := client.FullNodeService.GetBlockchainState()
	if err != nil {
		panic(err)
	}

	if state.BlockchainState.IsPresent() {
		fmt.Println(state.BlockchainState.MustGet().Space)
	}
}

Output:

func (*Client) AddDisconnectHandler 

func (c *Client) AddDisconnectHandler(onDisconnect rpcinterface.DisconnectHandler)

AddDisconnectHandler the function to call when the client is disconnected

func (*Client) AddHandler 

func (c *Client) AddHandler(handler rpcinterface.WebsocketResponseHandler) error

AddHandler adds a handler function to call when a message is received over the websocket This is expected to NOT be used in conjunction with ListenSync This will run in the background, and allow other things to happen in the foreground while ListenSync will take over the foreground process

func (*Client) AddReconnectHandler added in v0.0.12 

func (c *Client) AddReconnectHandler(onReconnect rpcinterface.ReconnectHandler)

AddReconnectHandler the function to call when the client is disconnected

func (*Client) Do 

func (c *Client) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is a helper that wraps the activeClient's Do method

func (*Client) ListenSync 

func (c *Client) ListenSync(handler rpcinterface.WebsocketResponseHandler) error

ListenSync Listens for async responses over the connection in a synchronous fashion, blocking anything else

func (*Client) NewRequest 

func (c *Client) NewRequest(service rpcinterface.ServiceType, rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest is a helper that wraps the activeClient's NewRequest method

func (*Client) Subscribe 

func (c *Client) Subscribe(service string) error

Subscribe adds a subscription to events from a particular service This is currently only useful for websocket mode

func (*Client) SubscribeSelf 

func (c *Client) SubscribeSelf() error

SubscribeSelf subscribes to responses to requests from this service This is currently only useful for websocket mode

type ConnectionMode 

type ConnectionMode uint8

ConnectionMode specifies the method used to connect to the server (HTTP or Websocket) 

const (
	// ConnectionModeHTTP uses HTTP for requests to the RPC server
	ConnectionModeHTTP ConnectionMode = iota

	// ConnectionModeWebsocket uses websockets for requests to the RPC server
	ConnectionModeWebsocket
)

type CrawlerService 

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

CrawlerService encapsulates crawler RPC methods

func (*CrawlerService) Do 

func (s *CrawlerService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*CrawlerService) GetIPsAfterTimestamp 

func (s *CrawlerService) GetIPsAfterTimestamp(opts *GetIPsAfterTimestampOptions) (*GetIPsAfterTimestampResponse, *http.Response, error)

GetIPsAfterTimestamp Returns IP addresses seen by the network after a particular timestamp

func (*CrawlerService) GetPeerCounts 

func (s *CrawlerService) GetPeerCounts() (*GetPeerCountsResponse, *http.Response, error)

GetPeerCounts crawler rpc -> get_peer_counts

func (*CrawlerService) NewRequest 

func (s *CrawlerService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the crawler service

type CreateSignedTransactionOptions added in v0.0.20 

type CreateSignedTransactionOptions struct {
	WalletID           *uint32          `json:"wallet_id,omitempty"`
	Additions          []types.Addition `json:"additions"`
	Fee                *uint64          `json:"fee,omitempty"`
	MinCoinAmount      *uint64          `json:"min_coin_amount,omitempty"`
	MaxCoinAmount      *uint64          `json:"max_coin_amount,omitempty"`
	ExcludeCoinAmounts []*uint64        `json:"exclude_coin_amounts,omitempty"`
	Coins              []types.Coin     `json:"Coins,omitempty"`
	ExcludeCoins       []types.Coin     `json:"exclude_coins,omitempty"`
}

CreateSignedTransactionOptions Options for create_signed_transaction endpoint

type CreateSignedTransactionResponse added in v0.0.20 

type CreateSignedTransactionResponse struct {
	Response
	SignedTXs mo.Option[[]types.TransactionRecord] `json:"signed_txs"`
	SignedTX  mo.Option[types.TransactionRecord]   `json:"signed_tx"`
}

CreateSignedTransactionResponse Response from create_signed_transaction

type DataLayerService added in v0.4.0 

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

DataLayerService encapsulates data layer RPC methods

func (*DataLayerService) Do added in v0.4.0 

func (s *DataLayerService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*DataLayerService) NewRequest added in v0.4.0 

func (s *DataLayerService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the wallet service

type DeleteAllKeysResponse added in v0.0.22 

type DeleteAllKeysResponse struct {
	Response
}

DeleteAllKeysResponse Delete keys response

type FarmerService added in v0.2.1 

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

FarmerService encapsulates farmer RPC methods

func (*FarmerService) Do added in v0.2.1 

func (s *FarmerService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*FarmerService) GetConnections added in v0.2.1 

func (s *FarmerService) GetConnections(opts *GetConnectionsOptions) (*GetConnectionsResponse, *http.Response, error)

GetConnections returns connections

func (*FarmerService) NewRequest added in v0.2.1 

func (s *FarmerService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the wallet service

type FullNodePushTXOptions added in v0.0.22 

type FullNodePushTXOptions struct {
	SpendBundle types.SpendBundle `json:"spend_bundle"`
}

FullNodePushTXOptions options for pushing tx to full node mempool

type FullNodePushTXResponse added in v0.0.22 

type FullNodePushTXResponse struct {
	Response
	Status mo.Option[string] `json:"status"`
}

FullNodePushTXResponse Response from full node push_tx

type FullNodeService 

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

FullNodeService encapsulates full node RPC methods

func (*FullNodeService) Do 

func (s *FullNodeService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*FullNodeService) GetAdditionsAndRemovals added in v0.2.2 

func (s *FullNodeService) GetAdditionsAndRemovals(opts *GetAdditionsAndRemovalsOptions) (*GetAdditionsAndRemovalsResponse, *http.Response, error)

GetAdditionsAndRemovals Gets additions and removals for a particular block hash

func (*FullNodeService) GetBlock 

func (s *FullNodeService) GetBlock(opts *GetBlockOptions) (*GetBlockResponse, *http.Response, error)

GetBlock full_node->get_block RPC method

func (*FullNodeService) GetBlockByHeight 

func (s *FullNodeService) GetBlockByHeight(opts *GetBlockByHeightOptions) (*GetBlockResponse, *http.Response, error)

GetBlockByHeight helper function to get a full block by height, calls full_node->get_block_record_by_height RPC method then full_node->get_block RPC method

func (*FullNodeService) GetBlockCountMetrics 

func (s *FullNodeService) GetBlockCountMetrics() (*GetBlockCountMetricsResponse, *http.Response, error)

GetBlockCountMetrics gets metrics about blocks

func (*FullNodeService) GetBlockRecordByHeight 

func (s *FullNodeService) GetBlockRecordByHeight(opts *GetBlockByHeightOptions) (*GetBlockRecordResponse, *http.Response, error)

GetBlockRecordByHeight full_node->get_block_record_by_height RPC method

func (*FullNodeService) GetBlockchainState 

func (s *FullNodeService) GetBlockchainState() (*GetBlockchainStateResponse, *http.Response, error)

GetBlockchainState returns blockchain state

func (*FullNodeService) GetBlocks 

func (s *FullNodeService) GetBlocks(opts *GetBlocksOptions) (*GetBlocksResponse, *http.Response, error)

GetBlocks full_node->get_blocks RPC method

func (*FullNodeService) GetCoinRecordByName added in v0.0.19 

func (s *FullNodeService) GetCoinRecordByName(opts *GetCoinRecordByNameOptions) (*GetCoinRecordByNameResponse, *http.Response, error)

GetCoinRecordByName request to get_coin_record_by_name endpoint

func (*FullNodeService) GetCoinRecordsByHint added in v0.3.0 

func (s *FullNodeService) GetCoinRecordsByHint(opts *GetCoinRecordsByHintOptions) (*GetCoinRecordsByHintResponse, *http.Response, error)

GetCoinRecordsByHint returns coin records for a specified puzzle hash

func (*FullNodeService) GetCoinRecordsByPuzzleHash added in v0.2.2 

func (s *FullNodeService) GetCoinRecordsByPuzzleHash(opts *GetCoinRecordsByPuzzleHashOptions) (*GetCoinRecordsByPuzzleHashResponse, *http.Response, error)

GetCoinRecordsByPuzzleHash returns coin records for a specified puzzle hash

func (*FullNodeService) GetCoinRecordsByPuzzleHashes added in v0.2.2 

func (s *FullNodeService) GetCoinRecordsByPuzzleHashes(opts *GetCoinRecordsByPuzzleHashesOptions) (*GetCoinRecordsByPuzzleHashesResponse, *http.Response, error)

GetCoinRecordsByPuzzleHashes returns coin records for a specified list of puzzle hashes

func (*FullNodeService) GetConnections 

func (s *FullNodeService) GetConnections(opts *GetConnectionsOptions) (*GetConnectionsResponse, *http.Response, error)

GetConnections returns connections

func (*FullNodeService) GetFeeEstimate added in v0.0.21 

func (s *FullNodeService) GetFeeEstimate(opts *GetFeeEstimateOptions) (*GetFeeEstimateResponse, *http.Response, error)

GetFeeEstimate endpoint

func (*FullNodeService) GetPuzzleAndSolution added in v0.1.0 

func (s *FullNodeService) GetPuzzleAndSolution(opts *GetPuzzleAndSolutionOptions) (*GetPuzzleAndSolutionResponse, *http.Response, error)

GetPuzzleAndSolution full_node-> get_puzzle_and_solution RPC method

func (*FullNodeService) NewRequest 

func (s *FullNodeService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the wallet service

func (*FullNodeService) PushTX added in v0.0.22 

func (s *FullNodeService) PushTX(opts *FullNodePushTXOptions) (*FullNodePushTXResponse, *http.Response, error)

PushTX pushes a transaction to the full node

type GenerateMnemonicResponse added in v0.0.20 

type GenerateMnemonicResponse struct {
	Response
	Mnemonic mo.Option[[]string] `json:"mnemonic"`
}

GenerateMnemonicResponse Random new 24 words response

type GetAdditionsAndRemovalsOptions added in v0.2.2 

type GetAdditionsAndRemovalsOptions struct {
	HeaderHash types.Bytes32 `json:"header_hash"`
}

GetAdditionsAndRemovalsOptions options for get_additions_and_removals

type GetAdditionsAndRemovalsResponse added in v0.2.2 

type GetAdditionsAndRemovalsResponse struct {
	Response
	Additions []types.CoinRecord `json:"additions"`
	Removals  []types.CoinRecord `json:"removals"`
}

GetAdditionsAndRemovalsResponse response for get_additions_and_removals

type GetBlockByHeightOptions 

type GetBlockByHeightOptions struct {
	BlockHeight int `json:"height"`
}

GetBlockByHeightOptions options for get_block_record_by_height and get_block rpc call

type GetBlockCountMetricsResponse 

type GetBlockCountMetricsResponse struct {
	Response
	Metrics mo.Option[types.BlockCountMetrics] `json:"metrics"`
}

GetBlockCountMetricsResponse response for get_block_count_metrics rpc call

type GetBlockOptions 

type GetBlockOptions struct {
	HeaderHash types.Bytes32 `json:"header_hash"`
}

GetBlockOptions options for get_block rpc call

type GetBlockRecordResponse 

type GetBlockRecordResponse struct {
	Response
	BlockRecord mo.Option[types.BlockRecord] `json:"block_record"`
}

GetBlockRecordResponse response from get_block_record_by_height

type GetBlockResponse 

type GetBlockResponse struct {
	Response
	Block mo.Option[types.FullBlock] `json:"block"`
}

GetBlockResponse response for get_block rpc call

type GetBlockchainStateResponse 

type GetBlockchainStateResponse struct {
	Response
	BlockchainState mo.Option[types.BlockchainState] `json:"blockchain_state,omitempty"`
}

GetBlockchainStateResponse is the blockchain state RPC response

type GetBlocksOptions 

type GetBlocksOptions struct {
	Start int `json:"start"`
	End   int `json:"end"`
	// ExcludeHeaderHash if set to true, omits the `header_hash` key from the response
	ExcludeHeaderHash bool `json:"exclude_header_hash"`
	// ExcludeReorged if set to true, excludes reorged blocks from the response
	ExcludeReorged bool `json:"exclude_reorged"`
}

GetBlocksOptions options for get_blocks rpc call

type GetBlocksResponse 

type GetBlocksResponse struct {
	Response
	Blocks mo.Option[[]types.FullBlock] `json:"blocks"`
}

GetBlocksResponse response for get_blocks rpc call

type GetCoinRecordByNameOptions added in v0.0.19 

type GetCoinRecordByNameOptions struct {
	Name string `json:"name"`
}

GetCoinRecordByNameOptions request options for /get_coin_record_by_name

type GetCoinRecordByNameResponse added in v0.0.19 

type GetCoinRecordByNameResponse struct {
	Response
	CoinRecord mo.Option[types.CoinRecord] `json:"coin_record"`
}

GetCoinRecordByNameResponse response from get_coin_record_by_name endpoint

type GetCoinRecordsByHintOptions added in v0.3.0 

type GetCoinRecordsByHintOptions struct {
	Hint              types.Bytes32 `json:"hint"`
	IncludeSpentCoins bool          `json:"include_spent_coins"`
	StartHeight       uint32        `json:"start_height,omitempty"`
	EndHeight         uint32        `json:"end_height,omitempty"`
}

GetCoinRecordsByHintOptions options for get_coin_records_by_hint

type GetCoinRecordsByHintResponse added in v0.3.0 

type GetCoinRecordsByHintResponse struct {
	Response
	CoinRecords []types.CoinRecord `json:"coin_records"`
}

GetCoinRecordsByHintResponse Response for /get_coin_records_by_hint

type GetCoinRecordsByPuzzleHashOptions added in v0.2.2 

type GetCoinRecordsByPuzzleHashOptions struct {
	PuzzleHash        types.Bytes32 `json:"puzzle_hash"`
	IncludeSpentCoins bool          `json:"include_spent_coins"`
	StartHeight       uint32        `json:"start_height,omitempty"`
	EndHeight         uint32        `json:"end_height,omitempty"`
}

GetCoinRecordsByPuzzleHashOptions request options for /get_coin_records_by_puzzle_hash

type GetCoinRecordsByPuzzleHashResponse added in v0.2.2 

type GetCoinRecordsByPuzzleHashResponse struct {
	Response
	CoinRecords []types.CoinRecord `json:"coin_records"`
}

GetCoinRecordsByPuzzleHashResponse Response for /get_coin_records_by_puzzle_hash

type GetCoinRecordsByPuzzleHashesOptions added in v0.2.2 

type GetCoinRecordsByPuzzleHashesOptions struct {
	PuzzleHash        []types.Bytes32 `json:"puzzle_hashes"`
	IncludeSpentCoins bool            `json:"include_spent_coins"`
	StartHeight       uint32          `json:"start_height,omitempty"`
	EndHeight         uint32          `json:"end_height,omitempty"`
}

GetCoinRecordsByPuzzleHashesOptions request options for /get_coin_records_by_puzzle_hash

type GetCoinRecordsByPuzzleHashesResponse added in v0.2.2 

type GetCoinRecordsByPuzzleHashesResponse struct {
	Response
	CoinRecords []types.CoinRecord `json:"coin_records"`
}

GetCoinRecordsByPuzzleHashesResponse Response for /get_coin_records_by_puzzle_hashes

type GetConnectionsOptions 

type GetConnectionsOptions struct {
	NodeType types.NodeType `json:"node_type,omitempty"`
}

GetConnectionsOptions options to filter get_connections

type GetConnectionsResponse 

type GetConnectionsResponse struct {
	Response
	Connections mo.Option[[]types.Connection] `json:"connections"`
}

GetConnectionsResponse get_connections response format

type GetFeeEstimateOptions added in v0.0.21 

type GetFeeEstimateOptions struct {
	SpendBundle *types.SpendBundle `json:"spend_bundle,omitempty"`
	Cost        uint64             `json:"cost,omitempty"`
	TargetTimes []uint64           `json:"target_times"`
}

GetFeeEstimateOptions inputs to get a fee estimate TargetTimes is a list of values corresponding to "seconds from now" to get a fee estimate for The estimated fee is the estimate of the fee required to complete the TX by the target time seconds

type GetFeeEstimateResponse added in v0.0.21 

type GetFeeEstimateResponse struct {
	Response
	Estimates         mo.Option[[]float64] `json:"estimates"`
	TargetTimes       mo.Option[[]uint64]  `json:"target_times"`
	CurrentFeeRate    mo.Option[float64]   `json:"current_fee_rate"`
	MempoolSize       mo.Option[uint64]    `json:"mempool_size"`
	MempoolMaxSize    mo.Option[uint64]    `json:"mempool_max_size"`
	FullNodeSynced    mo.Option[bool]      `json:"full_node_synced"`
	PeakHeight        mo.Option[uint32]    `json:"peak_height"`
	LastPeakTimestamp mo.Option[uint64]    `json:"last_peak_timestamp"`
	NodeTimeUTC       mo.Option[uint64]    `json:"node_time_utc"`
}

GetFeeEstimateResponse response for get_fee_estimate

type GetIPsAfterTimestampOptions 

type GetIPsAfterTimestampOptions struct {
	After  int64 `json:"after"`
	Offset uint  `json:"offset"`
	Limit  uint  `json:"limit"`
}

GetIPsAfterTimestampOptions Options for the get_ips_after_timestamp RPC call

type GetIPsAfterTimestampResponse 

type GetIPsAfterTimestampResponse struct {
	Response
	IPs   mo.Option[[]string] `json:"ips"`
	Total mo.Option[int]      `json:"total"`
}

GetIPsAfterTimestampResponse Response for get_ips_after_timestamp

type GetNFTInfoOptions added in v0.0.14 

type GetNFTInfoOptions struct {
	CoinID   string `json:"coin_id"`
	WalletID uint32 `json:"wallet_id"`
}

GetNFTInfoOptions represents the options for nft_get_info

type GetNFTInfoResponse added in v0.0.14 

type GetNFTInfoResponse struct {
	Response
	NFTInfo mo.Option[types.NFTInfo] `json:"nft_info"`
}

GetNFTInfoResponse represents the response from nft_get_info

type GetNFTsOptions added in v0.0.14 

type GetNFTsOptions struct {
	WalletID   uint32         `json:"wallet_id"`
	StartIndex mo.Option[int] `json:"start_index"`
	Num        mo.Option[int] `json:"num"`
}

GetNFTsOptions represents the options for nft_get_nfts

type GetNFTsResponse added in v0.0.14 

type GetNFTsResponse struct {
	Response
	WalletID mo.Option[uint32]          `json:"wallet_id"`
	NFTList  mo.Option[[]types.NFTInfo] `json:"nft_list"`
}

GetNFTsResponse represents the response from nft_get_nfts

type GetNextAddressOptions added in v0.0.20 

type GetNextAddressOptions struct {
	NewAddress bool   `json:"new_address"`
	WalletID   uint32 `json:"wallet_id"`
}

GetNextAddressOptions options for get_next_address endpoint

type GetNextAddressResponse added in v0.0.20 

type GetNextAddressResponse struct {
	Response
	WalletID mo.Option[uint32] `json:"wallet_id"`
	Address  mo.Option[string] `json:"address"`
}

GetNextAddressResponse response from get next address

type GetPeerCountsResponse 

type GetPeerCountsResponse struct {
	Response
	PeerCounts mo.Option[types.CrawlerPeerCounts] `json:"peer_counts"`
}

GetPeerCountsResponse Response for get_get_peer_counts on crawler

type GetPublicKeysResponse added in v0.0.20 

type GetPublicKeysResponse struct {
	Response
	PublicKeyFingerprints mo.Option[[]int] `json:"public_key_fingerprints"`
}

GetPublicKeysResponse response from get_public_keys

type GetPuzzleAndSolutionOptions added in v0.1.0 

type GetPuzzleAndSolutionOptions struct {
	CoinID types.Bytes32 `json:"coin_id"`
	Height uint32        `json:"height"`
}

GetPuzzleAndSolutionOptions options for get_puzzle_and_solution rpc call

type GetPuzzleAndSolutionResponse added in v0.1.0 

type GetPuzzleAndSolutionResponse struct {
	Response
	CoinSolution mo.Option[types.CoinSpend] `json:"coin_solution"`
}

GetPuzzleAndSolutionResponse response from get_puzzle_and_solution

type GetSpendableCoinsOptions added in v0.0.20 

type GetSpendableCoinsOptions struct {
	WalletID            uint32   `json:"wallet_id"`
	MinCoinAmount       *uint64  `json:"min_coin_amount,omitempty"`
	MaxCoinAmount       *uint64  `json:"max_coin_amount,omitempty"`
	ExcludedCoinAmounts []uint64 `json:"excluded_coin_amounts,omitempty"`
}

GetSpendableCoinsOptions Options for get_spendable_coins

type GetSpendableCoinsResponse added in v0.0.20 

type GetSpendableCoinsResponse struct {
	Response
	ConfirmedRecords     mo.Option[[]types.CoinRecord] `json:"confirmed_records"`
	UnconfirmedRemovals  mo.Option[[]types.CoinRecord] `json:"unconfirmed_removals"`
	UnconfirmedAdditions mo.Option[[]types.CoinRecord] `json:"unconfirmed_additions"`
}

GetSpendableCoinsResponse response from get_spendable_coins

type GetWalletBalanceOptions 

type GetWalletBalanceOptions struct {
	WalletID uint32 `json:"wallet_id"`
}

GetWalletBalanceOptions request options for get_wallet_balance

type GetWalletBalanceResponse 

type GetWalletBalanceResponse struct {
	Response
	Balance mo.Option[types.WalletBalance] `json:"wallet_balance"`
}

GetWalletBalanceResponse is the wallet balance RPC response

type GetWalletHeightInfoResponse 

type GetWalletHeightInfoResponse struct {
	Response
	Height mo.Option[uint32] `json:"height"`
}

GetWalletHeightInfoResponse response for get_height_info on wallet

type GetWalletNetworkInfoResponse 

type GetWalletNetworkInfoResponse struct {
	Response
	NetworkName   mo.Option[string] `json:"network_name"`
	NetworkPrefix mo.Option[string] `json:"network_prefix"`
}

GetWalletNetworkInfoResponse response for get_height_info on wallet

type GetWalletSyncStatusResponse 

type GetWalletSyncStatusResponse struct {
	Response
	GenesisInitialized mo.Option[bool] `json:"genesis_initialized"`
	Synced             mo.Option[bool] `json:"synced"`
	Syncing            mo.Option[bool] `json:"syncing"`
}

GetWalletSyncStatusResponse Response for get_sync_status on wallet

type GetWalletTransactionCountOptions 

type GetWalletTransactionCountOptions struct {
	WalletID uint32 `json:"wallet_id"`
}

GetWalletTransactionCountOptions options for get transaction count

type GetWalletTransactionCountResponse 

type GetWalletTransactionCountResponse struct {
	Response
	WalletID mo.Option[uint32] `json:"wallet_id"`
	Count    mo.Option[int]    `json:"count"`
}

GetWalletTransactionCountResponse response for get_transaction_count

type GetWalletTransactionOptions 

type GetWalletTransactionOptions struct {
	WalletID      uint32 `json:"wallet_id"`
	TransactionID string `json:"transaction_id"`
}

GetWalletTransactionOptions options for getting a single wallet transaction

type GetWalletTransactionResponse 

type GetWalletTransactionResponse struct {
	Response
	Transaction   mo.Option[types.TransactionRecord] `json:"transaction"`
	TransactionID mo.Option[string]                  `json:"transaction_id"`
}

GetWalletTransactionResponse response for get_wallet_transactions

type GetWalletTransactionsOptions 

type GetWalletTransactionsOptions struct {
	WalletID  uint32 `json:"wallet_id"`
	Start     *int   `json:"start,omitempty"`
	End       *int   `json:"end,omitempty"`
	ToAddress string `json:"to_address,omitempty"`
}

GetWalletTransactionsOptions options for get wallet transactions

type GetWalletTransactionsResponse 

type GetWalletTransactionsResponse struct {
	Response
	WalletID     mo.Option[uint32]                    `json:"wallet_id"`
	Transactions mo.Option[[]types.TransactionRecord] `json:"transactions"`
}

GetWalletTransactionsResponse response for get_wallet_transactions

type GetWalletsOptions added in v0.0.17 

type GetWalletsOptions struct {
	Type types.WalletType `json:"type"`
}

GetWalletsOptions wallet rpc -> get_wallets

type GetWalletsResponse 

type GetWalletsResponse struct {
	Response
	Fingerprint mo.Option[int]                `json:"fingerprint"`
	Wallets     mo.Option[[]types.WalletInfo] `json:"wallets"`
}

GetWalletsResponse wallet rpc -> get_wallets

type HarvesterGetPlotsResponse added in v0.0.6 

type HarvesterGetPlotsResponse struct {
	Response
	Plots                 mo.Option[[]types.PlotInfo] `json:"plots"`
	FailedToOpenFilenames mo.Option[[]string]         `json:"failed_to_open_filenames"`
	NotFoundFilenames     mo.Option[[]string]         `json:"not_found_filenames"`
}

HarvesterGetPlotsResponse get_plots response format

type HarvesterService added in v0.0.6 

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

HarvesterService encapsulates harvester RPC methods

func (*HarvesterService) Do added in v0.0.6 

func (s *HarvesterService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*HarvesterService) GetConnections added in v0.2.1 

func (s *HarvesterService) GetConnections(opts *GetConnectionsOptions) (*GetConnectionsResponse, *http.Response, error)

GetConnections returns connections

func (*HarvesterService) GetPlots added in v0.0.6 

func (s *HarvesterService) GetPlots() (*HarvesterGetPlotsResponse, *http.Response, error)

GetPlots returns connections

func (*HarvesterService) NewRequest added in v0.0.6 

func (s *HarvesterService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the wallet service

type MintNFTOptions added in v0.0.14 

type MintNFTOptions struct {
	DidID             string   `json:"did_id"`             // not required
	EditionNumber     uint32   `json:"edition_number"`     // not required
	EditionCount      uint32   `json:"edition_count"`      // not required
	Fee               uint64   `json:"fee"`                // not required
	LicenseHash       string   `json:"license_hash"`       //not required
	LicenseURIs       []string `json:"license_uris"`       // not required
	MetaHash          string   `json:"meta_hash"`          // not required
	MetaURIs          []string `json:"meta_uris"`          // not required
	RoyaltyAddress    string   `json:"royalty_address"`    // not required
	RoyaltyPercentage uint32   `json:"royalty_percentage"` // not required
	TargetAddress     string   `json:"target_address"`     // not required
	Hash              string   `json:"hash"`
	URIs              []string `json:"uris"`
	WalletID          uint32   `json:"wallet_id"`
}

MintNFTOptions represents the options for nft_get_info

type MintNFTResponse added in v0.0.14 

type MintNFTResponse struct {
	Response
	SpendBundle mo.Option[types.SpendBundle] `json:"spend_bundle"`
	WalletID    mo.Option[uint32]            `json:"wallet_id"`
}

MintNFTResponse represents the response from nft_get_info

type NFTAddURIOptions added in v0.0.14 

type NFTAddURIOptions struct {
	Fee       uint64 `json:"fee"` // not required
	Key       string `json:"key"`
	NFTCoinID string `json:"nft_coin_id"`
	URI       string `json:"uri"`
	WalletID  uint32 `json:"wallet_id"`
}

NFTAddURIOptions represents the options for nft_add_uri

type NFTAddURIResponse added in v0.0.14 

type NFTAddURIResponse struct {
	Response
	SpendBundle mo.Option[types.SpendBundle] `json:"spend_bundle"`
	WalletID    mo.Option[uint32]            `json:"wallet_id"`
}

NFTAddURIResponse represents the response from nft_add_uri

type NFTGetByDidOptions added in v0.1.0 

type NFTGetByDidOptions struct {
	DidID types.Bytes32 `json:"did_id,omitempty"`
}

NFTGetByDidOptions represents the options for nft_get_by_did

type NFTGetByDidResponse added in v0.1.0 

type NFTGetByDidResponse struct {
	Response
	WalletID mo.Option[uint32] `json:"wallet_id"`
}

NFTGetByDidResponse represents the response from nft_get_by_did

type Response added in v0.1.1 

type Response struct {
	Success bool              `json:"success"`
	Error   mo.Option[string] `json:"error,omitempty"`
}

Response is the base response elements that may be in any response from an RPC server in Chia

type SendTransactionMultiResponse added in v0.0.20 

type SendTransactionMultiResponse struct {
	Response
	Transaction   mo.Option[types.TransactionRecord] `json:"transaction"`
	TransactionID mo.Option[string]                  `json:"transaction_id"`
}

SendTransactionMultiResponse Response from send_transaction_multi

type SendTransactionOptions 

type SendTransactionOptions struct {
	WalletID uint32        `json:"wallet_id"`
	Amount   uint64        `json:"amount"`
	Address  string        `json:"address"`
	Memos    []types.Bytes `json:"memos,omitempty"`
	Fee      uint64        `json:"fee"`
	Coins    []types.Coin  `json:"coins,omitempty"`
}

SendTransactionOptions represents the options for send_transaction

type SendTransactionResponse 

type SendTransactionResponse struct {
	Response
	TransactionID mo.Option[string]                  `json:"transaction_id"`
	Transaction   mo.Option[types.TransactionRecord] `json:"transaction"`
}

SendTransactionResponse represents the response from send_transaction

type TransferNFTOptions added in v0.0.14 

type TransferNFTOptions struct {
	Fee           uint64 `json:"fee"` // not required
	NFTCoinID     string `json:"nft_coin_id"`
	TargetAddress string `json:"target_address"`
	WalletID      uint32 `json:"wallet_id"`
}

TransferNFTOptions represents the options for nft_get_info

type TransferNFTResponse added in v0.0.14 

type TransferNFTResponse struct {
	Response
	SpendBundle mo.Option[types.SpendBundle] `json:"spend_bundle"`
	WalletID    mo.Option[uint32]            `json:"wallet_id"`
}

TransferNFTResponse represents the response from nft_get_info

type WalletService 

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

WalletService encapsulates wallet RPC methods

func (*WalletService) AddKey added in v0.0.20 

func (s *WalletService) AddKey(options *AddKeyOptions) (*AddKeyResponse, *http.Response, error)

AddKey Adds a new key from 24 words to the keychain

func (*WalletService) CatSpend added in v0.0.4 

func (s *WalletService) CatSpend(opts *CatSpendOptions) (*CatSpendResponse, *http.Response, error)

CatSpend sends a transaction

func (*WalletService) CreateSignedTransaction added in v0.0.20 

func (s *WalletService) CreateSignedTransaction(opts *CreateSignedTransactionOptions) (*CreateSignedTransactionResponse, *http.Response, error)

CreateSignedTransaction generates a signed transaction based on the specified options

func (*WalletService) DeleteAllKeys added in v0.0.22 

func (s *WalletService) DeleteAllKeys() (*DeleteAllKeysResponse, *http.Response, error)

DeleteAllKeys deletes all keys from the keychain

func (*WalletService) Do 

func (s *WalletService) Do(req *rpcinterface.Request, v interface{}) (*http.Response, error)

Do is just a shortcut to the client's Do method

func (*WalletService) GenerateMnemonic added in v0.0.20 

func (s *WalletService) GenerateMnemonic() (*GenerateMnemonicResponse, *http.Response, error)

GenerateMnemonic Endpoint for generating a new random 24 words

func (*WalletService) GetConnections added in v0.2.1 

func (s *WalletService) GetConnections(opts *GetConnectionsOptions) (*GetConnectionsResponse, *http.Response, error)

GetConnections returns connections

func (*WalletService) GetHeightInfo 

func (s *WalletService) GetHeightInfo() (*GetWalletHeightInfoResponse, *http.Response, error)

GetHeightInfo wallet rpc -> get_height_info

func (*WalletService) GetNFTInfo added in v0.0.14 

func (s *WalletService) GetNFTInfo(opts *GetNFTInfoOptions) (*GetNFTInfoResponse, *http.Response, error)

GetNFTInfo Get info about an NFT

func (*WalletService) GetNFTs added in v0.0.14 

func (s *WalletService) GetNFTs(opts *GetNFTsOptions) (*GetNFTsResponse, *http.Response, error)

GetNFTs Show all NFTs in a given wallet

func (*WalletService) GetNetworkInfo 

func (s *WalletService) GetNetworkInfo() (*GetWalletNetworkInfoResponse, *http.Response, error)

GetNetworkInfo wallet rpc -> get_network_info

func (*WalletService) GetNextAddress added in v0.0.20 

func (s *WalletService) GetNextAddress(options *GetNextAddressOptions) (*GetNextAddressResponse, *http.Response, error)

GetNextAddress returns the current address for the wallet. If NewAddress is true, it moves to the next address before responding

func (*WalletService) GetPublicKeys added in v0.0.20 

func (s *WalletService) GetPublicKeys() (*GetPublicKeysResponse, *http.Response, error)

GetPublicKeys endpoint

func (*WalletService) GetSpendableCoins added in v0.0.20 

func (s *WalletService) GetSpendableCoins(opts *GetSpendableCoinsOptions) (*GetSpendableCoinsResponse, *http.Response, error)

GetSpendableCoins returns information about the coins in the wallet

func (*WalletService) GetSyncStatus 

func (s *WalletService) GetSyncStatus() (*GetWalletSyncStatusResponse, *http.Response, error)

GetSyncStatus wallet rpc -> get_sync_status

func (*WalletService) GetTransaction 

func (s *WalletService) GetTransaction(opts *GetWalletTransactionOptions) (*GetWalletTransactionResponse, *http.Response, error)

GetTransaction returns a single transaction record

func (*WalletService) GetTransactionCount 

func (s *WalletService) GetTransactionCount(opts *GetWalletTransactionCountOptions) (*GetWalletTransactionCountResponse, *http.Response, error)

GetTransactionCount returns the total count of transactions for the specific wallet ID

func (*WalletService) GetTransactions 

func (s *WalletService) GetTransactions(opts *GetWalletTransactionsOptions) (*GetWalletTransactionsResponse, *http.Response, error)

GetTransactions wallet rpc -> get_transactions

func (*WalletService) GetWalletBalance 

func (s *WalletService) GetWalletBalance(opts *GetWalletBalanceOptions) (*GetWalletBalanceResponse, *http.Response, error)

GetWalletBalance returns wallet balance

func (*WalletService) GetWallets 

func (s *WalletService) GetWallets(opts *GetWalletsOptions) (*GetWalletsResponse, *http.Response, error)

GetWallets wallet rpc -> get_wallets

func (*WalletService) MintNFT added in v0.0.14 

func (s *WalletService) MintNFT(opts *MintNFTOptions) (*MintNFTResponse, *http.Response, error)

MintNFT Mint a new NFT

func (*WalletService) NFTAddURI added in v0.0.14 

func (s *WalletService) NFTAddURI(opts *NFTAddURIOptions) (*NFTAddURIResponse, *http.Response, error)

NFTAddURI Get info about an NFT

func (*WalletService) NFTGetByDid added in v0.1.0 

func (s *WalletService) NFTGetByDid(opts *NFTGetByDidOptions) (*NFTGetByDidResponse, *http.Response, error)

NFTGetByDid Get wallet ID by DID

func (*WalletService) NewRequest 

func (s *WalletService) NewRequest(rpcEndpoint rpcinterface.Endpoint, opt interface{}) (*rpcinterface.Request, error)

NewRequest returns a new request specific to the wallet service

func (*WalletService) SendTransaction 

func (s *WalletService) SendTransaction(opts *SendTransactionOptions) (*SendTransactionResponse, *http.Response, error)

SendTransaction sends a transaction

func (*WalletService) SendTransactionMulti added in v0.0.20 

func (s *WalletService) SendTransactionMulti(opts *CreateSignedTransactionOptions) (*SendTransactionMultiResponse, *http.Response, error)

SendTransactionMulti allows sending a more detailed transaction with multiple inputs/outputs. Options are the same as create signed transaction since this is ultimately just a wrapper around that in Chia

func (*WalletService) TransferNFT added in v0.0.14 

func (s *WalletService) TransferNFT(opts *TransferNFTOptions) (*TransferNFTResponse, *http.Response, error)

TransferNFT Get info about an NFT

Source Files

View all Source files

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.