solana

package module
v1.23.0 Latest Latest
Warning

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

 Go to latest Published: Aug 26, 2026 License: Apache-2.0 Imports: 34 Imported by: 2,233

README

Solana SDK library for Go

GoDoc GitHub tag (latest SemVer pre-release) Build Status Lint Status TODOs Go Report Card

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

Contents

Features

Current development status

solana-go ships from two parallel branches:

  • main (v1) — recommended default. Backward-compatible improvements only. Latest release: v1.22.0.
  • v2 — opt-in. Same content as main plus breaking API cleanups. Latest: v2.0.0-rc (release candidate). See About v2 below.

Most users should stay on v1. Only choose v2 if you specifically want the changes listed in About v2.

The RPC and WS client implementation is based on the Solana RPC API documentation.

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.24 or later

Installation

$ cd my-project
$ go get github.com/gagliardetto/solana-go@latest

Looking for v2? See About v2.

Pretty-Print transactions/instructions

pretty-printed

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/gagliardetto/solana-go/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/gagliardetto/solana-go"
	lookup "github.com/gagliardetto/solana-go/programs/address-lookup-table"
	"github.com/gagliardetto/solana-go/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())
}

V1 Transactions (SIMD-0385)

V1 is the transaction format introduced by SIMD-0385 (anza-xyz/solana-sdk #538). Compared to legacy/v0 transactions:

legacy / v0 v1
max transaction size 1232 bytes 4096 bytes
compute budget ComputeBudget program instructions inline TransactionConfig in the message header
address lookup tables v0 only not supported
max signatures / addresses / instructions bounded by the 1232-byte size (indices are u8) 12 / 64 / 64 (enforced by Sanitize)
wire layout sigs (compact-u16 len) || message 0x81 || message || sigs (fixed, no len)

The Go API stays the same; you opt in with solana.TransactionV1Config (or solana.TransactionMessageVersion(solana.MessageVersionV1)):

package main

import (
	"context"
	"fmt"

	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/programs/system"
	"github.com/gagliardetto/solana-go/rpc"
)

func main() {
	ctx := context.Background()
	client := rpc.New(rpc.DevNet_RPC)

	sender, _ := solana.PrivateKeyFromSolanaKeygenFile("/path/to/id.json")
	recipient := solana.NewWallet().PublicKey()

	recent, err := client.GetLatestBlockhash(ctx, rpc.CommitmentFinalized)
	if err != nil {
		panic(err)
	}

	// The compute budget lives in the message header; every field is optional.
	config := solana.TransactionConfig{}.
		WithComputeUnitLimit(20_000). // unset means 0 CUs -> always set it
		WithPriorityFee(1_000)        // TOTAL lamports, not micro-lamports/CU
	// Also available: WithLoadedAccountsDataSizeLimit(bytes), WithHeapSize(bytes)
	// (heap must be a multiple of 1024 within [32 KiB, 256 KiB]).

	tx, err := solana.NewTransaction(
		[]solana.Instruction{
			system.NewTransferInstruction(solana.LAMPORTS_PER_SOL/1000, sender.PublicKey(), recipient).Build(),
		},
		recent.Value.Blockhash,
		solana.TransactionPayer(sender.PublicKey()),
		solana.TransactionV1Config(config), // <- selects the V1 format
	)
	if err != nil {
		panic(err)
	}

	// Signing, sending and confirming are unchanged.
	if _, err := tx.Sign(func(key solana.PublicKey) *solana.PrivateKey {
		if sender.PublicKey().Equals(key) {
			return &sender
		}
		return nil
	}); err != nil {
		panic(err)
	}
	sig, err := client.SendTransaction(ctx, tx)
	if err != nil {
		panic(err)
	}
	fmt.Println(sig)
}

Decoding is automatic (TransactionFromBytes, TransactionFromBase64, rpc results, JSON): the version byte 0x81 selects the V1 decoder.

tx, err := solana.TransactionFromBase64(b64)
if err != nil {
	panic(err)
}
if tx.Message.GetVersion() == solana.MessageVersionV1 {
	cfg := tx.Message.TransactionConfig // *uint64 / *uint32 fields, nil = not requested
	if cfg.ComputeUnitLimit != nil {
		fmt.Println("compute unit limit:", *cfg.ComputeUnitLimit)
	}
}
if err := tx.Sanitize(); err != nil { // structural limits; the 4096-byte cap is enforced by the cluster
	panic(err)
}

When fetching transactions/blocks from the RPC, ask for version 1 (getTransaction, getBlock, blockSubscribe, ... all take the same option):

out, err := client.GetTransaction(ctx, sig, &rpc.GetTransactionOpts{
	MaxSupportedTransactionVersion: &rpc.MaxSupportedTransactionVersion1,
})

Things to keep in mind:

  • The cluster must have SIMD-0385 activated, otherwise V1 transactions are rejected during sanitization.
  • PriorityFee is the total priority fee in lamports for the whole transaction (unlike SetComputeUnitPrice, which is micro-lamports per CU).
  • An unset ComputeUnitLimit means a requested limit of 0 compute units.
  • ComputeBudget program instructions are no-ops in V1 transactions; NewTransaction rejects them for V1.
  • V1 transactions cannot use address lookup tables; combining TransactionV1Config with TransactionAddressTables is an error.
  • solana.MaxTransactionSizeV1 (4096) is the size cap including signatures (checked by the cluster, not the SDK).

See rpc/examples/sendTransactionV1 and the ExampleNewTransaction_v1 godoc example for complete programs.

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/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/system"
  "github.com/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/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`.
    // It looks up the decoder for `progKey` in a central registry, so it
    // works for any program ID regardless of what you know at compile time.
    //
    // Each `programs/<name>` package registers its decoder via init(),
    // which only runs when the package is imported. If you are not
    // already using the package's builders (e.g. `system.NewTransferInstruction`),
    // blank-import it so the decoder is available - same idiom as
    // database/sql drivers:
    //
    //     import (
    //         _ "github.com/gagliardetto/solana-go/programs/system"
    //         _ "github.com/gagliardetto/solana-go/programs/token"
    //         // ...add more as needed
    //     )
    //
    // For a program that solana-go does not ship (e.g. a custom Anchor
    // program), register its decoder yourself:
    //
    //     solana.MustRegisterInstructionDecoder(myProgramID, myDecoderFunc)
    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)")
    }
  }

  {
    // 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/gagliardetto/solana-go/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/gagliardetto/solana-go/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/gagliardetto/solana-go/rpc"
  "github.com/gagliardetto/solana-go/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/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/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/gagliardetto/solana-go"
  "github.com/gagliardetto/solana-go/programs/system"
  "github.com/gagliardetto/solana-go/rpc"
  confirm "github.com/gagliardetto/solana-go/rpc/sendAndConfirmTransaction"
  "github.com/gagliardetto/solana-go/rpc/jsonrpc"
  "github.com/gagliardetto/solana-go/rpc/ws"
  "github.com/gagliardetto/solana-go/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.GetLatestBlockhash(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 Methods

All RPC methods from the Solana JSON RPC API are supported. Each method has a testable example in rpc/example_test.go that is rendered on pkg.go.dev.

WebSocket Subscriptions

All WebSocket subscriptions from the Solana WebSocket API are supported. Each subscription has a testable example in rpc/ws/example_test.go that is rendered on pkg.go.dev.

About v2

A v2 branch exists in parallel with main. It contains everything on main plus three breaking changes that couldn't ship on v1 without disrupting existing users:

  1. Module path — github.com/solana-foundation/solana-go/v2
  2. Loader program packages (programs/loader-v2 / -v3 / -v4) realigned to on-chain program specs (#410)
  3. WebSocket subscription API aligned to the JSON-RPC spec (#407)

v1 remains the recommended default. Choose v2 only if you specifically need one of the above.

To use v2 (currently v2.0.0-rc, a release candidate):

$ go get github.com/solana-foundation/solana-go/v2@v2.0.0-rc

Full v2 details, release notes, and migration guide:

Contributing

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

Please read CONTRIBUTING.md for guidelines on commit messages, semver policy, linting, and CI checks.

Before opening a PR, run:

go test ./... -count=1
golangci-lint run

Both must pass in CI.

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

Examples

Constants

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

	SolDecimals uint8 = 9
)
View Source 
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

	// Number of bytes in a private key.
	PrivateKeyLength = voied25519.PrivateKeySize
)
View Source 
const (
	// MaxTransactionSizeV1 is the V1 size cap, signatures included (enforced by the cluster).
	MaxTransactionSizeV1 = 4096
	// MaxAddressesV1 is the maximum number of addresses in a V1 message.
	MaxAddressesV1 = 64
	// MaxInstructionsV1 is the maximum number of instructions in a V1 message.
	MaxInstructionsV1 = 64
	// MaxSignaturesV1 is the maximum number of signatures in a V1 transaction.
	MaxSignaturesV1 = 12
	// MinHeapSizeV1 is the minimum (and default) requested heap size.
	MinHeapSizeV1 uint32 = 32 * 1024
	// MaxHeapSizeV1 is the maximum requested heap size.
	MaxHeapSizeV1 uint32 = 256 * 1024
	// DefaultHeapSizeV1 is the heap size when none is requested.
	DefaultHeapSizeV1 = MinHeapSizeV1
)
View Source 
const (
	AccountsTypeIndex = "Fee"
	AccountsTypeKey   = "Key"
)
View Source 
const FeatureSizeOf = 9

FeatureSizeOf is the serialized size of a Feature account (1-byte option tag + u64).

View Source 
const NonceStateSize = 80

NonceStateSize is the serialized size, in bytes, of a nonce account's data. It is constant regardless of whether the account is initialized: the runtime always allocates this many bytes. Mirrors solana_nonce::state::State::size().

View Source 
const PDA_MARKER = "ProgramDerivedAddress"
View Source 
const SolanaDerivationPath = "m/44'/501'/0'/0'"

SolanaDerivationPath is the default BIP-44 derivation path used by Phantom and most Solana wallets when generating a key from a BIP-39 mnemonic: m/44'/501'/0'/0'.

Variables

View Source 
var (
	FeatureReduceSlotTimeTo350ms = MustPublicKeyFromBase58("iBRL5RuWhw4yqaAZu96RUULHckHTZAoe2b77qaV38JZ")
	FeatureReduceSlotTimeTo300ms = MustPublicKeyFromBase58("iBRLL3k18HST852F1Mf3Lv83waTNQmmqvKDxvYGwQFL")
	FeatureReduceSlotTimeTo250ms = MustPublicKeyFromBase58("iBRLMc81UjRa8fn8A6eE8bJTnRbgQoPTynM51akENCV")
	FeatureReduceSlotTimeTo200ms = MustPublicKeyFromBase58("iBRLjhJnkmDZgNoZRDMW11d8ZV7HvsL3vAyRjZB5npW")
)

SIMD-0525 slot-time reduction feature gates, in activation order. Each takes effect one epoch after its activation epoch (see sysvar.MsPerSlotAt).

View Source 
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")

	// Create and manage address lookup tables.
	AddressLookupTableProgramID = MustPublicKeyFromBase58("AddressLookupTab1e1111111111111111111111111")
)
View Source 
var (
	// A Token program on the Solana blockchain.
	// This program defines a common implementation for Fungible and Non Fungible tokens.
	TokenProgramID = MustPublicKeyFromBase58("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")

	Token2022ProgramID = MustPublicKeyFromBase58("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")

	// 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")

	// MemoProgramIDV1 is the deprecated v1 Memo program.
	// Some legacy transactions still reference this program ID.
	MemoProgramIDV1 = MustPublicKeyFromBase58("Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo")
)

