solana

README

Solana SDK library for Go

Go library to interface with Solana JSON RPC and WebSocket interfaces.

More contracts to come.

If you're using/developing Solana programs written in Anchor Framework, you can use anchor-go to generate Golang clients

If you're looking for a SERUM library, you can check out gagliardetto/serum-go (./programs/serum is deprecated.)

Future Development

solana-go is exclusively supported by my own time (which is money).

If my work has been useful in building your for-profit services/infra/bots/etc., consider donating at 47EhAdBKitfqHRv16Y6wLff8duFBNx3JLxBozcSY36ac (solana) to support future development.

Thanks!

Contents

• Solana SDK library for Go
  • Contents' Index
  • Features
  • Current development status
  • Requirements
  • Installation
  • Pretty-Print transactions/instructions
  • SendAndConfirmTransaction
  • Address Lookup Tables
  • Decode an instruction data
  • Borsh encoding/decoding
  • ZSTD account data encoding
  • Custom Headers for authenticating with RPC providers
  • Working with rate-limited RPC providers
  • Timeouts and Custom HTTP Clients
  • Examples
    • Create Account/Wallet
    • Load/parse keys
    • Transfer SOL from a wallet to another
    • RPC (index)
      • RPC examples
      • Websocket Subscription examples
  • Contributing
  • License
  • Credits

Features

• Full JSON RPC API
• Full WebSocket JSON streaming API
• Wallet, account, and keys management
• Clients for native programs
  • system
  • config
  • stake
  • vote
  • BPF Loader
  • Secp256k1
• Clients for Solana Program Library (SPL)
  • SPL token
  • associated-token-account
  • memo
  • name-service
  • ...
• Client for Serum
• Metaplex:
  • auction
  • metaplex
  • token-metadata
  • token-vault
  • nft-candy-machine
• More programs

Current development status

There is currently no stable release. The SDK is actively developed and latest is v1.8.4 which is an alpha release.

The RPC and WS client implementation is based on this RPC spec.

Note

• solana-go is in active development, so all APIs are subject to change.
• This code is unaudited. Use at your own risk.

Requirements

• Go 1.18 or later

Installation

$ cd my-project
$ go get github.com/stonecoldik/go-solana@v1.8.4

Pretty-Print transactions/instructions

Instructions can be pretty-printed with the String() method on a Transaction:

tx, err := solana.NewTransaction(
  []solana.Instruction{
    system.NewTransferInstruction(
      amount,
      accountFrom.PublicKey(),
      accountTo,
    ).Build(),
  },
  recent.Value.Blockhash,
  solana.TransactionPayer(accountFrom.PublicKey()),
)

...

// Pretty print the transaction:
fmt.Println(tx.String())
// OR you can choose a destination and a title:
// tx.EncodeTree(text.NewTreeEncoder(os.Stdout, "Transfer SOL"))

SendAndConfirmTransaction

You can wait for a transaction confirmation using the github.com/stonecoldik/go-solana/rpc/sendAndConfirmTransaction package tools (for a complete example: see here)

// Send transaction, and wait for confirmation:
sig, err := confirm.SendAndConfirmTransaction(
  context.TODO(),
  rpcClient,
  wsClient,
  tx,
)
if err != nil {
  panic(err)
}
spew.Dump(sig)

The above command will send the transaction, and wait for its confirmation.

Address Lookup Tables

Resolve lookups for a transaction:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/stonecoldik/go-solana"
	lookup "github.com/stonecoldik/go-solana/programs/address-lookup-table"
	"github.com/stonecoldik/go-solana/rpc"
	"golang.org/x/time/rate"
)

func main() {
	cluster := rpc.MainNetBeta

	rpcClient := rpc.NewWithCustomRPCClient(rpc.NewWithLimiter(
		cluster.RPC,
		rate.Every(time.Second), // time frame
		5,                       // limit of requests per time frame
	))

	version := uint64(0)
	tx, err := rpcClient.GetTransaction(
		context.Background(),
		solana.MustSignatureFromBase58("24jRjMP3medE9iMqVSPRbkwfe9GdPmLfeftKPuwRHZdYTZJ6UyzNMGGKo4BHrTu2zVj4CgFF3CEuzS79QXUo2CMC"),
		&rpc.GetTransactionOpts{
			MaxSupportedTransactionVersion: &version,
			Encoding:                       solana.EncodingBase64,
		},
	)
	if err != nil {
		panic(err)
	}
	parsed, err := tx.Transaction.GetTransaction()
	if err != nil {
		panic(err)
	}
	processTransactionWithAddressLookups(*parsed, rpcClient)
}

func processTransactionWithAddressLookups(txx solana.Transaction, rpcClient *rpc.Client) {
	if !txx.Message.IsVersioned() {
		fmt.Println("tx is not versioned; only versioned transactions can contain lookups")
		return
	}
	tblKeys := txx.Message.GetAddressTableLookups().GetTableIDs()
	if len(tblKeys) == 0 {
		fmt.Println("no lookup tables in versioned transaction")
		return
	}
	numLookups := txx.Message.GetAddressTableLookups().NumLookups()
	if numLookups == 0 {
		fmt.Println("no lookups in versioned transaction")
		return
	}
	fmt.Println("num lookups:", numLookups)
	fmt.Println("num tbl keys:", len(tblKeys))
	resolutions := make(map[solana.PublicKey]solana.PublicKeySlice)
	for _, key := range tblKeys {
		fmt.Println("Getting table", key)

		info, err := rpcClient.GetAccountInfo(
			context.Background(),
			key,
		)
		if err != nil {
			panic(err)
		}
		fmt.Println("got table "+key.String())

		tableContent, err := lookup.DecodeAddressLookupTableState(info.GetBinary())
		if err != nil {
			panic(err)
		}

		fmt.Println("table content:", spew.Sdump(tableContent))
		fmt.Println("isActive", tableContent.IsActive())

		resolutions[key] = tableContent.Addresses
	}

	err := txx.Message.SetAddressTables(resolutions)
	if err != nil {
		panic(err)
	}

	err = txx.Message.ResolveLookups()
	if err != nil {
		panic(err)
	}
	fmt.Println(txx.String())
}

Parse/decode an instruction from a transaction

package main

import (
  "context"
  "encoding/base64"
  "os"
  "reflect"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/programs/system"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/text"
)

func main() {
  exampleFromGetTransaction()
}

func exampleFromBase64() {
  encoded := "AfjEs3XhTc3hrxEvlnMPkm/cocvAUbFNbCl00qKnrFue6J53AhEqIFmcJJlJW3EDP5RmcMz+cNTTcZHW/WJYwAcBAAEDO8hh4VddzfcO5jbCt95jryl6y8ff65UcgukHNLWH+UQGgxCGGpgyfQVQV02EQYqm4QwzUt2qf9f1gVLM7rI4hwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6ANIF55zOZWROWRkeh+lExxZBnKFqbvIxZDLE7EijjoBAgIAAQwCAAAAOTAAAAAAAAA="

  data, err := base64.StdEncoding.DecodeString(encoded)
  if err != nil {
    panic(err)
  }

  // parse transaction:
  tx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(data))
  if err != nil {
    panic(err)
  }

  decodeSystemTransfer(tx)
}

func exampleFromGetTransaction() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  txSig := solana.MustSignatureFromBase58("3hZorctJtD3QLCRV3zF6JM6FDbFR5kAvsuKEG1RH9rWdz8YgnDzAvMWZFjdJgoL8KSNzZnx7aiExm1JEMC8KHfyy")
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      &rpc.GetTransactionOpts{
        Encoding: solana.EncodingBase64,
      },
    )
    if err != nil {
      panic(err)
    }

    tx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(out.Transaction.GetBinary()))
    if err != nil {
      panic(err)
    }

    decodeSystemTransfer(tx)
  }
}

func decodeSystemTransfer(tx *solana.Transaction) {
  spew.Dump(tx)

  // Get (for example) the first instruction of this transaction
  // which we know is a `system` program instruction:
  i0 := tx.Message.Instructions[0]

  // Find the program address of this instruction:
  progKey, err := tx.ResolveProgramIDIndex(i0.ProgramIDIndex)
  if err != nil {
    panic(err)
  }

  // Find the accounts of this instruction:
  accounts, err := i0.ResolveInstructionAccounts(&tx.Message)
  if err != nil {
    panic(err)
  }

  // Feed the accounts and data to the system program parser
  // OR see below for alternative parsing when you DON'T know
  // what program the instruction is for / you don't have a parser.
  inst, err := system.DecodeInstruction(accounts, i0.Data)
  if err != nil {
    panic(err)
  }

  // inst.Impl contains the specific instruction type (in this case, `inst.Impl` is a `*system.Transfer`)
  spew.Dump(inst)
  if _, ok := inst.Impl.(*system.Transfer); !ok {
    panic("the instruction is not a *system.Transfer")
  }

  // OR
  {
    // There is a more general instruction decoder: `solana.DecodeInstruction`.
    // But before you can use `solana.DecodeInstruction`,
    // you must register a decoder for each program ID beforehand
    // by using `solana.RegisterInstructionDecoder` (all solana-go program clients do it automatically with the default program IDs).
    decodedInstruction, err := solana.DecodeInstruction(
      progKey,
      accounts,
      i0.Data,
    )
    if err != nil {
      panic(err)
    }
    // The returned `decodedInstruction` is the decoded instruction.
    spew.Dump(decodedInstruction)

    // decodedInstruction == inst
    if !reflect.DeepEqual(inst, decodedInstruction) {
      panic("they are NOT equal (this would never happen)")
    }

    // To register other (not yet registered decoders), you can add them with
    // `solana.RegisterInstructionDecoder` function.
  }

  {
    // pretty-print whole transaction:
    _, err := tx.EncodeTree(text.NewTreeEncoder(os.Stdout, text.Bold("TEST TRANSACTION")))
    if err != nil {
      panic(err)
    }
  }
}

Borsh encoding/decoding

You can use the github.com/gagliardetto/binary package for encoding/decoding borsh-encoded data:

Decoder:

  resp, err := client.GetAccountInfo(
    context.TODO(),
    pubKey,
  )
  if err != nil {
    panic(err)
  }

  borshDec := bin.NewBorshDecoder(resp.GetBinary())
  var meta token_metadata.Metadata
  err = borshDec.Decode(&meta)
  if err != nil {
    panic(err)
  }

Encoder:

buf := new(bytes.Buffer)
borshEncoder := bin.NewBorshEncoder(buf)
err := borshEncoder.Encode(meta)
if err != nil {
  panic(err)
}
// fmt.Print(buf.Bytes())

ZSTD account data encoding

You can request account data to be encoded with base64+zstd in the Encoding parameter:

resp, err := client.GetAccountInfoWithOpts(
  context.TODO(),
  pubKey,
  &rpc.GetAccountInfoOpts{
    Encoding:   solana.EncodingBase64Zstd,
    Commitment: rpc.CommitmentFinalized,
  },
)
if err != nil {
  panic(err)
}
spew.Dump(resp)

var mint token.Mint
err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
if err != nil {
  panic(err)
}
spew.Dump(mint)

Working with rate-limited RPC providers

package main