SPL:

View Source 
var (
	SolMint    = MustPublicKeyFromBase58("So11111111111111111111111111111111111111111")
	WrappedSol = MustPublicKeyFromBase58("So11111111111111111111111111111111111111112")
)
View Source 
var (
	// Owner address for sysvar accounts.
	SysVarPubkey = MustPublicKeyFromBase58("Sysvar1111111111111111111111111111111111111")

	// 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 EpochRewards sysvar contains epoch rewards distribution data.
	SysVarEpochRewardsPubkey = MustPublicKeyFromBase58("SysvarEpochRewards1111111111111111111111111")

	// 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 LastRestartSlot sysvar contains the last restart slot.
	SysVarLastRestartSlotPubkey = MustPublicKeyFromBase58("SysvarLastRestartS1ot1111111111111111111111")

	// 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")

	// The Rewards sysvar.
	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")

	// The stake config account is used to store parameters and settings that govern the behavior of staking on the Solana network.
	SysVarStakeConfigPubkey = MustPublicKeyFromBase58("StakeConfig11111111111111111111111111111111")
)

From https://github.com/anza-xyz/solana-sdk/blob/master/sdk-ids/src/lib.rs

View Source 
var ErrAddressTablesNotSet = errors.New(
	"address tables not set for versioned message with lookups; " +
		"fetch each table id returned by Message.GetAddressTableLookups().GetTableIDs() " +
		"(e.g. via rpc.Client.GetMultipleAccounts, decoding each account with " +
		"addresslookuptable.DecodeAddressLookupTableState) " +
		"and pass the resolved {tableID -> []PublicKey} map to Message.SetAddressTables",
)

ErrAddressTablesNotSet is returned by `(*Message).AccountMetaList`, `(*Message).ResolveLookups`, and friends when the message is a versioned (V0+) transaction with one or more address-table lookups but the actual table contents have not been provided yet via `(*Message).SetAddressTables`. Callers can use `errors.Is` to detect this specific condition (see #280) without scraping the error text.

View Source 
var ErrAlreadyResolved = fmt.Errorf("lookups already resolved")
View Source 
var ErrIllegalOwner = errors.New("provided owner is not allowed")

ErrIllegalOwner is returned by CreateWithSeed when the owner ends with the program-derived-address marker, which is disallowed.

View Source 
var ErrInstructionDecoderNotFound = errors.New("instruction decoder not found")
View Source 
var ErrMaxSeedLengthExceeded = errors.New("max seed length exceeded")
View Source 
var ErrNonceUninitialized = errors.New("nonce account is uninitialized")

ErrNonceUninitialized is returned by Authorize when the nonce account has not been initialized.

View Source 
var TokenMetadataProgramID = MustPublicKeyFromBase58("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")

Functions

func DecimalsInBigInt 

func DecimalsInBigInt(decimal uint32) *big.Int

func DecodeInstruction 

func DecodeInstruction(programID PublicKey, accounts []*AccountMeta, data []byte) (any, error)

func GetAddedRemovedPubkeys added in v1.1.0 

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 added in v0.3.5 

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

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

func IsOnCurve added in v1.0.4 

func IsOnCurve(b []byte) bool

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

func IsSanitizeError added in v1.17.0 

func IsSanitizeError(err error) bool

IsSanitizeError reports whether err is a sanitization validation error.

func LamportsPerSignatureOf added in v1.22.0 

func LamportsPerSignatureOf(data []byte) (uint64, bool)

LamportsPerSignatureOf decodes a nonce account's data and returns the per-signature fee it records, or (0, false) when uninitialized or undecodable.

Mirrors nonce_account::lamports_per_signature_of, which likewise does NOT verify the account owner; this function only takes the data bytes and cannot. Pass data you have already confirmed belongs to a System-owned nonce account (e.g. via GetSystemAccountKind or VerifyNonceAccount), or treat the result as advisory.

func MustRegisterInstructionDecoder added in v1.17.0 

func MustRegisterInstructionDecoder(programID PublicKey, decoder InstructionDecoder)

MustRegisterInstructionDecoder is like RegisterInstructionDecoder but panics on error. Intended for use in init() functions where error handling is not possible.

func RegisterInstructionDecoder 

func RegisterInstructionDecoder(programID PublicKey, decoder InstructionDecoder) error

RegisterInstructionDecoder registers a decoder for the given programID. Returns an error if a different decoder is already registered for that programID. Re-registering the same decoder function is a no-op.

func ValidatePrivateKey added in v1.12.0 

func ValidatePrivateKey(b []byte) (bool, error)

Types

type Account 

type Account struct {
	// Lamports in the account.
	Lamports uint64 `json:"lamports"`

	// Data held in this account.
	Data []byte `json:"data"`

	// Owner is the program that owns this account. If executable, the
	// program that loads this account.
	Owner PublicKey `json:"owner"`

	// Executable indicates whether this account's data contains a loaded
	// program (and is now read-only).
	Executable bool `json:"executable"`

	// RentEpoch is the epoch at which this account will next owe rent.
	RentEpoch uint64 `json:"rentEpoch"`
}

Account is the on-chain state of an account: lamports, raw data, owner, executable flag, and rent epoch.

This is a port of the upstream anza-xyz/solana-sdk `account` crate's `Account` struct. It is the plain binary-state counterpart of rpc.Account (which is shaped for JSON-RPC responses): use this type when working with bincode-encoded account state, test fixtures, or off-chain tooling that mirrors validator-side types.

The bincode codec below matches the Rust serde encoding of solana_account::Account exactly (fields in declaration order, little-endian integers, Vec<u8> as u64 length + bytes).

The json tags are a plain debug/convenience form only; the resulting JSON is not compatible with the JSON-RPC shape of rpc.Account (in particular, Data encodes as base64 rather than the RPC data envelope).

NOTE: MarshalWithEncoder/UnmarshalWithDecoder are custom-codec hooks that every gagliardetto/binary encoder dispatches to, so a borsh or compact-u16 container with an Account field still emits the bincode layout for it. Likewise, embedding Account anonymously in another struct promotes these methods to the outer type, which would then (de)serialize only the Account fields; give such wrapper structs their own codec methods.

func DecodeAccount added in v1.23.0 

func DecodeAccount(data []byte) (*Account, error)

DecodeAccount decodes a bincode-encoded solana_account::Account. Trailing bytes are tolerated; see UnmarshalBinary.

func (Account) MarshalBinary added in v1.23.0 

func (a Account) MarshalBinary() ([]byte, error)

MarshalBinary bincode-encodes the account, matching the Rust serde encoding of solana_account::Account.

func (Account) MarshalWithEncoder added in v1.23.0 

func (a Account) MarshalWithEncoder(encoder *bin.Encoder) error

func (*Account) UnmarshalBinary added in v1.23.0 

func (a *Account) UnmarshalBinary(data []byte) error

UnmarshalBinary decodes a bincode-encoded account. Trailing bytes after the account are tolerated: Rust's bincode::deserialize free function is declared with allow_trailing_bytes(), and Agave decodes account state through it (e.g. Account::deserialize_data), so leniency IS the parity behavior.

func (*Account) UnmarshalWithDecoder added in v1.23.0 

func (a *Account) UnmarshalWithDecoder(decoder *bin.Decoder) error

type AccountMeta 

type AccountMeta struct {
	PublicKey  PublicKey
	IsWritable bool
	IsSigner   bool
}

func Meta added in v0.4.0 

func Meta(
	pubKey PublicKey,
) *AccountMeta

Meta intializes a new AccountMeta with the provided pubKey.

func NewAccountMeta added in v0.4.0 

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

func (*AccountMeta) SIGNER added in v0.4.0 

func (meta *AccountMeta) SIGNER() *AccountMeta

SIGNER sets IsSigner to true.

func (*AccountMeta) WRITE added in v0.4.0 

func (meta *AccountMeta) WRITE() *AccountMeta

WRITE sets IsWritable to true.

type AccountMetaSlice added in v0.4.0 

type AccountMetaSlice []*AccountMeta

func (*AccountMetaSlice) Append added in v0.4.0 

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

func (AccountMetaSlice) Get added in v1.1.0 

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 added in v0.4.0 

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

func (AccountMetaSlice) GetKeys added in v1.2.0 

func (slice AccountMetaSlice) GetKeys() PublicKeySlice

GetKeys returns the pubkeys of all AccountMeta.

func (AccountMetaSlice) GetSigners added in v0.4.0 

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

GetSigners returns the accounts that are signers.

func (AccountMetaSlice) Len added in v0.4.4 

func (slice AccountMetaSlice) Len() int

func (*AccountMetaSlice) SetAccounts added in v0.4.0 

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

func (AccountMetaSlice) SplitFrom added in v0.4.4 

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

type AccountsGettable added in v0.4.0 

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

type AccountsSettable added in v0.4.0 

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 Base64 added in v1.12.0 

type Base64 []byte

func (Base64) MarshalJSON added in v1.12.0 

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

func (*Base64) UnmarshalJSON added in v1.12.0 

func (t *Base64) 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 added in v1.2.0 

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 added in v1.2.0 

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

type DurableNonce added in v1.22.0 

type DurableNonce Hash

DurableNonce is the 32-byte value stored in an initialized nonce account and used as the recent_blockhash field of a durable-nonce transaction.

Although it is used in the recent_blockhash slot, it is NOT a real blockhash: it is derived from one via DurableNonceFromBlockhash with a domain prefix.

func DurableNonceFromBlockhash added in v1.22.0 

func DurableNonceFromBlockhash(blockhash Hash) DurableNonce

DurableNonceFromBlockhash derives a durable nonce from a blockhash, computing sha256("DURABLE_NONCE" || blockhash). Mirrors DurableNonce::from_blockhash.

func (DurableNonce) AsHash added in v1.22.0 

func (d DurableNonce) AsHash() Hash

AsHash returns the durable nonce as a Hash, i.e. the value to place in a transaction's recent_blockhash field. Mirrors DurableNonce::as_hash.

func (DurableNonce) Equals added in v1.22.0 

func (d DurableNonce) Equals(other DurableNonce) bool

Equals reports whether two durable nonces are equal.

func (DurableNonce) IsZero added in v1.22.0 

func (d DurableNonce) IsZero() bool

IsZero reports whether the durable nonce is the zero value.

func (DurableNonce) String added in v1.22.0 

func (d DurableNonce) String() string

type DurationMilliseconds added in v1.7.0 

type DurationMilliseconds int64

DurationMilliseconds represents a duration in milliseconds.

func (DurationMilliseconds) Duration added in v1.7.0 

func (res DurationMilliseconds) Duration() time.Duration

func (DurationMilliseconds) String added in v1.7.0 

func (res DurationMilliseconds) String() string

type DurationSeconds added in v1.0.1 

type DurationSeconds int64

DurationSeconds represents a duration in seconds.

func (DurationSeconds) Duration added in v1.0.1 

func (res DurationSeconds) Duration() time.Duration

func (DurationSeconds) String added in v1.0.1 

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 Feature added in v1.23.0 

type Feature struct {
	// Slot at which the feature was activated; nil while pending.
	ActivatedAt *uint64
}

Feature is the state of a feature-gate account (owner FeatureProgramID).

func DecodeFeature added in v1.23.0 

func DecodeFeature(data []byte) (Feature, error)

DecodeFeature decodes a bincode-encoded Feature (Option<u64>).

func FeatureFromAccount added in v1.23.0 

func FeatureFromAccount(owner PublicKey, data []byte) (Feature, error)

FeatureFromAccount decodes a Feature after checking the account owner, mirroring feature-gate-interface from_account.

func (Feature) IsActive added in v1.23.0 

func (f Feature) IsActive() bool

IsActive reports whether the feature has been activated.

func (Feature) MarshalWithEncoder added in v1.23.0 

func (f Feature) MarshalWithEncoder(encoder *bin.Encoder) error

func (*Feature) UnmarshalWithDecoder added in v1.23.0 

func (f *Feature) UnmarshalWithDecoder(decoder *bin.Decoder) error

type FeatureSet added in v1.23.0 

type FeatureSet map[PublicKey]uint64

FeatureSet maps feature gate IDs to their activation slot, a minimal counterpart of the Rust FeatureSet's active map. The zero value (nil) is a valid, empty set.

func (FeatureSet) ActivatedSlot added in v1.23.0 

func (fs FeatureSet) ActivatedSlot(id PublicKey) (uint64, bool)

ActivatedSlot returns the activation slot of the feature, if activated.

func (FeatureSet) IsActive added in v1.23.0 

func (fs FeatureSet) IsActive(id PublicKey) bool

IsActive reports whether the feature is activated.

type FeeCalculator added in v1.22.0 

type FeeCalculator struct {
	LamportsPerSignature uint64
}

FeeCalculator records the cost, in lamports per signature, to process a transaction. Mirrors solana-sdk fee-calculator's FeeCalculator.

func (FeeCalculator) MarshalWithEncoder added in v1.22.0 

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

func (*FeeCalculator) UnmarshalWithDecoder added in v1.22.0 

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

type GenericInstruction added in v0.5.0 

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

func NewInstruction added in v0.5.0 

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 added in v0.5.0 

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

func (*GenericInstruction) Data added in v0.5.0 

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

func (*GenericInstruction) ProgramID added in v0.5.0 

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 added in v1.0.2 

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 added in v1.6.0 

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 added in v1.6.0 

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) (any, 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 PublicKeySlice `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 (v0 only).
	AddressTableLookups MessageAddressTableLookupSlice `json:"addressTableLookups"`

	// Inline compute budget (v1 only, SIMD-0385).
	TransactionConfig TransactionConfig `json:"transactionConfig"`
	// contains filtered or unexported fields
}

func (*Message) Account added in v1.8.0 

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 added in v1.7.0 

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

AddAddressTableLookup adds a lookup; legacy becomes v0, v1 is kept.

func (*Message) EncodeToTree added in v0.4.0 

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

func (*Message) GetAccountIndex added in v1.9.0 

func (m *Message) GetAccountIndex(account PublicKey) (uint16, error)

GetAccountIndex returns the index of the given account (first occurrence of the account).

func (*Message) GetAddressTableLookupAccounts added in v1.8.0 

func (mx *Message) GetAddressTableLookupAccounts() (PublicKeySlice, 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 added in v1.7.0 

func (mx *Message) GetAddressTableLookups() MessageAddressTableLookupSlice

GetAddressTableLookups returns the lookups used by this message.

func (*Message) GetAddressTables added in v1.7.0 

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 added in v1.8.0 

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) GetIxSigners added in v1.18.0 

func (m *Message) GetIxSigners(ixIndex int) PublicKeySlice

GetIxSigners returns the set of account keys that are both signers and referenced as accounts (not program) in the instruction at the given index.

func (*Message) GetVersion added in v1.7.0 

func (m *Message) GetVersion() MessageVersion

GetVersion returns the message version.

func (*Message) HasAccount added in v1.2.0 

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

func (*Message) HasDuplicates added in v1.17.0 

func (m *Message) HasDuplicates() bool

HasDuplicates checks if the message has duplicate account keys. Uses O(n^2) comparison but requires no heap allocation, which is faster for the typically small number of accounts in a message. Ported from solana-sdk/message/legacy.rs has_duplicates().

func (*Message) IsInstructionAccount added in v1.18.0 

func (m *Message) IsInstructionAccount(index uint16) bool

IsInstructionAccount returns true if the given account index is referenced as an account (not a program) in any instruction.

func (*Message) IsResolved added in v1.11.0 

func (mx *Message) IsResolved() bool

func (*Message) IsSigner 

func (m *Message) IsSigner(account PublicKey) bool

func (*Message) IsVersioned added in v1.7.0 

func (m *Message) IsVersioned() bool

IsVersioned reports whether the message is v0 or v1 (not legacy).

func (*Message) IsWritable 

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

func (*Message) IsWritableStatic added in v1.13.0 

func (m *Message) IsWritableStatic(account PublicKey) bool

IsWritableStatic checks if the account is a writable account in the static accounts list, ignoring the accounts in the address table lookups.

func (*Message) MarshalBinary added in v0.3.5 

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

func (Message) MarshalJSON added in v1.8.4 

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

func (*Message) MarshalLegacy added in v1.7.0 

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

func (*Message) MarshalV0 added in v1.7.0 

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

func (*Message) MarshalV1 added in v1.23.0 

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

MarshalV1 encodes the message as v1 (0x81 prefix included); never truncates.

func (Message) MarshalWithEncoder added in v0.4.0 

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

func (*Message) NumLookups added in v1.8.0 

func (mx *Message) NumLookups() int

func (*Message) NumReadonlyAccounts added in v1.18.0 

func (m *Message) NumReadonlyAccounts() int

NumReadonlyAccounts returns the total number of readonly accounts (signed + unsigned) in the static account list.

func (*Message) NumWritableLookups added in v1.8.0 

func (mx *Message) NumWritableLookups() int

func (*Message) Program added in v1.8.0 

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

Program returns the program key at the given index.

func (*Message) ProgramIDs added in v1.18.0 

func (m *Message) ProgramIDs() PublicKeySlice

ProgramIDs returns the deduplicated list of program IDs used by the message's instructions.

func (*Message) ProgramPosition added in v1.18.0 

func (m *Message) ProgramPosition(index uint16) (int, bool)

ProgramPosition returns the 0-based position of the account at the given index among all program IDs invoked by the message. Returns (pos, true) if found, or (0, false) if the account is not a program ID.

func (*Message) ResolveLookups added in v1.8.0 

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) ResolveLookupsWith added in v1.13.0 

func (mx *Message) ResolveLookupsWith(writable, readonly PublicKeySlice) (err error)

ResolveLookupsWith resolves the address table lookups with the provided writable and readonly accounts, assuming that the order of the accounts is correct.

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) Sanitize added in v1.17.0 

func (m *Message) Sanitize() error

Sanitize validates the structural integrity of a Message. Ported from solana-sdk/message legacy.rs, v0/mod.rs sanitize() and v1 validate().

func (*Message) SetAddressTableLookups added in v1.7.0 

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

SetAddressTableLookups (re)sets the lookups; legacy becomes v0, v1 is kept.

func (*Message) SetAddressTables added in v1.7.0 

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 added in v1.7.0 

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

SetVersion forces the encoding version. V1 cannot carry lookups; leaving V1 with a non-empty config is an error.

func (*Message) Signers added in v1.2.0 

func (m *Message) Signers() PublicKeySlice

Signers returns the pubkeys of all accounts that are signers.

func (Message) ToBase64 added in v1.3.0 

func (mx Message) ToBase64() string

func (*Message) UnmarshalBase64 added in v1.7.0 

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

func (*Message) UnmarshalJSON added in v1.19.0 

func (mx *Message) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes the message; `addressTableLookups` selects v0, `transactionConfig` v1.

func (*Message) UnmarshalLegacy added in v1.7.0 

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

func (*Message) UnmarshalV0 added in v1.7.0 

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

func (*Message) UnmarshalV1 added in v1.23.0 

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

UnmarshalV1 decodes a v1 message from the 0x81 prefix; limits are checked by Sanitize.

func (*Message) UnmarshalWithDecoder added in v0.4.0 

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

func (*Message) Writable added in v1.2.0 

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

Writable returns the pubkeys of all accounts that are writable.

type MessageAddressTableLookup added in v1.7.0 

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

type MessageAddressTableLookupSlice added in v1.7.0 

type MessageAddressTableLookupSlice []MessageAddressTableLookup

func (MessageAddressTableLookupSlice) GetTableIDs added in v1.7.0 

func (lookups MessageAddressTableLookupSlice) GetTableIDs() PublicKeySlice

GetTableIDs returns the list of all address table IDs.

func (MessageAddressTableLookupSlice) NumLookups added in v1.7.0 

func (lookups MessageAddressTableLookupSlice) NumLookups() int

NumLookups returns the number of accounts from all the lookups.

func (MessageAddressTableLookupSlice) NumWritableLookups added in v1.8.0 

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 added in v0.4.0 

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

type MessageVersion added in v1.7.0 

type MessageVersion int
const (
	MessageVersionLegacy MessageVersion = 0 // default
	MessageVersionV0     MessageVersion = 1 // v0
	MessageVersionV1     MessageVersion = 2 // v1 (SIMD-0385)
)

type MissingRequiredSignatureError added in v1.22.0 

type MissingRequiredSignatureError struct {
	// Authority is the nonce account's current authority whose signature is
	// required.
	Authority PublicKey
}

MissingRequiredSignatureError is returned by Authorize when the current nonce authority is not among the provided signers.

func (*MissingRequiredSignatureError) Error added in v1.22.0 

func (e *MissingRequiredSignatureError) Error() string

type NonceData added in v1.22.0 

type NonceData struct {
	// Authority is the address allowed to sign transactions that consume and
	// advance this nonce.
	Authority PublicKey
	// DurableNonce is the current nonce value.
	DurableNonce DurableNonce
	// FeeCalculator records the fee in effect when the nonce was last advanced.
	FeeCalculator FeeCalculator
}

NonceData is the initialized data of a durable transaction nonce account.

func NewNonceData added in v1.22.0 

func NewNonceData(authority PublicKey, durableNonce DurableNonce, lamportsPerSignature uint64) NonceData

NewNonceData builds nonce data from an authority, durable nonce and the lamports-per-signature fee. Mirrors Data::new.

func VerifyNonceAccount added in v1.22.0 

func VerifyNonceAccount(owner PublicKey, data []byte, recentBlockhash Hash) (*NonceData, bool)

VerifyNonceAccount decodes a system-owned nonce account and verifies that recentBlockhash matches its current nonce, returning the nonce data when valid. The account owner must be the System program. Mirrors nonce_account::verify_nonce_account.

func (NonceData) Blockhash added in v1.22.0 

func (d NonceData) Blockhash() Hash

Blockhash returns the hash to use as a transaction's recent_blockhash when spending this nonce. Mirrors Data::blockhash.

func (NonceData) LamportsPerSignature added in v1.22.0 

func (d NonceData) LamportsPerSignature() uint64

LamportsPerSignature returns the per-signature fee recorded for the next transaction that uses this nonce. Mirrors Data::get_lamports_per_signature.

func (NonceData) MarshalWithEncoder added in v1.22.0 

func (d NonceData) MarshalWithEncoder(encoder *bin.Encoder) (err error)

func (*NonceData) UnmarshalWithDecoder added in v1.22.0 

func (d *NonceData) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

type NonceState added in v1.22.0 

type NonceState struct {
	Kind NonceStateKind
	// Data is meaningful only when Kind == NonceStateInitialized.
	Data NonceData
}

NonceState is the state of a durable transaction nonce account: a discriminated union that is either Uninitialized or Initialized with NonceData.

func NewInitializedNonceState added in v1.22.0 

func NewInitializedNonceState(authority PublicKey, durableNonce DurableNonce, lamportsPerSignature uint64) NonceState

NewInitializedNonceState builds an initialized nonce state. Mirrors State::new_initialized.

func (NonceState) IsInitialized added in v1.22.0 

func (s NonceState) IsInitialized() bool

IsInitialized reports whether the nonce account has been initialized.

func (NonceState) MarshalWithEncoder added in v1.22.0 

func (s NonceState) MarshalWithEncoder(encoder *bin.Encoder) (err error)

func (*NonceState) UnmarshalWithDecoder added in v1.22.0 

func (s *NonceState) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

type NonceStateKind added in v1.22.0 

type NonceStateKind uint32

NonceStateKind identifies whether a nonce account has been initialized. 

const (
	NonceStateUninitialized NonceStateKind = 0
	NonceStateInitialized   NonceStateKind = 1
)

type NonceVersion added in v1.22.0 

type NonceVersion uint32

NonceVersion identifies the version of a nonce account's state. Only Current nonces have durable-nonce and blockhash domains separated and can therefore authorize durable-nonce transactions. 

const (
	NonceVersionLegacy  NonceVersion = 0
	NonceVersionCurrent NonceVersion = 1
)

type NonceVersions added in v1.22.0 

type NonceVersions struct {
	Version NonceVersion
	State   NonceState
}

NonceVersions wraps a NonceState together with its version. It is the type stored in a nonce account's data. Mirrors solana_nonce::versions::Versions.

func DecodeNonceVersions added in v1.22.0 

func DecodeNonceVersions(data []byte) (*NonceVersions, error)

DecodeNonceVersions decodes a nonce account's data into NonceVersions. Any trailing bytes (e.g. the zero padding present because the account is allocated at NonceStateSize) are ignored. The account-verification helpers use decodeNonceVersionsStrict instead, to match upstream bincode semantics.

func NewNonceVersions added in v1.22.0 

func NewNonceVersions(state NonceState) NonceVersions

NewNonceVersions wraps a state in a Current version. Mirrors Versions::new.

func (NonceVersions) Authorize added in v1.22.0 

func (v NonceVersions) Authorize(signers []PublicKey, newAuthority PublicKey) (NonceVersions, error)

Authorize sets a new authority on the nonce account. The current authority must be present in signers. The version variant is preserved because the durable_nonce field is not changed here. Mirrors Versions::authorize.

func (NonceVersions) LamportsPerSignature added in v1.22.0 

func (v NonceVersions) LamportsPerSignature() (uint64, bool)

LamportsPerSignature returns the per-signature fee of an initialized nonce, or (0, false) when uninitialized.

func (NonceVersions) MarshalAccountData added in v1.22.0 

func (v NonceVersions) MarshalAccountData() ([]byte, error)

MarshalAccountData returns the on-chain account data for this nonce, zero- padded to NonceStateSize bytes the way the runtime allocates it.

func (NonceVersions) MarshalBinary added in v1.22.0 

func (v NonceVersions) MarshalBinary() ([]byte, error)

MarshalBinary returns the bincode-serialized nonce versions (8 bytes when uninitialized, NonceStateSize bytes when initialized).

func (NonceVersions) MarshalWithEncoder added in v1.22.0 

func (v NonceVersions) MarshalWithEncoder(encoder *bin.Encoder) (err error)

func (*NonceVersions) UnmarshalBinary added in v1.22.0 

func (v *NonceVersions) UnmarshalBinary(data []byte) error

UnmarshalBinary decodes nonce versions from bincode-serialized bytes, satisfying encoding.BinaryUnmarshaler as the counterpart to MarshalBinary. Like DecodeNonceVersions it tolerates trailing bytes (e.g. account padding).

func (*NonceVersions) UnmarshalWithDecoder added in v1.22.0 

func (v *NonceVersions) UnmarshalWithDecoder(decoder *bin.Decoder) (err error)

func (NonceVersions) Upgrade added in v1.22.0 

func (v NonceVersions) Upgrade() (NonceVersions, bool)

Upgrade migrates a Legacy nonce into the Current durable-nonce domain. It returns (_, false) when there is nothing to upgrade: the nonce is already Current, or it is an uninitialized Legacy nonce (which is upgraded on initialization instead). Mirrors Versions::upgrade.

func (NonceVersions) VerifyRecentBlockhash added in v1.22.0 

func (v NonceVersions) VerifyRecentBlockhash(recentBlockhash Hash) (*NonceData, bool)

VerifyRecentBlockhash checks that recentBlockhash matches this nonce and returns the nonce data if so. Legacy versions never verify, because durable nonces in the legacy blockhash domain are invalid. Mirrors Versions::verify_recent_blockhash.

type PK added in v1.7.0 

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 PrivateKeyFromMnemonic added in v1.21.0 

func PrivateKeyFromMnemonic(mnemonic, passphrase string) (PrivateKey, error)

PrivateKeyFromMnemonic derives a PrivateKey from a BIP-39 mnemonic using the default Solana derivation path (m/44'/501'/0'/0'). The passphrase may be empty; when set, it must match the passphrase used when the mnemonic was generated.

func PrivateKeyFromMnemonicAtPath added in v1.21.0 

func PrivateKeyFromMnemonicAtPath(mnemonic, passphrase, path string) (PrivateKey, error)

PrivateKeyFromMnemonicAtPath derives a PrivateKey from a BIP-39 mnemonic at the given SLIP-0010 derivation path. All path segments must be hardened (suffixed with ' or h); SLIP-0010 does not define non-hardened derivation for ed25519.

func PrivateKeyFromSeedAtPath added in v1.21.0 

func PrivateKeyFromSeedAtPath(seed []byte, path string) (PrivateKey, error)

PrivateKeyFromSeedAtPath derives a PrivateKey from a 16..64 byte seed (typically a 64 byte BIP-39 seed) using the given SLIP-0010 derivation path. All path segments must be hardened.

func PrivateKeyFromSolanaKeygenFile 

func PrivateKeyFromSolanaKeygenFile(file string) (PrivateKey, error)

func PrivateKeyFromSolanaKeygenFileBytes added in v1.12.0 

func PrivateKeyFromSolanaKeygenFileBytes(content []byte) (PrivateKey, error)

func (PrivateKey) IsValid added in v1.12.0 

func (k PrivateKey) IsValid() bool

IsValid returns whether the private key is valid.

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

func (PrivateKey) Validate added in v1.12.0 

func (k PrivateKey) Validate() error

type PublicKey 

type PublicKey [PublicKeyLength]byte

func CreateProgramAddress added in v0.4.0 

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 added in v0.4.0 

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 added in v0.4.0 

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

func FindAssociatedTokenAddressWithProgram added in v1.17.0 

func FindAssociatedTokenAddressWithProgram(
	wallet PublicKey,
	mint PublicKey,
	tokenProgram PublicKey,
) (PublicKey, uint8, error)

FindAssociatedTokenAddressWithProgram returns the associated token account PDA for the provided wallet, mint, and token program.

func FindProgramAddress added in v0.4.0 

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

Find a valid program address and its corresponding bump seed.

func FindTokenMetadataAddress added in v1.0.2 

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

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

func GetAssociatedAuthority added in v1.12.0 

func GetAssociatedAuthority(programID PublicKey, marketAddr PublicKey) (PublicKey, uint8, error)

Get the marketAuthority(PDA) from the Market Initialization

func MPK added in v1.7.0 

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)

PublicKeyFromBase58 creates a PublicKey from a base58 encoded string. NOTE: it will accept on- and off-curve pubkeys.

func PublicKeyFromBytes 

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

PublicKeyFromBytes creates a PublicKey from a byte slice that must be 32 bytes long. NOTE: it will accept on- and off-curve pubkeys.

func (PublicKey) Bytes added in v0.4.0 

func (p PublicKey) Bytes() []byte

func (PublicKey) Equals 

func (p PublicKey) Equals(pb PublicKey) bool

func (PublicKey) IsAnyOf added in v1.8.0 

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

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

func (PublicKey) IsOnCurve added in v1.0.4 

func (p PublicKey) IsOnCurve() bool

Check if a `Pubkey` is on the voied25519 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 added in v1.8.2 

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

MarshalBSON implements the bson.Marshaler interface.

func (PublicKey) MarshalBSONValue added in v1.8.2 

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

MarshalBSONValue implements the bson.ValueMarshaler interface.

func (PublicKey) MarshalJSON 

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

func (PublicKey) MarshalText added in v0.3.4 

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

func (*PublicKey) Set added in v1.4.0 

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

func (PublicKey) Short added in v1.1.0 

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 added in v0.4.0 

func (p PublicKey) ToPointer() *PublicKey

ToPointer returns a pointer to the pubkey.

func (*PublicKey) UnmarshalBSON added in v1.8.2 

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

UnmarshalBSON implements the bson.Unmarshaler interface.

func (*PublicKey) UnmarshalBSONValue added in v1.8.2 

func (p *PublicKey) UnmarshalBSONValue(t bson.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 added in v0.3.4 

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

func (PublicKey) Verify added in v1.7.0 

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

type PublicKeySlice added in v0.4.0 

type PublicKeySlice []PublicKey

func (PublicKeySlice) Added added in v1.7.0 

func (a PublicKeySlice) Added(b PublicKeySlice) PublicKeySlice

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

func (*PublicKeySlice) Append added in v0.4.0 

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

func (PublicKeySlice) Contains added in v1.7.0 

func (slice PublicKeySlice) Contains(pubkey PublicKey) bool

Contains returns true if the slice contains the provided pubkey.

func (PublicKeySlice) ContainsAll added in v1.7.0 

func (slice PublicKeySlice) ContainsAll(pubkeys PublicKeySlice) bool

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

func (PublicKeySlice) ContainsAny added in v1.7.0 

func (slice PublicKeySlice) ContainsAny(pubkeys ...PublicKey) bool

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

func (PublicKeySlice) Dedupe added in v1.7.0 

func (slice PublicKeySlice) Dedupe() PublicKeySlice

Dedupe returns a new slice with all duplicate pubkeys removed.

func (PublicKeySlice) Equals added in v1.7.0 

func (slice PublicKeySlice) Equals(other PublicKeySlice) bool

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

func (PublicKeySlice) First added in v1.7.0 

func (slice PublicKeySlice) First() *PublicKey

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

func (PublicKeySlice) GetAddedRemoved added in v1.7.0 

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 added in v0.4.0 

func (slice PublicKeySlice) Has(pubkey PublicKey) bool

func (PublicKeySlice) Intersect added in v1.7.0 

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 added in v1.7.0 

func (slice PublicKeySlice) Last() *PublicKey

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

func (PublicKeySlice) Len added in v1.7.0 

func (slice PublicKeySlice) Len() int

func (PublicKeySlice) Less added in v1.7.0 

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

func (PublicKeySlice) Removed added in v1.7.0 

func (a PublicKeySlice) Removed(b PublicKeySlice) PublicKeySlice

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

func (PublicKeySlice) Same added in v1.7.0 

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 added in v1.7.0 

func (slice PublicKeySlice) Sort()

Sort sorts the slice.

func (PublicKeySlice) Split added in v1.1.0 

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

Split splits the slice into chunks of the specified size.

func (PublicKeySlice) Swap added in v1.7.0 

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

func (PublicKeySlice) ToBase58 added in v1.7.0 

func (slice PublicKeySlice) ToBase58() []string

func (PublicKeySlice) ToBytes added in v1.7.0 

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

func (PublicKeySlice) ToPointers added in v1.7.0 

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

func (*PublicKeySlice) UniqueAppend added in v0.4.0 

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 added in v1.2.0 

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 added in v1.6.0 

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 added in v1.6.0 

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

func (Signature) Verify added in v1.2.0 

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

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

type SystemAccountKind added in v1.22.0 

type SystemAccountKind int

SystemAccountKind classifies a system-program-owned account. 

const (
	SystemAccountKindSystem SystemAccountKind = iota
	SystemAccountKindNonce
)

func GetSystemAccountKind added in v1.22.0 

func GetSystemAccountKind(owner PublicKey, data []byte) (SystemAccountKind, bool)

GetSystemAccountKind classifies a system-program-owned account as a plain system account or an initialized nonce account, returning (_, false) for any other account (wrong owner, or data that is neither empty nor a valid initialized nonce). Mirrors nonce_account::get_system_account_kind.

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.
	// Wire: legacy/v0 = compact-u16 count + sigs + message; v1 = message + sigs.
	Signatures []Signature `json:"signatures"`

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

func MustTransactionFromDecoder added in v0.4.1 

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)
Example (V1)

ExampleNewTransaction_v1 builds, signs, serializes and decodes a V1 (SIMD-0385) transaction with an inline compute budget configuration. 

package main

import (
	"crypto/ed25519"
	"fmt"

	"github.com/gagliardetto/solana-go"
)

func main() {
	// Deterministic keys for the example; use solana.NewWallet() in real code.
	payerKey := solana.PrivateKey(ed25519.NewKeyFromSeed(make([]byte, 32)))
	payer := payerKey.PublicKey()
	recipient := solana.MustPublicKeyFromBase58("2mHtsPqiHkQKKh6t2Q1jGwYQ8vG7ULfF7c9k4t9BvGkw")
	programID := solana.SystemProgramID

	// Any Instruction works; this is a raw System Program transfer of 1 lamport.
	data := []byte{2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}
	ix := solana.NewInstruction(programID, solana.AccountMetaSlice{
		solana.Meta(payer).WRITE().SIGNER(),
		solana.Meta(recipient).WRITE(),
	}, data)

	// A zero blockhash for the example; fetch it from the RPC in real code.
	var blockhash solana.Hash

	tx, err := solana.NewTransaction(
		[]solana.Instruction{ix},
		blockhash,
		solana.TransactionPayer(payer),
		// Selects v1; unset CU limit means 0, PriorityFee is total lamports.
		solana.TransactionV1Config(solana.TransactionConfig{}.
			WithComputeUnitLimit(20_000).
			WithPriorityFee(1_000)),
	)
	if err != nil {
		panic(err)
	}
	if _, err := tx.Sign(func(key solana.PublicKey) *solana.PrivateKey {
		if key.Equals(payer) {
			return &payerKey
		}
		return nil
	}); err != nil {
		panic(err)
	}

	// Wire: 0x81 prefix first, signatures last (no length prefix).
	wire, err := tx.MarshalBinary()
	if err != nil {
		panic(err)
	}

	decoded, err := solana.TransactionFromBytes(wire)
	if err != nil {
		panic(err)
	}
	fmt.Println("version:", decoded.Message.GetVersion() == solana.MessageVersionV1)
	fmt.Println("prefix: 0x" + fmt.Sprintf("%02x", wire[0]))
	fmt.Println("compute unit limit:", *decoded.Message.TransactionConfig.ComputeUnitLimit)
	fmt.Println("priority fee:", *decoded.Message.TransactionConfig.PriorityFee)
	fmt.Println("heap size requested:", decoded.Message.TransactionConfig.HeapSize != nil)
	fmt.Println("size ok:", len(wire) <= solana.MaxTransactionSizeV1)
	fmt.Println("signatures valid:", decoded.VerifySignatures() == nil)
}

Output:
version: true
prefix: 0x81
compute unit limit: 20000
priority fee: 1000
heap size requested: false
size ok: true
signatures valid: true

func TransactionFromBase58 added in v1.11.0 

func TransactionFromBase58(b58 string) (*Transaction, error)

func TransactionFromBase64 added in v1.11.0 

func TransactionFromBase64(b64 string) (*Transaction, error)

func TransactionFromBytes added in v1.11.0 

func TransactionFromBytes(data []byte) (*Transaction, error)

TransactionFromBytes decodes a transaction from the whole slice. For v1, trailing bytes are rejected (SIMD-0385); legacy/v0 stay lenient. Streaming callers can use TransactionFromDecoder, which is always lenient.

func TransactionFromDecoder added in v0.4.0 

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 added in v0.4.0 

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

func (*Transaction) EncodeTree added in v0.4.0 

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

func (*Transaction) GetAccountIndex added in v1.9.0 

func (t *Transaction) GetAccountIndex(account PublicKey) (uint16, error)

func (*Transaction) GetNonceAccount added in v1.17.0 

func (tx *Transaction) GetNonceAccount() (PublicKey, bool)

GetNonceAccount returns the public key of the nonce account if this transaction uses a durable nonce. The nonce account is the first account of the first instruction (the AdvanceNonceAccount instruction). Returns the zero PublicKey and false if this is not a nonce transaction.

func (*Transaction) GetProgramIDs added in v1.11.0 

func (tx *Transaction) GetProgramIDs() (PublicKeySlice, error)

func (*Transaction) HasAccount added in v1.2.0 

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

func (*Transaction) IsSigner 

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

func (*Transaction) IsVote added in v1.13.0 

func (tx *Transaction) IsVote() bool

func (*Transaction) IsWritable 

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

func (*Transaction) MarshalBinary added in v0.3.5 

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

func (Transaction) MarshalWithEncoder added in v0.4.0 

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

func (Transaction) MustToBase64 added in v1.3.0 

func (tx Transaction) MustToBase64() string

func (*Transaction) NumReadonlyAccounts added in v1.11.0 

func (tx *Transaction) NumReadonlyAccounts() int

func (*Transaction) NumSigners added in v1.11.0 

func (tx *Transaction) NumSigners() int

func (*Transaction) NumWriteableAccounts added in v1.11.0 

func (tx *Transaction) NumWriteableAccounts() int

func (*Transaction) PartialSign added in v1.7.0 

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

func (*Transaction) ResolveProgramIDIndex 

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

func (*Transaction) Sanitize added in v1.17.0 

func (tx *Transaction) Sanitize() error

Sanitize validates the structural integrity of a Transaction. It checks that the signature count matches the message header and that the message itself is valid. Ported from solana-sdk/transaction: lib.rs and versioned/mod.rs sanitize().

func (*Transaction) Sign 

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

func (*Transaction) String added in v1.2.0 

func (tx *Transaction) String() string

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

func (Transaction) ToBase64 added in v1.3.0 

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

func (*Transaction) UnmarshalBase64 added in v1.7.0 

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

UnmarshalBase64 decodes a base64 encoded transaction.

func (*Transaction) UnmarshalWithDecoder added in v0.4.0 

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

func (*Transaction) UsesDurableNonce added in v1.17.0 

func (tx *Transaction) UsesDurableNonce() bool

UsesDurableNonce checks whether this transaction uses a durable nonce by inspecting the first instruction. Returns true if the first instruction is a System Program AdvanceNonceAccount instruction. Ported from solana-sdk/transaction: uses_durable_nonce().

func (*Transaction) VerifySignatures added in v1.2.0 

func (tx *Transaction) VerifySignatures() error

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

func (*Transaction) VerifyWithResults added in v1.17.0 

func (tx *Transaction) VerifyWithResults() ([]bool, error)

VerifyWithResults verifies each signature independently and returns a per-signature boolean result. Ported from solana-sdk/transaction/lib.rs verify_with_results().

type TransactionBuilder added in v0.4.0 

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

func NewTransactionBuilder added in v0.4.0 

func NewTransactionBuilder() *TransactionBuilder

NewTransactionBuilder creates a new instruction builder.

func (*TransactionBuilder) AddInstruction added in v0.4.0 

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

AddInstruction adds the provided instruction to the builder.

func (*TransactionBuilder) Build added in v0.4.0 

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

Build builds and returns a *Transaction.

func (*TransactionBuilder) SetFeePayer added in v0.4.0 

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 added in v0.4.0 

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

SetRecentBlockHash sets the recent blockhash for the instruction builder.

func (*TransactionBuilder) SetTransactionConfig added in v1.23.0 

func (builder *TransactionBuilder) SetTransactionConfig(config TransactionConfig) *TransactionBuilder

SetTransactionConfig sets the v1 inline compute budget (see TransactionV1Config).

func (*TransactionBuilder) SetVersion added in v1.23.0 

func (builder *TransactionBuilder) SetVersion(version MessageVersion) *TransactionBuilder

SetVersion selects the message version (see TransactionMessageVersion).

func (*TransactionBuilder) WithOpt added in v0.4.0 

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

WithOpt adds a TransactionOption.

type TransactionConfig added in v1.23.0 

type TransactionConfig struct {
	// Total priority fee in lamports.
	PriorityFee *uint64 `json:"priorityFee"`
	// Maximum compute units; nil means 0.
	ComputeUnitLimit *uint32 `json:"computeUnitLimit"`
	// Maximum bytes of loaded account data; nil means 0.
	LoadedAccountsDataSizeLimit *uint32 `json:"loadedAccountsDataSizeLimit"`
	// Heap size: multiple of 1024 in [MinHeapSizeV1, MaxHeapSizeV1]; nil means default.
	HeapSize *uint32 `json:"heapSize"`
}

TransactionConfig is the v1 inline compute budget; nil field = not requested. Unset ComputeUnitLimit means 0 CUs; PriorityFee is total lamports.

func (*TransactionConfig) EncodeToTree added in v1.23.0 

func (c *TransactionConfig) EncodeToTree(branch treeout.Branches)

EncodeToTree renders the config; unset fields are shown as "<unset>".

func (TransactionConfig) IsEmpty added in v1.23.0 

func (c TransactionConfig) IsEmpty() bool

IsEmpty reports whether no config value is set.

func (TransactionConfig) Mask added in v1.23.0 

func (c TransactionConfig) Mask() TransactionConfigMask

Mask returns the TransactionConfigMask describing which values are set.

func (TransactionConfig) Size added in v1.23.0 

func (c TransactionConfig) Size() int

Size returns the encoded size of the config values in bytes.

func (TransactionConfig) WithComputeUnitLimit added in v1.23.0 

func (c TransactionConfig) WithComputeUnitLimit(units uint32) TransactionConfig

WithComputeUnitLimit returns a copy with the compute unit limit set.

func (TransactionConfig) WithHeapSize added in v1.23.0 

func (c TransactionConfig) WithHeapSize(bytes uint32) TransactionConfig

WithHeapSize returns a copy with the heap size set (validated by Sanitize).

func (TransactionConfig) WithLoadedAccountsDataSizeLimit added in v1.23.0 

func (c TransactionConfig) WithLoadedAccountsDataSizeLimit(bytes uint32) TransactionConfig

WithLoadedAccountsDataSizeLimit returns a copy with the loaded accounts data size limit set.

func (TransactionConfig) WithPriorityFee added in v1.23.0 

func (c TransactionConfig) WithPriorityFee(lamports uint64) TransactionConfig

WithPriorityFee returns a copy with the priority fee (total lamports) set.

type TransactionConfigMask added in v1.23.0 

type TransactionConfigMask uint32

TransactionConfigMask flags which config values a V1 message carries. 

const (
	// TransactionConfigMaskPriorityFee: bits 0-1 (both required), u64 LE.
	TransactionConfigMaskPriorityFee TransactionConfigMask = 0b11
	// TransactionConfigMaskComputeUnitLimit: bit 2, u32 LE.
	TransactionConfigMaskComputeUnitLimit TransactionConfigMask = 0b100
	// TransactionConfigMaskLoadedAccountsDataSize: bit 3, u32 LE.
	TransactionConfigMaskLoadedAccountsDataSize TransactionConfigMask = 0b1000
	// TransactionConfigMaskHeapSize: bit 4, u32 LE.
	TransactionConfigMaskHeapSize TransactionConfigMask = 0b10000
	// TransactionConfigMaskKnownBits is the union of all supported bits.
	TransactionConfigMaskKnownBits = TransactionConfigMaskPriorityFee |
		TransactionConfigMaskComputeUnitLimit |
		TransactionConfigMaskLoadedAccountsDataSize |
		TransactionConfigMaskHeapSize
)

func (TransactionConfigMask) HasComputeUnitLimit added in v1.23.0 

func (m TransactionConfigMask) HasComputeUnitLimit() bool

HasComputeUnitLimit reports whether the compute unit limit bit is set.

func (TransactionConfigMask) HasHeapSize added in v1.23.0 

func (m TransactionConfigMask) HasHeapSize() bool

HasHeapSize reports whether the heap size bit is set.

func (TransactionConfigMask) HasInvalidPriorityFeeBits added in v1.23.0 

func (m TransactionConfigMask) HasInvalidPriorityFeeBits() bool

HasInvalidPriorityFeeBits reports whether exactly one priority fee bit is set.

func (TransactionConfigMask) HasLoadedAccountsDataSize added in v1.23.0 

func (m TransactionConfigMask) HasLoadedAccountsDataSize() bool

HasLoadedAccountsDataSize reports whether the loaded accounts data size bit is set.

func (TransactionConfigMask) HasPriorityFee added in v1.23.0 

func (m TransactionConfigMask) HasPriorityFee() bool

HasPriorityFee reports whether both priority fee bits are set.

func (TransactionConfigMask) HasUnknownBits added in v1.23.0 

func (m TransactionConfigMask) HasUnknownBits() bool

HasUnknownBits reports whether any unsupported bit is set.

func (TransactionConfigMask) SizeOfConfig added in v1.23.0 

func (m TransactionConfigMask) SizeOfConfig() int

SizeOfConfig returns the encoded size of the flagged config values.

type TransactionOption 

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

func TransactionAddressTables added in v1.8.0 

func TransactionAddressTables(tables map[PublicKey]PublicKeySlice) TransactionOption

func TransactionMessageVersion added in v1.23.0 

func TransactionMessageVersion(version MessageVersion) TransactionOption

TransactionMessageVersion selects the message version built by NewTransaction. V1 rejects address tables and ComputeBudget instructions; prefer TransactionV1Config.

func TransactionPayer 

func TransactionPayer(payer PublicKey) TransactionOption

func TransactionV1Config added in v1.23.0 

func TransactionV1Config(config TransactionConfig) TransactionOption

TransactionV1Config sets the v1 inline compute budget and implies MessageVersionV1.

type Uint8SliceAsNum added in v1.8.4 

type Uint8SliceAsNum []uint8

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

func (Uint8SliceAsNum) MarshalJSON added in v1.8.4 

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

MarshalJSON implements json.Marshaler.

type UnixTimeMilliseconds added in v1.5.0 

type UnixTimeMilliseconds int64

UnixTimeMilliseconds represents a UNIX millisecond-resolution timestamp.

func (UnixTimeMilliseconds) String added in v1.5.0 

func (res UnixTimeMilliseconds) String() string

func (UnixTimeMilliseconds) Time added in v1.5.0 

func (res UnixTimeMilliseconds) Time() time.Time

type UnixTimeSeconds added in v0.5.0 

type UnixTimeSeconds int64

UnixTimeSeconds represents a UNIX second-resolution timestamp.

func (UnixTimeSeconds) String added in v0.5.1 

func (res UnixTimeSeconds) String() string

func (UnixTimeSeconds) Time added in v0.5.0 

func (res UnixTimeSeconds) Time() time.Time

type Wallet added in v0.4.2 

type Wallet struct {
	PrivateKey PrivateKey
}

Wallet is a wrapper around a PrivateKey

func NewWallet added in v0.4.2 

func NewWallet() *Wallet

func NewWalletFromMnemonic added in v1.21.0 

func NewWalletFromMnemonic(mnemonic, passphrase string) (*Wallet, error)

NewWalletFromMnemonic creates a Wallet whose private key is derived from a BIP-39 mnemonic using the default Solana derivation path m/44'/501'/0'/0'.

func WalletFromPrivateKeyBase58 added in v0.4.2 

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

func (*Wallet) PublicKey added in v0.4.2 

func (a *Wallet) PublicKey() PublicKey

Source Files

View all Source files

Directories

Path Synopsis
Package bip39 is the Golang implementation of the BIP39 spec.
 Package bip39 is the Golang implementation of the BIP39 spec.
wordlists
cmd
slnc command
slnc/cmd
programs
address-lookup-table
associated-token-account
bpf-loader
compute-budget
Package computebudget provides the ComputeBudget program instructions.
 Package computebudget provides the ComputeBudget program instructions.
memo
stake
system
token
token-2022
token-2022/zkencryption
Package zkencryption ports the deterministic key-derivation functions from solana-zk-sdk (zk-sdk/src/encryption) to Go.
 Package zkencryption ports the deterministic key-derivation functions from solana-zk-sdk (zk-sdk/src/encryption) to Go.
token-2022/zkencryption/examples/deriveKeys command
Command deriveKeys shows how to deterministically derive the two key materials used by the Token-2022 confidential-transfer extension from a Solana signer: the ElGamal secret key and the AES (AeKey) key.
 Command deriveKeys shows how to deterministically derive the two key materials used by the Token-2022 confidential-transfer extension from a Solana signer: the ElGamal secret key and the AES (AeKey) key.
tokenregistry
vote
rpc
examples/createMint command
createMint builds and submits the two-instruction transaction that creates a new SPL Token mint on devnet:
 createMint builds and submits the two-instruction transaction that creates a new SPL Token mint on devnet:
examples/getAccountInfo command
examples/getBalance command
examples/getBlock command
examples/getBlockCommitment command
examples/getBlockHeight command
examples/getBlockProduction command
examples/getBlockTime command
examples/getBlocks command
examples/getBlocksWithLimit command
examples/getClusterNodes command
examples/getEpochInfo command
examples/getEpochSchedule command
examples/getFeeForMessage command
examples/getFirstAvailableBlock command
examples/getGenesisHash command
examples/getHealth command
examples/getHighestSnapshotSlot command
examples/getIdentity command
examples/getInflationGovernor command
examples/getInflationRate command
examples/getInflationReward command
examples/getLargestAccounts command
examples/getLatestBlockhash command
examples/getLeaderSchedule command
examples/getMaxRetransmitSlot command
examples/getMaxShredInsertSlot command
examples/getMinimumBalanceForRentExemption command
examples/getMultipleAccounts command
examples/getProgramAccounts command
examples/getRecentPerformanceSamples command
examples/getSignatureStatuses command
examples/getSignaturesForAddress command
examples/getSlot command
examples/getSlotLeader command
examples/getSlotLeaders command
examples/getSupply command
examples/getTokenAccountBalance command
examples/getTokenAccountsByDelegate command
examples/getTokenAccountsByOwner command
examples/getTokenLargestAccounts command
examples/getTokenSupply command
examples/getTransaction command
examples/getTransactionCount command
examples/getVersion command
examples/getVoteAccounts command
examples/isBlockhashValid command
examples/minimumLedgerSlot command
examples/requestAirdrop command
examples/sendEncodedTransaction command
examples/sendRawTransaction command
examples/sendTransaction command
examples/sendTransactionV1 command
examples/simulateTransaction command
jsonrpc
Package jsonrpc provides a JSON-RPC 2.0 client that sends JSON-RPC requests and receives JSON-RPC responses using HTTP.
 Package jsonrpc provides a JSON-RPC 2.0 client that sends JSON-RPC requests and receives JSON-RPC responses using HTTP.
sendAndConfirmTransaction
ws
ws/examples/accountSubscribe command
ws/examples/logsSubscribe command
ws/examples/programSubscribe command
ws/examples/rootSubscribe command
ws/examples/signatureSubscribe command
ws/examples/slotSubscribe command
ws/examples/voteSubscribe command
format

Jump to

Keyboard shortcuts

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