import (
  "context"

  "golang.org/x/time/rate"
  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  cluster := rpc.MainNetBeta
  client := rpc.NewWithCustomRPCClient(rpc.NewWithLimiter(
		cluster.RPC,
		rate.Every(time.Second), // time frame
		5,                       // limit of requests per time frame
	))

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

Custom Headers for authenticating with RPC providers

package main

import (
  "context"

  "golang.org/x/time/rate"
  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  cluster := rpc.MainNetBeta
  client := rpc.NewWithHeaders(
    cluster.RPC,
    map[string]string{
      "x-api-key": "...",
    },
  )

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

The data will AUTOMATICALLY get decoded and returned (the right decoder will be used) when you call the resp.GetBinary() method.

Timeouts and Custom HTTP Clients

You can use a timeout context:

ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
defer cancel()
acc, err := rpcClient.GetAccountInfoWithOpts(
  ctx,
  accountID,
  &rpc.GetAccountInfoOpts{
    Commitment: rpc.CommitmentProcessed,
  },
)

Or you can initialize the RPC client using a custom HTTP client using rpc.NewWithCustomRPCClient:

import (
  "net"
  "net/http"
  "time"

  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/jsonrpc"
)

func NewHTTPTransport(
  timeout time.Duration,
  maxIdleConnsPerHost int,
  keepAlive time.Duration,
) *http.Transport {
  return &http.Transport{
    IdleConnTimeout:     timeout,
    MaxIdleConnsPerHost: maxIdleConnsPerHost,
    Proxy:               http.ProxyFromEnvironment,
    Dial: (&net.Dialer{
      Timeout:   timeout,
      KeepAlive: keepAlive,
    }).Dial,
  }
}

// NewHTTP returns a new Client from the provided config.
func NewHTTP(
  timeout time.Duration,
  maxIdleConnsPerHost int,
  keepAlive time.Duration,
) *http.Client {
  tr := NewHTTPTransport(
    timeout,
    maxIdleConnsPerHost,
    keepAlive,
  )

  return &http.Client{
    Timeout:   timeout,
    Transport: tr,
  }
}

// NewRPC creates a new Solana JSON RPC client.
func NewRPC(rpcEndpoint string) *rpc.Client {
  var (
    defaultMaxIdleConnsPerHost = 10
    defaultTimeout             = 25 * time.Second
    defaultKeepAlive           = 180 * time.Second
  )
  opts := &jsonrpc.RPCClientOpts{
    HTTPClient: NewHTTP(
      defaultTimeout,
      defaultMaxIdleConnsPerHost,
      defaultKeepAlive,
    ),
  }
  rpcClient := jsonrpc.NewClientWithOpts(rpcEndpoint, opts)
  return rpc.NewWithCustomRPCClient(rpcClient)
}

Examples

Create account (wallet)

package main

import (
  "context"
  "fmt"

  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  // Create a new account:
  account := solana.NewWallet()
  fmt.Println("account private key:", account.PrivateKey)
  fmt.Println("account public key:", account.PublicKey())

  // Create a new RPC client:
  client := rpc.New(rpc.TestNet_RPC)

  // Airdrop 1 SOL to the new account:
  out, err := client.RequestAirdrop(
    context.TODO(),
    account.PublicKey(),
    solana.LAMPORTS_PER_SOL*1,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  fmt.Println("airdrop transaction signature:", out)
}

Load/parse private and public keys

{
  // Load private key from a json file generated with
  // $ solana-keygen new --outfile=standard.solana-keygen.json
  privateKey, err := solana.PrivateKeyFromSolanaKeygenFile("/path/to/standard.solana-keygen.json")
  if err != nil {
    panic(err)
  }
  fmt.Println("private key:", privateKey.String())
  // To get the public key, you need to call the `PublicKey()` method:
  publicKey := privateKey.PublicKey()
  // To get the base58 string of a public key, you can call the `String()` method:
  fmt.Println("public key:", publicKey.String())
}

{
  // Load private key from base58:
  {
    privateKey, err := solana.PrivateKeyFromBase58("66cDvko73yAf8LYvFMM3r8vF5vJtkk7JKMgEKwkmBC86oHdq41C7i1a2vS3zE1yCcdLLk6VUatUb32ZzVjSBXtRs")
    if err != nil {
      panic(err)
    }
    fmt.Println("private key:", privateKey.String())
    fmt.Println("public key:", privateKey.PublicKey().String())
  }
  // OR:
  {
    privateKey := solana.MustPrivateKeyFromBase58("66cDvko73yAf8LYvFMM3r8vF5vJtkk7JKMgEKwkmBC86oHdq41C7i1a2vS3zE1yCcdLLk6VUatUb32ZzVjSBXtRs")
    _ = privateKey
  }
}

{
  // Generate a new key pair:
  {
    privateKey, err := solana.NewRandomPrivateKey()
    if err != nil {
      panic(err)
    }
    _ = privateKey
  }
  {
    { // Generate a new private key (a Wallet struct is just a wrapper around a private key)
      account := solana.NewWallet()
      _ = account
    }
  }
}

{
  // Parse a public key from a base58 string:
  {
    publicKey, err := solana.PublicKeyFromBase58("F8UvVsKnzWyp2nF8aDcqvQ2GVcRpqT91WDsAtvBKCMt9")
    if err != nil {
      panic(err)
    }
    _ = publicKey
  }
  // OR:
  {
    publicKey := solana.MustPublicKeyFromBase58("F8UvVsKnzWyp2nF8aDcqvQ2GVcRpqT91WDsAtvBKCMt9")
    _ = publicKey
  }
}

Transfer Sol from one wallet to another wallet

package main

import (
  "context"
  "fmt"
  "os"
  "time"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/programs/system"
  "github.com/stonecoldik/go-solana/rpc"
  confirm "github.com/stonecoldik/go-solana/rpc/sendAndConfirmTransaction"
  "github.com/stonecoldik/go-solana/rpc/jsonrpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
  "github.com/stonecoldik/go-solana/text"
)

func main() {
  // Create a new RPC client:
  rpcClient := rpc.New(rpc.DevNet_RPC)

  // Create a new WS client (used for confirming transactions)
  wsClient, err := ws.Connect(context.Background(), rpc.DevNet_WS)
  if err != nil {
    panic(err)
  }

  // Load the account that you will send funds FROM:
  accountFrom, err := solana.PrivateKeyFromSolanaKeygenFile("/path/to/.config/solana/id.json")
  if err != nil {
    panic(err)
  }
  fmt.Println("accountFrom private key:", accountFrom)
  fmt.Println("accountFrom public key:", accountFrom.PublicKey())

  // The public key of the account that you will send sol TO:
  accountTo := solana.MustPublicKeyFromBase58("TODO")
  // The amount to send (in lamports);
  // 1 sol = 1000000000 lamports
  amount := uint64(3333)

  if true {
    // Airdrop 1 sol to the account so it will have something to transfer:
    out, err := rpcClient.RequestAirdrop(
      context.TODO(),
      accountFrom.PublicKey(),
      solana.LAMPORTS_PER_SOL*1,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    fmt.Println("airdrop transaction signature:", out)
    time.Sleep(time.Second * 5)
  }
  //---------------

  recent, err := rpcClient.GetRecentBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  tx, err := solana.NewTransaction(
    []solana.Instruction{
      system.NewTransferInstruction(
        amount,
        accountFrom.PublicKey(),
        accountTo,
      ).Build(),
    },
    recent.Value.Blockhash,
    solana.TransactionPayer(accountFrom.PublicKey()),
  )
  if err != nil {
    panic(err)
  }

  _, err = tx.Sign(
    func(key solana.PublicKey) *solana.PrivateKey {
      if accountFrom.PublicKey().Equals(key) {
        return &accountFrom
      }
      return nil
    },
  )
  if err != nil {
    panic(fmt.Errorf("unable to sign transaction: %w", err))
  }
  spew.Dump(tx)
  // Pretty print the transaction:
  tx.EncodeTree(text.NewTreeEncoder(os.Stdout, "Transfer SOL"))

  // Send transaction, and wait for confirmation:
  sig, err := confirm.SendAndConfirmTransaction(
    context.TODO(),
    rpcClient,
    wsClient,
    tx,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(sig)

  // Or just send the transaction WITHOUT waiting for confirmation:
  // sig, err := rpcClient.SendTransactionWithOpts(
  //   context.TODO(),
  //   tx,
  //   false,
  //   rpc.CommitmentFinalized,
  // )
  // if err != nil {
  //   panic(err)
  // }
  // spew.Dump(sig)
}

RPC usage examples

• RPC Methods
  • GetAccountInfo
  • GetBalance
  • GetBlock
  • GetBlockCommitment
  • GetBlockHeight
  • GetBlockProduction
  • GetBlockTime
  • GetBlocks
  • GetBlocksWithLimit
  • GetClusterNodes
  • GetConfirmedBlock
    • DEPRECATED: Please use GetBlock instead (This method is expected to be removed in solana-core v2.0)
  • GetConfirmedBlocks
    • DEPRECATED: Please use GetBlocks instead (This method is expected to be removed in solana-core v2.0)
  • GetConfirmedBlocksWithLimit
    • DEPRECATED: Please use GetBlocksWithLimit instead (This method is expected to be removed in solana-core v2.0)
  • GetConfirmedSignaturesForAddress2
    • DEPRECATED: Please use GetSignaturesForAddress instead (This method is expected to be removed in solana-core v2.0)
  • GetConfirmedTransaction
    • DEPRECATED: Please use GetTransaction instead (This method is expected to be removed in solana-core v2.0)
  • GetEpochInfo
  • GetEpochSchedule
  • GetFeeCalculatorForBlockhash
    • DEPRECATED: Please use IsBlockhashValid or GetFeeForMessage instead (This method is expected to be removed in solana-core v2.0)
  • GetFeeRateGovernor DEPRECATED
  • GetFees
    • DEPRECATED: Please use GetFeeForMessage instead (This method is expected to be removed in solana-core v2.0)
  • GetFeeForMessage
  • GetFirstAvailableBlock
  • GetGenesisHash
  • GetHealth
  • GetHighestSnapshotSlot
  • GetLatestBlockhash
  • GetIdentity
  • GetInflationGovernor
  • GetInflationRate
  • GetInflationReward
  • GetLargestAccounts
  • GetLeaderSchedule
  • GetMaxRetransmitSlot
  • GetMaxShredInsertSlot
  • GetMinimumBalanceForRentExemption
  • GetMultipleAccounts
  • GetProgramAccounts
  • GetRecentBlockhash
    • To be used with solana v1.8
    • For solana v1.9 or newer: DEPRECATED: Please use GetLatestBlockhash instead (This method is expected to be removed in solana-core v2.0)
  • GetRecentPerformanceSamples
  • GetRecentPrioritizationFees
  • GetSignatureStatuses
  • GetSignaturesForAddress
  • GetSlot
  • GetSlotLeader
  • GetSlotLeaders
  • GetSnapshotSlot
    • DEPRECATED: Please use GetHighestSnapshotSlot instead (This method is expected to be removed in solana-core v2.0)
  • GetStakeActivation
  • GetSupply
  • GetTokenAccountBalance
  • GetTokenAccountsByDelegate
  • GetTokenAccountsByOwner
  • GetTokenLargestAccounts
  • GetTokenSupply
  • GetTransaction
  • GetTransactionCount
  • GetVersion
  • GetVoteAccounts
  • IsBlockhashValid
  • MinimumLedgerSlot
  • RequestAirdrop
  • SendTransaction
  • SimulateTransaction
• Websocket Subscriptions
  • AccountSubscribe
  • LogsSubscribe
  • ProgramSubscribe
  • RootSubscribe
  • SignatureSubscribe
  • SlotSubscribe
  • VoteSubscribe

RPC Methods

index > RPC > GetAccountInfo

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  solana "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/programs/token"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  {
    pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
    // basic usage
    resp, err := client.GetAccountInfo(
      context.TODO(),
      pubKey,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(resp)

    var mint token.Mint
    // Account{}.Data.GetBinary() returns the *decoded* binary data
    // regardless the original encoding (it can handle them all).
    err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
    // NOTE: The supply is mint.Supply, with the mint.Decimals:
    // mint.Supply = 9998022451607088
    // mint.Decimals = 6
    // ... which means that the supply is 9998022451.607088
  }
  {
    // Or you can use `GetAccountDataInto` which does all of the above in one call:
    pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
    var mint token.Mint
    // Get the account, and decode its data into the provided mint object:
    err := client.GetAccountDataInto(
      context.TODO(),
      pubKey,
      &mint,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
  }
  {
    // // Or you can use `GetAccountDataBorshInto` which does all of the above in one call but for borsh-encoded data:
    // var metadata token_metadata.Metadata
    // // Get the account, and decode its data into the provided metadata object:
    // err := client.GetAccountDataBorshInto(
    //   context.TODO(),
    //   pubKey,
    //   &metadata,
    // )
    // if err != nil {
    //   panic(err)
    // }
    // spew.Dump(metadata)
  }
  {
    pubKey := solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R") // raydium token
    // advanced usage
    resp, err := client.GetAccountInfoWithOpts(
      context.TODO(),
      pubKey,
      // You can specify more options here:
      &rpc.GetAccountInfoOpts{
        Encoding:   solana.EncodingBase64Zstd,
        Commitment: rpc.CommitmentFinalized,
        // You can get just a part of the account data by specify a DataSlice:
        // DataSlice: &rpc.DataSlice{
        //  Offset: pointer.ToUint64(0),
        //  Length: pointer.ToUint64(1024),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(resp)

    var mint token.Mint
    err = bin.NewDecoder(resp.GetBinary()).Decode(&mint)
    if err != nil {
      panic(err)
    }
    spew.Dump(mint)
  }
}

index > RPC > GetBalance

package main

import (
  "context"
  "fmt"
  "math/big"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("7xLk17EQQ5KLDLDe44wCmupJKJjTGd8hs3eSVVhCx932")
  out, err := client.GetBalance(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Value) // total lamports on the account; 1 sol = 1000000000 lamports

  var lamportsOnAccount = new(big.Float).SetUint64(uint64(out.Value))
  // Convert lamports to sol:
  var solBalance = new(big.Float).Quo(lamportsOnAccount, new(big.Float).SetUint64(solana.LAMPORTS_PER_SOL))

  // WARNING: this is not a precise conversion.
  fmt.Println("◎", solBalance.Text('f', 10))
}

index > RPC > GetBlock

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  {
    out, err := client.GetBlock(context.TODO(), uint64(example.Context.Slot))
    if err != nil {
      panic(err)
    }
    // spew.Dump(out) // NOTE: This generates a lot of output.
    spew.Dump(len(out.Transactions))
  }

  {
    includeRewards := false
    out, err := client.GetBlockWithOpts(
      context.TODO(),
      uint64(example.Context.Slot),
      // You can specify more options here:
      &rpc.GetBlockOpts{
        Encoding:   solana.EncodingBase64,
        Commitment: rpc.CommitmentFinalized,
        // Get only signatures:
        TransactionDetails: rpc.TransactionDetailsSignatures,
        // Exclude rewards:
        Rewards: &includeRewards,
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetBlockCommitment

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(context.TODO(), rpc.CommitmentFinalized)
  if err != nil {
    panic(err)
  }

  out, err := client.GetBlockCommitment(
    context.TODO(),
    uint64(example.Context.Slot),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlockHeight

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetBlockHeight(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlockProduction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  {
    out, err := client.GetBlockProduction(context.TODO())
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    out, err := client.GetBlockProductionWithOpts(
      context.TODO(),
      &rpc.GetBlockProductionOpts{
        Commitment: rpc.CommitmentFinalized,
        // Range: &rpc.SlotRangeRequest{
        //  FirstSlot: XXXXXX,
        //  Identity:  solana.MustPublicKeyFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetBlockTime

package main

import (
  "context"
  "time"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetBlockTime(
    context.TODO(),
    uint64(example.Context.Slot),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Time().Format(time.RFC1123))
}

index > RPC > GetBlocks

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  endSlot := uint64(example.Context.Slot)
  out, err := client.GetBlocks(
    context.TODO(),
    uint64(example.Context.Slot-3),
    &endSlot,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetBlocksWithLimit

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  limit := uint64(4)
  out, err := client.GetBlocksWithLimit(
    context.TODO(),
    uint64(example.Context.Slot-10),
    limit,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetClusterNodes

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetClusterNodes(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetConfirmedBlock

package main

import (
  "context"

  "github.com/AlekSi/pointer"
  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  { // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlock(
      context.TODO(),
      uint64(example.Context.Slot),
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    slot := uint64(example.Context.Slot)
    out, err := client.GetConfirmedBlockWithOpts(
      context.TODO(),
      slot,
      // You can specify more options here:
      &rpc.GetConfirmedBlockOpts{
        Encoding:   solana.EncodingBase64,
        Commitment: rpc.CommitmentFinalized,
        // Get only signatures:
        TransactionDetails: rpc.TransactionDetailsSignatures,
        // Exclude rewards:
        Rewards: pointer.ToBool(false),
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedBlocks

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  {
    endSlot := uint64(example.Context.Slot)
    // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlocks(
      context.TODO(),
      uint64(example.Context.Slot-3),
      &endSlot,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedBlocksWithLimit

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  limit := uint64(3)
  { // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedBlocksWithLimit(
      context.TODO(),
      uint64(example.Context.Slot-10),
      limit,
      rpc.CommitmentFinalized,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedSignaturesForAddress2

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  {
    // deprecated and is going to be removed in solana-core v1.8
    out, err := client.GetConfirmedSignaturesForAddress2(
      context.TODO(),
      pubKey,
      // TODO:
      nil,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetConfirmedTransaction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  // Let's get a valid transaction to use in the example:
  example, err := client.GetConfirmedSignaturesForAddress2(
    context.TODO(),
    pubKey,
    nil,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetConfirmedTransaction(
    context.TODO(),
    example[0].Signature,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetEpochInfo

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetEpochInfo(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetEpochSchedule

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetEpochSchedule(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeCalculatorForBlockhash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetFeeCalculatorForBlockhash(
    context.TODO(),
    example.Value.Blockhash,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeRateGovernor

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFeeRateGovernor(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFees

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFees(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetFeeForMessage

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetFeeForMessage(
    context.Background(),
    "AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA",
    rpc.CommitmentProcessed,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetFirstAvailableBlock

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetFirstAvailableBlock(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetGenesisHash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetGenesisHash(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetHealth

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetHealth(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out == rpc.HealthOk)
}

index > RPC > GetHighestSnapshotSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetHighestSnapshotSlot(
    context.Background(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetLatestBlockhash

NEW: This method is only available in solana-core v1.9 or newer. Please use getRecentBlockhash for solana-core v1.8

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  example, err := client.GetLatestBlockhash(
    context.Background(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(example)
}

index > RPC > GetIdentity

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetIdentity(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationGovernor

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetInflationGovernor(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationRate

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetInflationRate(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetInflationReward

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("6dmNQ5jwLeLk5REvio1JcMshcbvkYMwy26sJ8pbkvStu")

  out, err := client.GetInflationReward(
    context.TODO(),
    []solana.PublicKey{
      pubKey,
    },
    &rpc.GetInflationRewardOpts{
      Commitment: rpc.CommitmentFinalized,
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetLargestAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetLargestAccounts(
    context.TODO(),
    rpc.CommitmentFinalized,
    rpc.LargestAccountsFilterCirculating,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetLeaderSchedule

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetLeaderSchedule(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out) // NOTE: this creates a lot of output
}

index > RPC > GetMaxRetransmitSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetMaxRetransmitSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMaxShredInsertSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetMaxShredInsertSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMinimumBalanceForRentExemption

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  dataSize := uint64(1024 * 9)
  out, err := client.GetMinimumBalanceForRentExemption(
    context.TODO(),
    dataSize,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetMultipleAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  {
    out, err := client.GetMultipleAccounts(
      context.TODO(),
      solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt"),  // serum token
      solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R"), // raydium token
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
  {
    out, err := client.GetMultipleAccountsWithOpts(
      context.TODO(),
      []solana.PublicKey{solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt"), // serum token
        solana.MustPublicKeyFromBase58("4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R"), // raydium token
      },
      &rpc.GetMultipleAccountsOpts{
        Encoding:   solana.EncodingBase64Zstd,
        Commitment: rpc.CommitmentFinalized,
        // You can get just a part of the account data by specify a DataSlice:
        // DataSlice: &rpc.DataSlice{
        //  Offset: pointer.ToUint64(0),
        //  Length: pointer.ToUint64(1024),
        // },
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
  }
}

index > RPC > GetProgramAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetProgramAccounts(
    context.TODO(),
    solana.MustPublicKeyFromBase58("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(len(out))
  spew.Dump(out) // NOTE: this can generate a lot of output
}

index > RPC > GetRecentBlockhash

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  recent, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(recent)
}

index > RPC > GetRecentPerformanceSamples

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  limit := uint(3)
  out, err := client.GetRecentPerformanceSamples(
    context.TODO(),
    &limit,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetRecentPrioritizationFees

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetRecentPrioritizationFees(
    context.TODO(),
    []solana.PublicKey{
      solana.MustPublicKeyFromBase58("q5BgreVhTyBH1QCeriVb7kQYEPneanFXPLjvyjdf8M3"),
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSignatureStatuses

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSignatureStatuses(
    context.TODO(),
    true,
    // All the transactions you want the get the status for:
    solana.MustSignatureFromBase58("2CwH8SqVZWFa1EvsH7vJXGFors1NdCuWJ7Z85F8YqjCLQ2RuSHQyeGKkfo1Tj9HitSTeLoMWnxpjxF2WsCH8nGWh"),
    solana.MustSignatureFromBase58("5YJHZPeHZuZjhunBc1CCB1NDRNf2tTJNpdb3azGsR7PfyEncCDhr95wG8EWrvjNXBc4wCKixkheSbCxoC2NCG3X7"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSignaturesForAddress

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSignaturesForAddress(
    context.TODO(),
    solana.MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSlot(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlotLeader

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSlotLeader(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSlotLeaders

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  recent, err := client.GetRecentBlockhash(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }

  out, err := client.GetSlotLeaders(
    context.TODO(),
    uint64(recent.Context.Slot),
    10,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSnapshotSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSnapshotSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetStakeActivation

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("EW2p7QCJNHMVj5nQCcW7Q2BDETtNBXn68FyucU4RCjvb")
  out, err := client.GetStakeActivation(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
    nil,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetSupply

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetSupply(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountBalance

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("EzK5qLWhftu8Z2znVa5fozVtobbjhd8Gdu9hQHpC8bec")
  out, err := client.GetTokenAccountBalance(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountsByDelegate

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("AfkALUPjQp8R1rUwE6KhT38NuTYWCncwwHwcJu7UtAfV")
  out, err := client.GetTokenAccountsByDelegate(
    context.TODO(),
    pubKey,
    &rpc.GetTokenAccountsConfig{
      Mint: solana.MustPublicKeyFromBase58("So11111111111111111111111111111111111111112"),
    },
    nil,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenAccountsByOwner

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  bin "github.com/gagliardetto/binary"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/programs/token"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("7HZaCWazgTuuFuajxaaxGYbGnyVKwxvsJKue1W4Nvyro")
  out, err := client.GetTokenAccountsByOwner(
    context.TODO(),
    pubKey,
    &rpc.GetTokenAccountsConfig{
      Mint: solana.WrappedSol.ToPointer(),
    },
    &rpc.GetTokenAccountsOpts{
      Encoding: solana.EncodingBase64Zstd,
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)

  {
    tokenAccounts := make([]token.Account, 0)
    for _, rawAccount := range out.Value {
      var tokAcc token.Account

      data := rawAccount.Account.Data.GetBinary()
      dec := bin.NewBinDecoder(data)
      err := dec.Decode(&tokAcc)
      if err != nil {
        panic(err)
      }
      tokenAccounts = append(tokenAccounts, tokAcc)
    }
    spew.Dump(tokenAccounts)
  }
}

index > RPC > GetTokenLargestAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  out, err := client.GetTokenLargestAccounts(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTokenSupply

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  pubKey := solana.MustPublicKeyFromBase58("SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt") // serum token
  out, err := client.GetTokenSupply(
    context.TODO(),
    pubKey,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetTransaction

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  txSig := solana.MustSignatureFromBase58("4bjVLV1g9SAfv7BSAdNnuSPRbSscADHFe4HegL6YVcuEBMY83edLEvtfjE4jfr6rwdLwKBQbaFiGgoLGtVicDzHq")
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      &rpc.GetTransactionOpts{
        Encoding: solana.EncodingBase64,
      },
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
    spew.Dump(out.Transaction.GetBinary())

    decodedTx, err := solana.TransactionFromDecoder(bin.NewBinDecoder(out.Transaction.GetBinary()))
    if err != nil {
      panic(err)
    }
    spew.Dump(decodedTx)
  }
  {
    out, err := client.GetTransaction(
      context.TODO(),
      txSig,
      nil,
    )
    if err != nil {
      panic(err)
    }
    spew.Dump(out)
    spew.Dump(out.Transaction.GetParsedTransaction())
  }
}

index > RPC > GetTransactionCount

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetTransactionCount(
    context.TODO(),
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetVersion

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetVersion(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > GetVoteAccounts

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.GetVoteAccounts(
    context.TODO(),
    &rpc.GetVoteAccountsOpts{
      VotePubkey: solana.MustPublicKeyFromBase58("vot33MHDqT6nSwubGzqtc6m16ChcUywxV7tNULF19Vu"),
    },
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > IsBlockhashValid

package main

import (
  "context"
  "fmt"
  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.MainNetBeta_RPC
  client := rpc.New(endpoint)

  blockHash := solana.MustHashFromBase58("J7rBdM6AecPDEZp8aPq5iPSNKVkU5Q76F3oAV4eW5wsW")
  out, err := client.IsBlockhashValid(
    context.TODO(),
    blockHash,
    rpc.CommitmentFinalized,
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
  spew.Dump(out.Value) // true or false

  fmt.Println("is blockhash valid:", out.Value)
}

index > RPC > MinimumLedgerSlot

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  out, err := client.MinimumLedgerSlot(
    context.TODO(),
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > RequestAirdrop

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
)

func main() {
  endpoint := rpc.TestNet_RPC
  client := rpc.New(endpoint)

  amount := solana.LAMPORTS_PER_SOL // 1 sol
  pubKey := solana.MustPublicKeyFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
  out, err := client.RequestAirdrop(
    context.TODO(),
    pubKey,
    amount,
    "",
  )
  if err != nil {
    panic(err)
  }
  spew.Dump(out)
}

index > RPC > SendTransaction

package main

func main() {

}

index > RPC > SimulateTransaction

package main

func main() {

}

Websocket Subscriptions

index > WS Subscriptions > AccountSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin") // serum

  {
    sub, err := client.AccountSubscribe(
      program,
      "",
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv()
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
  if false {
    sub, err := client.AccountSubscribeWithOpts(
      program,
      "",
      // You can specify the data encoding of the returned accounts:
      solana.EncodingBase64,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv()
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
}

index > WS Subscriptions > LogsSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin") // serum

  {
    // Subscribe to log events that mention the provided pubkey:
    sub, err := client.LogsSubscribeMentions(
      program,
      rpc.CommitmentRecent,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv()
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
  if false {
    // Subscribe to all log events:
    sub, err := client.LogsSubscribe(
      ws.LogsSubscribeFilterAll,
      rpc.CommitmentRecent,
    )
    if err != nil {
      panic(err)
    }
    defer sub.Unsubscribe()

    for {
      got, err := sub.Recv()
      if err != nil {
        panic(err)
      }
      spew.Dump(got)
    }
  }
}

index > WS Subscriptions > ProgramSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }
  program := solana.MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") // token

  sub, err := client.ProgramSubscribeWithOpts(
    program,
    rpc.CommitmentRecent,
    solana.EncodingBase64Zstd,
    nil,
  )
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv()
    if err != nil {
      panic(err)
    }
    spew.Dump(got)

    decodedBinary := got.Value.Account.Data.GetBinary()
    if decodedBinary != nil {
      // spew.Dump(decodedBinary)
    }

    // or if you requested solana.EncodingJSONParsed and it is supported:
    rawJSON := got.Value.Account.Data.GetRawJSON()
    if rawJSON != nil {
      // spew.Dump(rawJSON)
    }
  }
}

index > WS Subscriptions > RootSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  sub, err := client.RootSubscribe()
  if err != nil {
    panic(err)
  }

  for {
    got, err := sub.Recv()
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > SignatureSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  txSig := solana.MustSignatureFromBase58("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")

  sub, err := client.SignatureSubscribe(
    txSig,
    "",
  )
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv()
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > SlotSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.TestNet_WS)
  if err != nil {
    panic(err)
  }

  sub, err := client.SlotSubscribe()
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv()
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

index > WS Subscriptions > VoteSubscribe

package main

import (
  "context"

  "github.com/davecgh/go-spew/spew"
  "github.com/stonecoldik/go-solana/rpc"
  "github.com/stonecoldik/go-solana/rpc/ws"
)

func main() {
  client, err := ws.Connect(context.Background(), rpc.MainNetBeta_WS)
  if err != nil {
    panic(err)
  }

  // NOTE: this subscription must be enabled by the node you're connecting to.
  // This subscription is disabled by default.
  sub, err := client.VoteSubscribe()
  if err != nil {
    panic(err)
  }
  defer sub.Unsubscribe()

  for {
    got, err := sub.Recv()
    if err != nil {
      panic(err)
    }
    spew.Dump(got)
  }
}

Contributing

We encourage everyone to contribute, submit issues, PRs, discuss. Every kind of help is welcome.

License

Apache 2.0

Credits

• Gopher logo was originally created by Takuya Ueda (https://twitter.com/tenntenn). Licensed under the Creative Commons 3.0 Attributions license.

Documentation

Index

• Constants
• Variables
• func DecimalsInBigInt(decimal uint32) *big.Int
• func DecodeInstruction(programID PublicKey, accounts []*AccountMeta, data []byte) (interface{}, error)
• func GetAddedRemovedPubkeys(previous PublicKeySlice, next PublicKeySlice) (added PublicKeySlice, removed PublicKeySlice)
• func IsAnyOfEncodingType(candidate EncodingType, allowed ...EncodingType) bool
• func IsOnCurve(b []byte) bool
• func RegisterInstructionDecoder(programID PublicKey, decoder InstructionDecoder)
• type AccountMeta
  • func Meta(pubKey PublicKey) *AccountMeta
  • func NewAccountMeta(pubKey PublicKey, WRITE bool, SIGNER bool) *AccountMeta
  • func (meta *AccountMeta) SIGNER() *AccountMeta
  • func (meta *AccountMeta) WRITE() *AccountMeta
• type AccountMetaSlice
  • func (slice *AccountMetaSlice) Append(account *AccountMeta)
  • func (slice AccountMetaSlice) Get(index int) *AccountMeta
  • func (slice AccountMetaSlice) GetAccounts() []*AccountMeta
  • func (slice AccountMetaSlice) GetKeys() PublicKeySlice
  • func (slice AccountMetaSlice) GetSigners() []*AccountMeta
  • func (slice AccountMetaSlice) Len() int
  • func (slice *AccountMetaSlice) SetAccounts(accounts []*AccountMeta) error
  • func (slice AccountMetaSlice) SplitFrom(index int) (AccountMetaSlice, AccountMetaSlice)
• type AccountsGettable
• type AccountsSettable
• type Base58
  • func (t Base58) MarshalJSON() ([]byte, error)
  • func (t Base58) String() string
  • func (t *Base58) UnmarshalJSON(data []byte) (err error)
• type ByteWrapper
  • func (w *ByteWrapper) ReadByte() (byte, error)
• type CompiledInstruction
  • func (ci *CompiledInstruction) ResolveInstructionAccounts(message *Message) ([]*AccountMeta, error)
• type Data
  • func (t Data) MarshalJSON() ([]byte, error)
  • func (obj Data) MarshalWithEncoder(encoder *bin.Encoder) (err error)
  • func (t Data) String() string
  • func (t *Data) UnmarshalJSON(data []byte) (err error)
  • func (obj *Data) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)
• type DurationMilliseconds
  • func (res DurationMilliseconds) Duration() time.Duration
  • func (res DurationMilliseconds) String() string
• type DurationSeconds
  • func (res DurationSeconds) Duration() time.Duration
  • func (res DurationSeconds) String() string
• type EncodingType
• type GenericInstruction
  • func NewInstruction(programID PublicKey, accounts AccountMetaSlice, data []byte) *GenericInstruction
  • func (in *GenericInstruction) Accounts() []*AccountMeta
  • func (in *GenericInstruction) Data() ([]byte, error)
  • func (in *GenericInstruction) ProgramID() PublicKey
• type Hash
  • func HashFromBase58(in string) (Hash, error)
  • func HashFromBytes(in []byte) Hash
  • func MustHashFromBase58(in string) Hash
  • func (ha Hash) Equals(pb Hash) bool
  • func (ha Hash) IsZero() bool
  • func (ha Hash) MarshalJSON() ([]byte, error)
  • func (ha Hash) MarshalText() ([]byte, error)
  • func (ha Hash) String() string
  • func (ha *Hash) UnmarshalJSON(data []byte) (err error)
  • func (ha *Hash) UnmarshalText(data []byte) (err error)
• type Instruction
• type InstructionDecoder
• type Message
  • func (m Message) Account(index uint16) (PublicKey, error)
  • func (m Message) AccountMetaList() (AccountMetaSlice, error)
  • func (mx *Message) AddAddressTableLookup(lookup MessageAddressTableLookup) *Message
  • func (mx *Message) EncodeToTree(txTree treeout.Branches)
  • func (mx Message) GetAddressTableLookupAccounts() ([]PublicKey, error)
  • func (mx *Message) GetAddressTableLookups() MessageAddressTableLookupSlice
  • func (mx *Message) GetAddressTables() map[PublicKey]PublicKeySlice
  • func (mx Message) GetAllKeys() (keys PublicKeySlice, err error)
  • func (m *Message) GetVersion() MessageVersion
  • func (m Message) HasAccount(account PublicKey) (bool, error)
  • func (m Message) IsSigner(account PublicKey) bool
  • func (m Message) IsVersioned() bool
  • func (m Message) IsWritable(account PublicKey) (bool, error)
  • func (mx *Message) MarshalBinary() ([]byte, error)
  • func (mx Message) MarshalJSON() ([]byte, error)
  • func (mx *Message) MarshalLegacy() ([]byte, error)
  • func (mx *Message) MarshalV0() ([]byte, error)
  • func (mx Message) MarshalWithEncoder(encoder *bin.Encoder) error
  • func (mx Message) NumLookups() int
  • func (mx Message) NumWritableLookups() int
  • func (m Message) Program(programIDIndex uint16) (PublicKey, error)
  • func (mx *Message) ResolveLookups() (err error)
  • func (m Message) ResolveProgramIDIndex(programIDIndex uint16) (PublicKey, error)
  • func (mx *Message) SetAddressTableLookups(lookups []MessageAddressTableLookup) *Message
  • func (mx *Message) SetAddressTables(tables map[PublicKey]PublicKeySlice) error
  • func (m *Message) SetVersion(version MessageVersion) *Message
  • func (m Message) Signers() PublicKeySlice
  • func (mx Message) ToBase64() string
  • func (mx *Message) UnmarshalBase64(b64 string) error
  • func (mx *Message) UnmarshalLegacy(decoder *bin.Decoder) (err error)
  • func (mx *Message) UnmarshalV0(decoder *bin.Decoder) (err error)
  • func (mx *Message) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)
  • func (m Message) Writable() (out PublicKeySlice, err error)
• type MessageAddressTableLookup
• type MessageAddressTableLookupSlice
  • func (lookups MessageAddressTableLookupSlice) GetTableIDs() PublicKeySlice
  • func (lookups MessageAddressTableLookupSlice) NumLookups() int
  • func (lookups MessageAddressTableLookupSlice) NumWritableLookups() int
• type MessageHeader
  • func (header *MessageHeader) EncodeToTree(mxBranch treeout.Branches)
• type MessageVersion
• type PK
• type Padding
• type PrivateKey
  • func MustPrivateKeyFromBase58(in string) PrivateKey
  • func NewRandomPrivateKey() (PrivateKey, error)
  • func PrivateKeyFromBase58(privkey string) (PrivateKey, error)
  • func PrivateKeyFromSolanaKeygenFile(file string) (PrivateKey, error)
  • func (k PrivateKey) PublicKey() PublicKey
  • func (k PrivateKey) Sign(payload []byte) (Signature, error)
  • func (k PrivateKey) String() string
• type PublicKey
  • func CreateProgramAddress(seeds [][]byte, programID PublicKey) (PublicKey, error)
  • func CreateWithSeed(base PublicKey, seed string, owner PublicKey) (PublicKey, error)
  • func FindAssociatedTokenAddress(wallet PublicKey, mint PublicKey) (PublicKey, uint8, error)
  • func FindProgramAddress(seed [][]byte, programID PublicKey) (PublicKey, uint8, error)
  • func FindTokenMetadataAddress(mint PublicKey) (PublicKey, uint8, error)
  • func MPK(in string) PublicKey
  • func MustPublicKeyFromBase58(in string) PublicKey
  • func PublicKeyFromBase58(in string) (out PublicKey, err error)
  • func PublicKeyFromBytes(in []byte) (out PublicKey)
  • func (p PublicKey) Bytes() []byte
  • func (p PublicKey) Equals(pb PublicKey) bool
  • func (p PublicKey) IsAnyOf(keys ...PublicKey) bool
  • func (p PublicKey) IsOnCurve() bool
  • func (p PublicKey) IsZero() bool
  • func (p PublicKey) MarshalBSON() ([]byte, error)
  • func (p PublicKey) MarshalBSONValue() (bsontype.Type, []byte, error)
  • func (p PublicKey) MarshalJSON() ([]byte, error)
  • func (p PublicKey) MarshalText() ([]byte, error)
  • func (p *PublicKey) Set(s string) (err error)
  • func (p PublicKey) Short(n int) string
  • func (p PublicKey) String() string
  • func (p PublicKey) ToPointer() *PublicKey
  • func (p *PublicKey) UnmarshalBSON(data []byte) (err error)
  • func (p *PublicKey) UnmarshalBSONValue(t bsontype.Type, data []byte) (err error)
  • func (p *PublicKey) UnmarshalJSON(data []byte) (err error)
  • func (p *PublicKey) UnmarshalText(data []byte) error
  • func (p PublicKey) Verify(message []byte, signature Signature) bool
• type PublicKeySlice
  • func (a PublicKeySlice) Added(b PublicKeySlice) PublicKeySlice
  • func (slice *PublicKeySlice) Append(pubkeys ...PublicKey)
  • func (slice PublicKeySlice) Contains(pubkey PublicKey) bool
  • func (slice PublicKeySlice) ContainsAll(pubkeys PublicKeySlice) bool
  • func (slice PublicKeySlice) ContainsAny(pubkeys PublicKeySlice) bool
  • func (slice PublicKeySlice) Dedupe() PublicKeySlice
  • func (slice PublicKeySlice) Equals(other PublicKeySlice) bool
  • func (slice PublicKeySlice) First() *PublicKey
  • func (prev PublicKeySlice) GetAddedRemoved(next PublicKeySlice) (added PublicKeySlice, removed PublicKeySlice)
  • func (slice PublicKeySlice) Has(pubkey PublicKey) bool
  • func (prev PublicKeySlice) Intersect(next PublicKeySlice) PublicKeySlice
  • func (slice PublicKeySlice) Last() *PublicKey
  • func (slice PublicKeySlice) Len() int
  • func (slice PublicKeySlice) Less(i, j int) bool
  • func (a PublicKeySlice) Removed(b PublicKeySlice) PublicKeySlice
  • func (slice PublicKeySlice) Same(other PublicKeySlice) bool
  • func (slice PublicKeySlice) Sort()
  • func (slice PublicKeySlice) Split(chunkSize int) []PublicKeySlice
  • func (slice PublicKeySlice) Swap(i, j int)
  • func (slice PublicKeySlice) ToBase58() []string
  • func (slice PublicKeySlice) ToBytes() [][]byte
  • func (slice PublicKeySlice) ToPointers() []*PublicKey
  • func (slice *PublicKeySlice) UniqueAppend(pubkey PublicKey) bool
• type Signature
  • func MustSignatureFromBase58(in string) Signature
  • func SignatureFromBase58(in string) (out Signature, err error)
  • func SignatureFromBytes(in []byte) (out Signature)
  • func (sig Signature) Equals(pb Signature) bool
  • func (sig Signature) IsZero() bool
  • func (p Signature) MarshalJSON() ([]byte, error)
  • func (p Signature) MarshalText() ([]byte, error)
  • func (p Signature) String() string
  • func (p *Signature) UnmarshalJSON(data []byte) (err error)
  • func (p *Signature) UnmarshalText(data []byte) (err error)
  • func (s Signature) Verify(pubkey PublicKey, msg []byte) bool
• type Transaction
  • func MustTransactionFromDecoder(decoder *bin.Decoder) *Transaction
  • func NewTransaction(instructions []Instruction, recentBlockHash Hash, opts ...TransactionOption) (*Transaction, error)
  • func TransactionFromDecoder(decoder *bin.Decoder) (*Transaction, error)
  • func (t *Transaction) AccountMetaList() ([]*AccountMeta, error)
  • func (tx *Transaction) EncodeToTree(parent treeout.Branches)
  • func (tx *Transaction) EncodeTree(encoder *text.TreeEncoder) (int, error)
  • func (t *Transaction) HasAccount(account PublicKey) (bool, error)
  • func (t *Transaction) IsSigner(account PublicKey) bool
  • func (t *Transaction) IsWritable(account PublicKey) (bool, error)
  • func (tx *Transaction) MarshalBinary() ([]byte, error)
  • func (tx Transaction) MarshalWithEncoder(encoder *bin.Encoder) error
  • func (tx Transaction) MustToBase64() string
  • func (tx *Transaction) PartialSign(getter privateKeyGetter) (out []Signature, err error)
  • func (t *Transaction) ResolveProgramIDIndex(programIDIndex uint16) (PublicKey, error)
  • func (tx *Transaction) Sign(getter privateKeyGetter) (out []Signature, err error)
  • func (tx *Transaction) String() string
  • func (tx Transaction) ToBase64() (string, error)
  • func (tx *Transaction) UnmarshalBase64(b64 string) error
  • func (tx *Transaction) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)
  • func (tx *Transaction) VerifySignatures() error
• type TransactionBuilder
  • func NewTransactionBuilder() *TransactionBuilder
  • func (builder *TransactionBuilder) AddInstruction(instruction Instruction) *TransactionBuilder
  • func (builder *TransactionBuilder) Build() (*Transaction, error)
  • func (builder *TransactionBuilder) SetFeePayer(feePayer PublicKey) *TransactionBuilder
  • func (builder *TransactionBuilder) SetRecentBlockHash(recentBlockHash Hash) *TransactionBuilder
  • func (builder *TransactionBuilder) WithOpt(opt TransactionOption) *TransactionBuilder
• type TransactionOption
  • func TransactionAddressTables(tables map[PublicKey]PublicKeySlice) TransactionOption
  • func TransactionPayer(payer PublicKey) TransactionOption
• type Uint8SliceAsNum
  • func (slice Uint8SliceAsNum) MarshalJSON() ([]byte, error)
• type UnixTimeMilliseconds
  • func (res UnixTimeMilliseconds) String() string
  • func (res UnixTimeMilliseconds) Time() time.Time
• type UnixTimeSeconds
  • func (res UnixTimeSeconds) String() string
  • func (res UnixTimeSeconds) Time() time.Time
• type Wallet
  • func NewWallet() *Wallet
  • func WalletFromPrivateKeyBase58(privateKey string) (*Wallet, error)
  • func (a *Wallet) PublicKey() PublicKey

Constants

const (
	/// Number of bytes in a pubkey.
	PublicKeyLength = 32
	// Maximum length of derived pubkey seed.
	MaxSeedLength = 32
	// Maximum number of seeds.
	MaxSeeds = 16
	/// Number of bytes in a signature.
	SignatureLength = 64
)

const (
	// There are 1-billion lamports in one SOL.
	LAMPORTS_PER_SOL uint64 = 1000000000
)

const PDA_MARKER = "ProgramDerivedAddress"

Variables

var (
	// Create new accounts, allocate account data, assign accounts to owning programs,
	// transfer lamports from System Program owned accounts and pay transacation fees.
	SystemProgramID = MustPublicKeyFromBase58("11111111111111111111111111111111")

	// Add configuration data to the chain and the list of public keys that are permitted to modify it.
	ConfigProgramID = MustPublicKeyFromBase58("Config1111111111111111111111111111111111111")

	// Create and manage accounts representing stake and rewards for delegations to validators.
	StakeProgramID = MustPublicKeyFromBase58("Stake11111111111111111111111111111111111111")

	// Create and manage accounts that track validator voting state and rewards.
	VoteProgramID = MustPublicKeyFromBase58("Vote111111111111111111111111111111111111111")

	BPFLoaderDeprecatedProgramID = MustPublicKeyFromBase58("BPFLoader1111111111111111111111111111111111")
	// Deploys, upgrades, and executes programs on the chain.
	BPFLoaderProgramID            = MustPublicKeyFromBase58("BPFLoader2111111111111111111111111111111111")
	BPFLoaderUpgradeableProgramID = MustPublicKeyFromBase58("BPFLoaderUpgradeab1e11111111111111111111111")

	// Verify secp256k1 public key recovery operations (ecrecover).
	Secp256k1ProgramID = MustPublicKeyFromBase58("KeccakSecp256k11111111111111111111111111111")

	FeatureProgramID = MustPublicKeyFromBase58("Feature111111111111111111111111111111111111")

	ComputeBudget = MustPublicKeyFromBase58("ComputeBudget111111111111111111111111111111")
)

var (
	// A Token program on the Solana blockchain.
	// This program defines a common implementation for Fungible and Non Fungible tokens.
	TokenProgramID = MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")

	// A Uniswap-like exchange for the Token program on the Solana blockchain,
	// implementing multiple automated market maker (AMM) curves.
	TokenSwapProgramID = MustPublicKeyFromBase58("SwaPpA9LAaLfeLi3a68M4DjnLqgtticKg6CnyNwgAC8")
	TokenSwapFeeOwner  = MustPublicKeyFromBase58("HfoTxFR1Tm6kGmWgYWD6J7YHVy1UwqSULUGVLXkJqaKN")

	// A lending protocol for the Token program on the Solana blockchain inspired by Aave and Compound.
	TokenLendingProgramID = MustPublicKeyFromBase58("LendZqTs8gn5CTSJU1jWKhKuVpjJGom45nnwPb2AMTi")

	// This program defines the convention and provides the mechanism for mapping
	// the user's wallet address to the associated token accounts they hold.
	SPLAssociatedTokenAccountProgramID = MustPublicKeyFromBase58("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")

	// The Memo program is a simple program that validates a string of UTF-8 encoded characters
	// and verifies that any accounts provided are signers of the transaction.
	// The program also logs the memo, as well as any verified signer addresses,
	// to the transaction log, so that anyone can easily observe memos
	// and know they were approved by zero or more addresses
	// by inspecting the transaction log from a trusted provider.
	MemoProgramID = MustPublicKeyFromBase58("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr")
)

SPL:

var (
	// The Mint for native SOL Token accounts
	SolMint    = MustPublicKeyFromBase58("So11111111111111111111111111111111111111112")
	WrappedSol = SolMint
)

var (
	// The Clock sysvar contains data on cluster time,
	// including the current slot, epoch, and estimated wall-clock Unix timestamp.
	// It is updated every slot.
	SysVarClockPubkey = MustPublicKeyFromBase58("SysvarC1ock11111111111111111111111111111111")

	// The EpochSchedule sysvar contains epoch scheduling constants that are set in genesis,
	// and enables calculating the number of slots in a given epoch,
	// the epoch for a given slot, etc.
	// (Note: the epoch schedule is distinct from the leader schedule)
	SysVarEpochSchedulePubkey = MustPublicKeyFromBase58("SysvarEpochSchedu1e111111111111111111111111")

	// The Fees sysvar contains the fee calculator for the current slot.
	// It is updated every slot, based on the fee-rate governor.
	SysVarFeesPubkey = MustPublicKeyFromBase58("SysvarFees111111111111111111111111111111111")

	// The Instructions sysvar contains the serialized instructions in a Message while that Message is being processed.
	// This allows program instructions to reference other instructions in the same transaction.
	SysVarInstructionsPubkey = MustPublicKeyFromBase58("Sysvar1nstructions1111111111111111111111111")

	// The RecentBlockhashes sysvar contains the active recent blockhashes as well as their associated fee calculators.
	// It is updated every slot.
	// Entries are ordered by descending block height,
	// so the first entry holds the most recent block hash,
	// and the last entry holds an old block hash.
	SysVarRecentBlockHashesPubkey = MustPublicKeyFromBase58("SysvarRecentB1ockHashes11111111111111111111")

	// The Rent sysvar contains the rental rate.
	// Currently, the rate is static and set in genesis.
	// The Rent burn percentage is modified by manual feature activation.
	SysVarRentPubkey = MustPublicKeyFromBase58("SysvarRent111111111111111111111111111111111")

	//
	SysVarRewardsPubkey = MustPublicKeyFromBase58("SysvarRewards111111111111111111111111111111")

	// The SlotHashes sysvar contains the most recent hashes of the slot's parent banks.
	// It is updated every slot.
	SysVarSlotHashesPubkey = MustPublicKeyFromBase58("SysvarS1otHashes111111111111111111111111111")

	// The SlotHistory sysvar contains a bitvector of slots present over the last epoch. It is updated every slot.
	SysVarSlotHistoryPubkey = MustPublicKeyFromBase58("SysvarS1otHistory11111111111111111111111111")

	// The StakeHistory sysvar contains the history of cluster-wide stake activations and de-activations per epoch.
	// It is updated at the start of every epoch.
	SysVarStakeHistoryPubkey = MustPublicKeyFromBase58("SysvarStakeHistory1111111111111111111111111")
)

From https://github.com/solana-labs/solana/blob/94ab0eb49f1bce18d0a157dfe7a2bb1fb39dbe2c/docs/src/developing/runtime-facilities/sysvars.md

var ErrInstructionDecoderNotFound = errors.New("instruction decoder not found")

var ErrMaxSeedLengthExceeded = errors.New("Max seed length exceeded")

var (
	TokenMetadataProgramID = MustPublicKeyFromBase58("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
)

Functions

func DecimalsInBigInt

func DecimalsInBigInt(decimal uint32) *big.Int

func DecodeInstruction

func DecodeInstruction(programID PublicKey, accounts []*AccountMeta, data []byte) (interface{}, error)

func GetAddedRemovedPubkeys

func GetAddedRemovedPubkeys(previous PublicKeySlice, next PublicKeySlice) (added PublicKeySlice, removed PublicKeySlice)

GetAddedRemovedPubkeys accepts two slices of pubkeys (`previous` and `next`), and returns two slices: - `added` is the slice of pubkeys that are present in `next` but NOT present in `previous`. - `removed` is the slice of pubkeys that are present in `previous` but are NOT present in `next`.

func IsAnyOfEncodingType

func IsAnyOfEncodingType(candidate EncodingType, allowed ...EncodingType) bool

IsAnyOfEncodingType checks whether the provided `candidate` is any of the `allowed`.

func IsOnCurve

func IsOnCurve(b []byte) bool

Check if the provided `b` is on the ed25519 curve.

func RegisterInstructionDecoder

func RegisterInstructionDecoder(programID PublicKey, decoder InstructionDecoder)

Types

type AccountMeta

type AccountMeta struct {
	PublicKey  PublicKey
	IsWritable bool
	IsSigner   bool
}

func Meta

func Meta(
	pubKey PublicKey,
) *AccountMeta

Meta intializes a new AccountMeta with the provided pubKey.

func NewAccountMeta

func NewAccountMeta(
	pubKey PublicKey,
	WRITE bool,
	SIGNER bool,
) *AccountMeta

func (*AccountMeta) SIGNER

func (meta *AccountMeta) SIGNER() *AccountMeta

SIGNER sets IsSigner to true.

func (*AccountMeta) WRITE

func (meta *AccountMeta) WRITE() *AccountMeta

WRITE sets IsWritable to true.

type AccountMetaSlice

type AccountMetaSlice []*AccountMeta

func (*AccountMetaSlice) Append

func (slice *AccountMetaSlice) Append(account *AccountMeta)

func (AccountMetaSlice) Get

func (slice AccountMetaSlice) Get(index int) *AccountMeta

Get returns the AccountMeta at the desired index. If the index is not present, it returns nil.

func (AccountMetaSlice) GetAccounts

func (slice AccountMetaSlice) GetAccounts() []*AccountMeta

func (AccountMetaSlice) GetKeys

func (slice AccountMetaSlice) GetKeys() PublicKeySlice

GetKeys returns the pubkeys of all AccountMeta.

func (AccountMetaSlice) GetSigners

func (slice AccountMetaSlice) GetSigners() []*AccountMeta

GetSigners returns the accounts that are signers.

func (AccountMetaSlice) Len

func (slice AccountMetaSlice) Len() int

func (*AccountMetaSlice) SetAccounts

func (slice *AccountMetaSlice) SetAccounts(accounts []*AccountMeta) error

func (AccountMetaSlice) SplitFrom

func (slice AccountMetaSlice) SplitFrom(index int) (AccountMetaSlice, AccountMetaSlice)

type AccountsGettable

type AccountsGettable interface {
	GetAccounts() (accounts []*AccountMeta)
}

type AccountsSettable

type AccountsSettable interface {
	SetAccounts(accounts []*AccountMeta) error
}

type Base58

type Base58 []byte

func (Base58) MarshalJSON

func (t Base58) MarshalJSON() ([]byte, error)

func (Base58) String

func (t Base58) String() string

func (*Base58) UnmarshalJSON

func (t *Base58) UnmarshalJSON(data []byte) (err error)

type ByteWrapper

type ByteWrapper struct {
	io.Reader
}

func (*ByteWrapper) ReadByte

func (w *ByteWrapper) ReadByte() (byte, error)

type CompiledInstruction

type CompiledInstruction struct {
	// Index into the message.accountKeys array indicating the program account that executes this instruction.
	// NOTE: it is actually a uint8, but using a uint16 because uint8 is treated as a byte everywhere,
	// and that can be an issue.
	ProgramIDIndex uint16 `json:"programIdIndex"`

	// List of ordered indices into the message.accountKeys array indicating which accounts to pass to the program.
	// NOTE: it is actually a []uint8, but using a uint16 because []uint8 is treated as a []byte everywhere,
	// and that can be an issue.
	Accounts []uint16 `json:"accounts"`

	// The program input data encoded in a base-58 string.
	Data Base58 `json:"data"`
}

func (*CompiledInstruction) ResolveInstructionAccounts

func (ci *CompiledInstruction) ResolveInstructionAccounts(message *Message) ([]*AccountMeta, error)

type Data

type Data struct {
	Content  []byte
	Encoding EncodingType
}

func (Data) MarshalJSON

func (t Data) MarshalJSON() ([]byte, error)

func (Data) MarshalWithEncoder

func (obj Data) MarshalWithEncoder(encoder *bin.Encoder) (err error)

func (Data) String

func (t Data) String() string

func (*Data) UnmarshalJSON

func (t *Data) UnmarshalJSON(data []byte) (err error)

func (*Data) UnmarshalWithDecoder

func (obj *Data) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

type DurationMilliseconds

type DurationMilliseconds int64

DurationMilliseconds represents a duration in milliseconds.

func (DurationMilliseconds) Duration

func (res DurationMilliseconds) Duration() time.Duration

func (DurationMilliseconds) String

func (res DurationMilliseconds) String() string

type DurationSeconds

type DurationSeconds int64

DurationSeconds represents a duration in seconds.

func (DurationSeconds) Duration

func (res DurationSeconds) Duration() time.Duration

func (DurationSeconds) String

func (res DurationSeconds) String() string

type EncodingType

type EncodingType string

const (
	EncodingBase58     EncodingType = "base58"      // limited to Account data of less than 129 bytes
	EncodingBase64     EncodingType = "base64"      // will return base64 encoded data for Account data of any size
	EncodingBase64Zstd EncodingType = "base64+zstd" // compresses the Account data using Zstandard and base64-encodes the result

	// attempts to use program-specific state parsers to
	// return more human-readable and explicit account state data.
	// If "jsonParsed" is requested but a parser cannot be found,
	// the field falls back to "base64" encoding, detectable when the data field is type <string>.
	// Cannot be used if specifying dataSlice parameters (offset, length).
	EncodingJSONParsed EncodingType = "jsonParsed"

	EncodingJSON EncodingType = "json" // NOTE: you're probably looking for EncodingJSONParsed
)

type GenericInstruction

type GenericInstruction struct {
	AccountValues AccountMetaSlice
	ProgID        PublicKey
	DataBytes     []byte
}

func NewInstruction

func NewInstruction(
	programID PublicKey,
	accounts AccountMetaSlice,
	data []byte,
) *GenericInstruction

NewInstruction creates a generic instruction with the provided programID, accounts, and data bytes.

func (*GenericInstruction) Accounts

func (in *GenericInstruction) Accounts() []*AccountMeta

func (*GenericInstruction) Data

func (in *GenericInstruction) Data() ([]byte, error)

func (*GenericInstruction) ProgramID

func (in *GenericInstruction) ProgramID() PublicKey

type Hash

type Hash PublicKey

func HashFromBase58

func HashFromBase58(in string) (Hash, error)

HashFromBase58 decodes a base58 string into a Hash.

func HashFromBytes

func HashFromBytes(in []byte) Hash

HashFromBytes decodes a byte slice into a Hash.

func MustHashFromBase58

func MustHashFromBase58(in string) Hash

MustHashFromBase58 decodes a base58 string into a Hash. Panics on error.

func (Hash) Equals

func (ha Hash) Equals(pb Hash) bool

func (Hash) IsZero

func (ha Hash) IsZero() bool

func (Hash) MarshalJSON

func (ha Hash) MarshalJSON() ([]byte, error)

func (Hash) MarshalText

func (ha Hash) MarshalText() ([]byte, error)

MarshalText implements encoding.TextMarshaler.

func (Hash) String

func (ha Hash) String() string

func (*Hash) UnmarshalJSON

func (ha *Hash) UnmarshalJSON(data []byte) (err error)

func (*Hash) UnmarshalText

func (ha *Hash) UnmarshalText(data []byte) (err error)

UnmarshalText implements encoding.TextUnmarshaler.

type Instruction

type Instruction interface {
	ProgramID() PublicKey     // the programID the instruction acts on
	Accounts() []*AccountMeta // returns the list of accounts the instructions requires
	Data() ([]byte, error)    // the binary encoded instructions
}

type InstructionDecoder

type InstructionDecoder func(instructionAccounts []*AccountMeta, data []byte) (interface{}, error)

InstructionDecoder receives the AccountMeta FOR THAT INSTRUCTION, and not the accounts of the *Message object. Resolve with CompiledInstruction.ResolveInstructionAccounts(message) beforehand.

type Message

type Message struct {

	// List of base-58 encoded public keys used by the transaction,
	// including by the instructions and for signatures.
	// The first `message.header.numRequiredSignatures` public keys must sign the transaction.
	AccountKeys []PublicKey `json:"accountKeys"` // static keys; static keys + dynamic keys if after resolution (i.e. call to `ResolveLookups()`)

	// Details the account types and signatures required by the transaction.
	Header MessageHeader `json:"header"`

	// A base-58 encoded hash of a recent block in the ledger used to
	// prevent transaction duplication and to give transactions lifetimes.
	RecentBlockhash Hash `json:"recentBlockhash"`

	// List of program instructions that will be executed in sequence
	// and committed in one atomic transaction if all succeed.
	Instructions []CompiledInstruction `json:"instructions"`

	// List of address table lookups used to load additional accounts for this transaction.
	AddressTableLookups MessageAddressTableLookupSlice `json:"addressTableLookups"`
	// contains filtered or unexported fields
}

func (Message) Account

func (m Message) Account(index uint16) (PublicKey, error)

Account returns the account at the given index.

func (Message) AccountMetaList

func (m Message) AccountMetaList() (AccountMetaSlice, error)

func (*Message) AddAddressTableLookup

func (mx *Message) AddAddressTableLookup(lookup MessageAddressTableLookup) *Message

AddAddressTableLookup adds a new lookup to the message.

func (*Message) EncodeToTree

func (mx *Message) EncodeToTree(txTree treeout.Branches)

func (Message) GetAddressTableLookupAccounts

func (mx Message) GetAddressTableLookupAccounts() ([]PublicKey, error)

GetAddressTableLookupAccounts associates the lookups with the accounts in the actual address tables, and returns the accounts. NOTE: you need to call `SetAddressTables` before calling this method, so that the lookups can be associated with the accounts in the address tables.

func (*Message) GetAddressTableLookups

func (mx *Message) GetAddressTableLookups() MessageAddressTableLookupSlice

GetAddressTableLookups returns the lookups used by this message.

func (*Message) GetAddressTables

func (mx *Message) GetAddressTables() map[PublicKey]PublicKeySlice

GetAddressTables returns the actual address tables used by this message. NOTE: you must have called `SetAddressTable` before being able to use this method.

func (Message) GetAllKeys

func (mx Message) GetAllKeys() (keys PublicKeySlice, err error)

GetAllKeys returns ALL the message's account keys (including the keys from resolved address lookup tables).

func (*Message) GetVersion

func (m *Message) GetVersion() MessageVersion

GetVersion returns the message version.

func (Message) HasAccount

func (m Message) HasAccount(account PublicKey) (bool, error)

func (Message) IsSigner

func (m Message) IsSigner(account PublicKey) bool

func (Message) IsVersioned

func (m Message) IsVersioned() bool

func (Message) IsWritable

func (m Message) IsWritable(account PublicKey) (bool, error)

func (*Message) MarshalBinary

func (mx *Message) MarshalBinary() ([]byte, error)

func (Message) MarshalJSON

func (mx Message) MarshalJSON() ([]byte, error)

func (*Message) MarshalLegacy

func (mx *Message) MarshalLegacy() ([]byte, error)

func (*Message) MarshalV0

func (mx *Message) MarshalV0() ([]byte, error)

func (Message) MarshalWithEncoder

func (mx Message) MarshalWithEncoder(encoder *bin.Encoder) error

func (Message) NumLookups

func (mx Message) NumLookups() int

func (Message) NumWritableLookups

func (mx Message) NumWritableLookups() int

func (Message) Program

func (m Message) Program(programIDIndex uint16) (PublicKey, error)

Program returns the program key at the given index.

func (*Message) ResolveLookups

func (mx *Message) ResolveLookups() (err error)

ResolveLookups resolves the address table lookups, and appends the resolved accounts to the `message.AccountKeys` field. NOTE: you need to call `SetAddressTables` before calling this method.

func (Message) ResolveProgramIDIndex

func (m Message) ResolveProgramIDIndex(programIDIndex uint16) (PublicKey, error)

ResolveProgramIDIndex resolves the program ID index to a program ID. DEPRECATED: use `Program(index)` instead.

func (*Message) SetAddressTableLookups

func (mx *Message) SetAddressTableLookups(lookups []MessageAddressTableLookup) *Message

SetAddressTableLookups (re)sets the lookups used by this message.

func (*Message) SetAddressTables

func (mx *Message) SetAddressTables(tables map[PublicKey]PublicKeySlice) error

SetAddressTables sets the actual address tables used by this message. Use `mx.GetAddressTableLookups().GetTableIDs()` to get the list of all address table IDs. NOTE: you can call this once.

func (*Message) SetVersion

func (m *Message) SetVersion(version MessageVersion) *Message

SetVersion sets the message version. This method forces the message to be encoded in the specified version. NOTE: if you set lookups, the version will default to V0.

func (Message) Signers

func (m Message) Signers() PublicKeySlice

Signers returns the pubkeys of all accounts that are signers.

func (Message) ToBase64

func (mx Message) ToBase64() string

func (*Message) UnmarshalBase64

func (mx *Message) UnmarshalBase64(b64 string) error

func (*Message) UnmarshalLegacy

func (mx *Message) UnmarshalLegacy(decoder *bin.Decoder) (err error)

func (*Message) UnmarshalV0

func (mx *Message) UnmarshalV0(decoder *bin.Decoder) (err error)

func (*Message) UnmarshalWithDecoder

func (mx *Message) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

func (Message) Writable

func (m Message) Writable() (out PublicKeySlice, err error)

Writable returns the pubkeys of all accounts that are writable.

type MessageAddressTableLookup

type MessageAddressTableLookup struct {
	AccountKey      PublicKey       `json:"accountKey"` // The account key of the address table.
	WritableIndexes Uint8SliceAsNum `json:"writableIndexes"`
	ReadonlyIndexes Uint8SliceAsNum `json:"readonlyIndexes"`
}

type MessageAddressTableLookupSlice

type MessageAddressTableLookupSlice []MessageAddressTableLookup

func (MessageAddressTableLookupSlice) GetTableIDs

func (lookups MessageAddressTableLookupSlice) GetTableIDs() PublicKeySlice

GetTableIDs returns the list of all address table IDs.

func (MessageAddressTableLookupSlice) NumLookups

func (lookups MessageAddressTableLookupSlice) NumLookups() int

NumLookups returns the number of accounts from all the lookups.

func (MessageAddressTableLookupSlice) NumWritableLookups

func (lookups MessageAddressTableLookupSlice) NumWritableLookups() int

NumWritableLookups returns the number of writable accounts across all the lookups (all the address tables).

type MessageHeader

type MessageHeader struct {
	// The total number of signatures required to make the transaction valid.
	// The signatures must match the first `numRequiredSignatures` of `message.account_keys`.
	NumRequiredSignatures uint8 `json:"numRequiredSignatures"`

	// The last numReadonlySignedAccounts of the signed keys are read-only accounts.
	// Programs may process multiple transactions that load read-only accounts within
	// a single PoH entry, but are not permitted to credit or debit lamports or modify
	// account data.
	// Transactions targeting the same read-write account are evaluated sequentially.
	NumReadonlySignedAccounts uint8 `json:"numReadonlySignedAccounts"`

	// The last `numReadonlyUnsignedAccounts` of the unsigned keys are read-only accounts.
	NumReadonlyUnsignedAccounts uint8 `json:"numReadonlyUnsignedAccounts"`
}

func (*MessageHeader) EncodeToTree

func (header *MessageHeader) EncodeToTree(mxBranch treeout.Branches)

type MessageVersion

type MessageVersion int

const (
	MessageVersionLegacy MessageVersion = 0 // default
	MessageVersionV0     MessageVersion = 1 // v0
)

type PK

type PK = PublicKey

PK is a convenience alias for PublicKey

type Padding

type Padding []byte

type PrivateKey

type PrivateKey []byte

func MustPrivateKeyFromBase58

func MustPrivateKeyFromBase58(in string) PrivateKey

func NewRandomPrivateKey

func NewRandomPrivateKey() (PrivateKey, error)

func PrivateKeyFromBase58

func PrivateKeyFromBase58(privkey string) (PrivateKey, error)

func PrivateKeyFromSolanaKeygenFile

func PrivateKeyFromSolanaKeygenFile(file string) (PrivateKey, error)

func (PrivateKey) PublicKey

func (k PrivateKey) PublicKey() PublicKey

func (PrivateKey) Sign

func (k PrivateKey) Sign(payload []byte) (Signature, error)

func (PrivateKey) String

func (k PrivateKey) String() string

type PublicKey

type PublicKey [PublicKeyLength]byte

func CreateProgramAddress

func CreateProgramAddress(seeds [][]byte, programID PublicKey) (PublicKey, error)

Create a program address. Ported from https://github.com/solana-labs/solana/blob/216983c50e0a618facc39aa07472ba6d23f1b33a/sdk/program/src/pubkey.rs#L204

func CreateWithSeed

func CreateWithSeed(base PublicKey, seed string, owner PublicKey) (PublicKey, error)

Ported from https://github.com/solana-labs/solana/blob/216983c50e0a618facc39aa07472ba6d23f1b33a/sdk/program/src/pubkey.rs#L159

func FindAssociatedTokenAddress

func FindAssociatedTokenAddress(
	wallet PublicKey,
	mint PublicKey,
) (PublicKey, uint8, error)

func FindProgramAddress

func FindProgramAddress(seed [][]byte, programID PublicKey) (PublicKey, uint8, error)

Find a valid program address and its corresponding bump seed.

func FindTokenMetadataAddress

func FindTokenMetadataAddress(mint PublicKey) (PublicKey, uint8, error)

FindTokenMetadataAddress returns the token metadata program-derived address given a SPL token mint address.

func MPK

func MPK(in string) PublicKey

MPK is a convenience alias for MustPublicKeyFromBase58

func MustPublicKeyFromBase58

func MustPublicKeyFromBase58(in string) PublicKey

func PublicKeyFromBase58

func PublicKeyFromBase58(in string) (out PublicKey, err error)

func PublicKeyFromBytes

func PublicKeyFromBytes(in []byte) (out PublicKey)

func (PublicKey) Bytes

func (p PublicKey) Bytes() []byte

func (PublicKey) Equals

func (p PublicKey) Equals(pb PublicKey) bool

func (PublicKey) IsAnyOf

func (p PublicKey) IsAnyOf(keys ...PublicKey) bool

IsAnyOf checks if p is equals to any of the provided keys.

func (PublicKey) IsOnCurve

func (p PublicKey) IsOnCurve() bool

Check if a `Pubkey` is on the ed25519 curve.

func (PublicKey) IsZero

func (p PublicKey) IsZero() bool

IsZero returns whether the public key is zero. NOTE: the System Program public key is also zero.

func (PublicKey) MarshalBSON

func (p PublicKey) MarshalBSON() ([]byte, error)

MarshalBSON implements the bson.Marshaler interface.

func (PublicKey) MarshalBSONValue

func (p PublicKey) MarshalBSONValue() (bsontype.Type, []byte, error)

MarshalBSONValue implements the bson.ValueMarshaler interface.

func (PublicKey) MarshalJSON

func (p PublicKey) MarshalJSON() ([]byte, error)

func (PublicKey) MarshalText

func (p PublicKey) MarshalText() ([]byte, error)

func (*PublicKey) Set

func (p *PublicKey) Set(s string) (err error)

func (PublicKey) Short

func (p PublicKey) Short(n int) string

Short returns a shortened pubkey string, only including the first n chars, ellipsis, and the last n characters. NOTE: this is ONLY for visual representation for humans, and cannot be used for anything else.

func (PublicKey) String

func (p PublicKey) String() string

func (PublicKey) ToPointer

func (p PublicKey) ToPointer() *PublicKey

ToPointer returns a pointer to the pubkey.

func (*PublicKey) UnmarshalBSON

func (p *PublicKey) UnmarshalBSON(data []byte) (err error)

UnmarshalBSON implements the bson.Unmarshaler interface.

func (*PublicKey) UnmarshalBSONValue

func (p *PublicKey) UnmarshalBSONValue(t bsontype.Type, data []byte) (err error)

UnmarshalBSONValue implements the bson.ValueUnmarshaler interface.

func (*PublicKey) UnmarshalJSON

func (p *PublicKey) UnmarshalJSON(data []byte) (err error)

func (*PublicKey) UnmarshalText

func (p *PublicKey) UnmarshalText(data []byte) error

func (PublicKey) Verify

func (p PublicKey) Verify(message []byte, signature Signature) bool

type PublicKeySlice

type PublicKeySlice []PublicKey

func (PublicKeySlice) Added

func (a PublicKeySlice) Added(b PublicKeySlice) PublicKeySlice

Added returns the elements that are present in `b` but not in `a`.

func (*PublicKeySlice) Append

func (slice *PublicKeySlice) Append(pubkeys ...PublicKey)

func (PublicKeySlice) Contains

func (slice PublicKeySlice) Contains(pubkey PublicKey) bool

Contains returns true if the slice contains the provided pubkey.

func (PublicKeySlice) ContainsAll

func (slice PublicKeySlice) ContainsAll(pubkeys PublicKeySlice) bool

ContainsAll returns true if all the provided pubkeys are present in the slice.

func (PublicKeySlice) ContainsAny

func (slice PublicKeySlice) ContainsAny(pubkeys PublicKeySlice) bool

ContainsAny returns true if any of the provided pubkeys are present in the slice.

func (PublicKeySlice) Dedupe

func (slice PublicKeySlice) Dedupe() PublicKeySlice

Dedupe returns a new slice with all duplicate pubkeys removed.

func (PublicKeySlice) Equals

func (slice PublicKeySlice) Equals(other PublicKeySlice) bool

Equals returns true if the two PublicKeySlices are equal (same order of same keys).

func (PublicKeySlice) First

func (slice PublicKeySlice) First() *PublicKey

First returns the first element of the slice. Returns nil if the slice is empty.

func (PublicKeySlice) GetAddedRemoved

func (prev PublicKeySlice) GetAddedRemoved(next PublicKeySlice) (added PublicKeySlice, removed PublicKeySlice)

GetAddedRemoved compares to the `next` pubkey slice, and returns two slices: - `added` is the slice of pubkeys that are present in `next` but NOT present in `previous`. - `removed` is the slice of pubkeys that are present in `previous` but are NOT present in `next`.

func (PublicKeySlice) Has

func (slice PublicKeySlice) Has(pubkey PublicKey) bool

func (PublicKeySlice) Intersect

func (prev PublicKeySlice) Intersect(next PublicKeySlice) PublicKeySlice

Intersect returns the intersection of two PublicKeySlices, i.e. the elements that are in both PublicKeySlices. The returned PublicKeySlice is sorted and deduped.

func (PublicKeySlice) Last

func (slice PublicKeySlice) Last() *PublicKey

Last returns the last element of the slice. Returns nil if the slice is empty.

func (PublicKeySlice) Len

func (slice PublicKeySlice) Len() int

func (PublicKeySlice) Less

func (slice PublicKeySlice) Less(i, j int) bool

func (PublicKeySlice) Removed

func (a PublicKeySlice) Removed(b PublicKeySlice) PublicKeySlice

Removed returns the elements that are present in `a` but not in `b`.

func (PublicKeySlice) Same

func (slice PublicKeySlice) Same(other PublicKeySlice) bool

Same returns true if the two slices contain the same public keys, but not necessarily in the same order.

func (PublicKeySlice) Sort

func (slice PublicKeySlice) Sort()

Sort sorts the slice.

func (PublicKeySlice) Split

func (slice PublicKeySlice) Split(chunkSize int) []PublicKeySlice

Split splits the slice into chunks of the specified size.

func (PublicKeySlice) Swap

func (slice PublicKeySlice) Swap(i, j int)

func (PublicKeySlice) ToBase58

func (slice PublicKeySlice) ToBase58() []string

func (PublicKeySlice) ToBytes

func (slice PublicKeySlice) ToBytes() [][]byte

func (PublicKeySlice) ToPointers

func (slice PublicKeySlice) ToPointers() []*PublicKey

func (*PublicKeySlice) UniqueAppend

func (slice *PublicKeySlice) UniqueAppend(pubkey PublicKey) bool

UniqueAppend appends the provided pubkey only if it is not already present in the slice. Returns true when the provided pubkey wasn't already present.

type Signature

type Signature [64]byte

func MustSignatureFromBase58

func MustSignatureFromBase58(in string) Signature

MustSignatureFromBase58 decodes a base58 string into a Signature. Panics on error.

func SignatureFromBase58

func SignatureFromBase58(in string) (out Signature, err error)

SignatureFromBase58 decodes a base58 string into a Signature.

func SignatureFromBytes

func SignatureFromBytes(in []byte) (out Signature)

SignatureFromBytes decodes a byte slice into a Signature.

func (Signature) Equals

func (sig Signature) Equals(pb Signature) bool

func (Signature) IsZero

func (sig Signature) IsZero() bool

func (Signature) MarshalJSON

func (p Signature) MarshalJSON() ([]byte, error)

func (Signature) MarshalText

func (p Signature) MarshalText() ([]byte, error)

func (Signature) String

func (p Signature) String() string

func (*Signature) UnmarshalJSON

func (p *Signature) UnmarshalJSON(data []byte) (err error)

func (*Signature) UnmarshalText

func (p *Signature) UnmarshalText(data []byte) (err error)

func (Signature) Verify

func (s Signature) Verify(pubkey PublicKey, msg []byte) bool

Verify checks that the signature is valid for the given public key and message.

type Transaction

type Transaction struct {
	// A list of base-58 encoded signatures applied to the transaction.
	// The list is always of length `message.header.numRequiredSignatures` and not empty.
	// The signature at index `i` corresponds to the public key at index
	// `i` in `message.account_keys`. The first one is used as the transaction id.
	Signatures []Signature `json:"signatures"`

	// Defines the content of the transaction.
	Message Message `json:"message"`
}

func MustTransactionFromDecoder

func MustTransactionFromDecoder(decoder *bin.Decoder) *Transaction

MustTransactionFromDecoder decodes a transaction from a decoder. Panics on error.

func NewTransaction

func NewTransaction(instructions []Instruction, recentBlockHash Hash, opts ...TransactionOption) (*Transaction, error)

func TransactionFromDecoder

func TransactionFromDecoder(decoder *bin.Decoder) (*Transaction, error)

TransactionFromDecoder decodes a transaction from a decoder.

func (*Transaction) AccountMetaList

func (t *Transaction) AccountMetaList() ([]*AccountMeta, error)

func (*Transaction) EncodeToTree

func (tx *Transaction) EncodeToTree(parent treeout.Branches)

func (*Transaction) EncodeTree

func (tx *Transaction) EncodeTree(encoder *text.TreeEncoder) (int, error)

func (*Transaction) HasAccount

func (t *Transaction) HasAccount(account PublicKey) (bool, error)

func (*Transaction) IsSigner

func (t *Transaction) IsSigner(account PublicKey) bool

func (*Transaction) IsWritable

func (t *Transaction) IsWritable(account PublicKey) (bool, error)

func (*Transaction) MarshalBinary

func (tx *Transaction) MarshalBinary() ([]byte, error)

func (Transaction) MarshalWithEncoder

func (tx Transaction) MarshalWithEncoder(encoder *bin.Encoder) error

func (Transaction) MustToBase64

func (tx Transaction) MustToBase64() string

func (*Transaction) PartialSign

func (tx *Transaction) PartialSign(getter privateKeyGetter) (out []Signature, err error)

func (*Transaction) ResolveProgramIDIndex

func (t *Transaction) ResolveProgramIDIndex(programIDIndex uint16) (PublicKey, error)

func (*Transaction) Sign

func (tx *Transaction) Sign(getter privateKeyGetter) (out []Signature, err error)

func (*Transaction) String

func (tx *Transaction) String() string

String returns a human-readable string representation of the transaction data. To disable colors, set "github.com/stonecoldik/go-solana/text".DisableColors = true

func (Transaction) ToBase64

func (tx Transaction) ToBase64() (string, error)

func (*Transaction) UnmarshalBase64

func (tx *Transaction) UnmarshalBase64(b64 string) error

UnmarshalBase64 decodes a base64 encoded transaction.

func (*Transaction) UnmarshalWithDecoder

func (tx *Transaction) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

func (*Transaction) VerifySignatures

func (tx *Transaction) VerifySignatures() error

VerifySignatures verifies all the signatures in the transaction against the pubkeys of the signers.

type TransactionBuilder

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

func NewTransactionBuilder

func NewTransactionBuilder() *TransactionBuilder

NewTransactionBuilder creates a new instruction builder.

func (*TransactionBuilder) AddInstruction

func (builder *TransactionBuilder) AddInstruction(instruction Instruction) *TransactionBuilder

AddInstruction adds the provided instruction to the builder.

func (*TransactionBuilder) Build

func (builder *TransactionBuilder) Build() (*Transaction, error)

Build builds and returns a *Transaction.

func (*TransactionBuilder) SetFeePayer

func (builder *TransactionBuilder) SetFeePayer(feePayer PublicKey) *TransactionBuilder

Set transaction fee payer. If not set, defaults to first signer account of the first instruction.

func (*TransactionBuilder) SetRecentBlockHash

func (builder *TransactionBuilder) SetRecentBlockHash(recentBlockHash Hash) *TransactionBuilder

SetRecentBlockHash sets the recent blockhash for the instruction builder.

func (*TransactionBuilder) WithOpt

func (builder *TransactionBuilder) WithOpt(opt TransactionOption) *TransactionBuilder

WithOpt adds a TransactionOption.

type TransactionOption

type TransactionOption interface {
	// contains filtered or unexported methods
}

func TransactionAddressTables

func TransactionAddressTables(tables map[PublicKey]PublicKeySlice) TransactionOption

func TransactionPayer

func TransactionPayer(payer PublicKey) TransactionOption

type Uint8SliceAsNum

type Uint8SliceAsNum []uint8

Uint8SliceAsNum is a slice of uint8s that can be marshaled as numbers instead of a byte slice.

func (Uint8SliceAsNum) MarshalJSON

func (slice Uint8SliceAsNum) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

type UnixTimeMilliseconds

type UnixTimeMilliseconds int64

UnixTimeMilliseconds represents a UNIX millisecond-resolution timestamp.

func (UnixTimeMilliseconds) String

func (res UnixTimeMilliseconds) String() string

func (UnixTimeMilliseconds) Time

func (res UnixTimeMilliseconds) Time() time.Time

type UnixTimeSeconds

type UnixTimeSeconds int64

UnixTimeSeconds represents a UNIX second-resolution timestamp.

func (UnixTimeSeconds) String

func (res UnixTimeSeconds) String() string

func (UnixTimeSeconds) Time

func (res UnixTimeSeconds) Time() time.Time

type Wallet

type Wallet struct {
	PrivateKey PrivateKey
}

Wallet is a wrapper around a PrivateKey

func NewWallet

func NewWallet() *Wallet

func WalletFromPrivateKeyBase58

func WalletFromPrivateKeyBase58(privateKey string) (*Wallet, error)

func (*Wallet) PublicKey

func (a *Wallet) PublicKey() PublicKey