SOL Staking

import { Coinbase, ExternalAddress } from "@coinbase/coinbase-sdk";

// Create a new external address on the solana-devnet testnet network.
let address = new ExternalAddress(Coinbase.networks.SolanaDevnet, "YOUR_WALLET_ADDRESS");

// Find out how much SOL is available to stake.
let stakeableBalance = await address.stakeableBalance(Coinbase.assets.Sol);

// Build a stake operation for an amount <= stakeableBalance, in this case 0.1 SOL.
let stakingOperation = await address.buildStakeOperation(0.1, Coinbase.assets.Sol);

// Code assumes you've already created a CDP client as shown in the quickstart guide.

// Create a new external address on the solana-devnet testnet network.
address := coinbase.NewExternalAddress(coinbase.SolanaDevnet, "YOUR_WALLET_ADDRESS")

// Get the amount of SOL available to stake.
stakeableBalance, err := client.GetStakeableBalance(ctx, coinbase.Sol, address)
if err != nil {
    return err
}

// Build a stake operation for an amount <= stakeableBalance, in this case 0.1 SOL.
stakingOperation, err := client.BuildStakeOperation(
    context.Background(),
    big.NewFloat(0.1),
    coinbase.Sol,
    address,
)
if err != nil {
    return err
}

import { Coinbase, ExternalAddress } from "@coinbase/coinbase-sdk";

// Create a new external address on the solana-devnet testnet network.
let address = new ExternalAddress(Coinbase.networks.SolanaDevnet, "YOUR_WALLET_ADDRESS");

// To determine the amount of SOL available to unstake, use the `unstakeableBalance` method as shown below:
let unstakeableBalance = await address.unstakeableBalance(Coinbase.assets.Sol);

// Build an unstake operation for an amount <= unstakeableBalance, in this case 0.1 SOL.
let stakingOperation = await address.buildUnstakeOperation(0.1, Coinbase.assets.Sol);

// Code assumes you've already created a CDP client as shown in the quickstart guide.

// Create a new external address on the solana-devnet testnet network.
address := coinbase.NewExternalAddress(coinbase.SolanaDevnet, "YOUR_WALLET_ADDRESS")

// To determine the amount of SOL available to unstake, use the `unstakeableBalance` method as shown below:
unstakeableBalance, err := client.GetUnstakeableBalance(ctx, coinbase.Sol, address)
if err != nil {
    return err
}

// Build an unstake operation for an amount <= unstakeableBalance, in this case 0.1 SOL.
stakingOperation, err := client.BuildStakeOperation(
    context.Background(),
    big.NewFloat(0.1),
    coinbase.Sol,
    address,
)
if err != nil {
    return err
}

import { Coinbase, ExternalAddress } from "@coinbase/coinbase-sdk";

// Create a new external address on the solana-devnet testnet network.
let address = new ExternalAddress(Coinbase.networks.SolanaDevnet, "YOUR_WALLET_ADDRESS");

// Check if there is any balance available to claim.
let claimableBalance = await address.unstakeableBalance(Coinbase.assets.Sol);

// Build a claim_stake operation for an amount = claimableBalance.
// The claim stake operation aims to claim all the withdrawable SOL at that point in time.
let stakingOperation = await address.buildClaimStakeOperation(claimableBalance, Coinbase.assets.Sol);

// Code assumes you've already created a CDP client as shown in the quickstart guide.

// Create a new external address on the solana-devnet testnet network.
address := coinbase.NewExternalAddress(coinbase.SolanaDevnet, "YOUR_WALLET_ADDRESS")

// Check if there is any balance available to claim.
claimableBalance, err := client.GetClaimableBalance(ctx, coinbase.Sol, address)
if err != nil {
    return err
}

// Build a claim_stake operation for an amount = claimableBalance.
// The claim stake operation aims to claim all the withdrawable SOL at that point in time.
stakingOperation, err := client.BuildClaimStakeOperation(
    context.Background(),
    claimableBalance.Amount(),
    coinbase.Sol,
    address,
)
if err != nil {
    return err
}

import { Coinbase, ExternalAddress } from "@coinbase/coinbase-sdk";

// Create a new external address on the solana-mainnet network for which you want to view staking rewards.
let address = new ExternalAddress(Coinbase.networks.SolanaMainnet, "YOUR_WALLET_ADDRESS");

// Get the rewards earned from staking in the last 1 week (default window).
// Note that it can take several hours for new rewards to show up.
let rewards = await address.stakingRewards(Coinbase.assets.Sol);

// Loop through the rewards and print each staking reward.
rewards.forEach(reward => console.log(reward.toString()));

const balances = await StakingBalance.list(
    NetworkIdentifier.SolanaMainnet,
    Coinbase.assets.Sol,
    wallet,
    startTime,
    new Date().toISOString(),
);

// Get the balances earned from staking in the last 10 days.
// Note that it can take several hours for balance snapshots to show up.
balances, err := client.ListHistoricalStakingBalances(
    ctx,
    coinbase.Sol,
    address,
    time.Now().Add(-10*24*time.Hour),
    time.Now(),
)
if err != nil {
    log.Fatalf("error fetching staking balances: %v", err)
}

// Loop through the balances and print each staking balance.
for _, balance := range balances {
    log.Printf("Staking balance: %s", balance.String())
}

package main

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

    "github.com/btcsuite/btcutil/base58"
    "github.com/coinbase/coinbase-sdk-go/pkg/coinbase"
    bin "github.com/gagliardetto/binary"
    "github.com/gagliardetto/solana-go"
    "github.com/gagliardetto/solana-go/rpc"
)

const (
    walletPrivateKey = "YOUR_WALLET_PRIVATE_KEY"
    devnetRPC        = "https://api.devnet.solana.com"
)

func main() {
    ctx := context.Background()

    // This code assumes a solana stakingOperation has already been created.

    privateKey, err := decodePrivateKey(walletPrivateKey)

    err = stakingOperation.Sign(privateKey)
    if err != nil {
        log.Fatalf("error signing transaction: %v", err)
    }

    rpcClient := rpc.New(rpcURL)

    maxRetries := uint(5)
    opts := rpc.TransactionOpts{
        SkipPreflight: false,
        MaxRetries:    &maxRetries,
        // NOTE: In production, consider using rpc.CommitmentFinalized instead to ensure the block is included.
        PreflightCommitment: rpc.CommitmentProcessed,
    }

    for _, transaction := range stakingOperation.Transactions() {
        unsignedTx := transaction.UnsignedPayload()
        signedTx := transaction.SignedPayload()

        log.Printf("Unsigned tx payload: %s\n\n", unsignedTx)
        log.Printf("Signed tx payload: %s\n\n", signedTx)

        rawTx := transaction.Raw()
        solanaTx, ok := rawTx.(*solana.Transaction)
        if !ok {
            log.Fatal("failed to cast raw transaction to solana.Transaction")
        }

        sig, err := rpcClient.SendTransactionWithOpts(ctx, solanaTx, opts)
        if err != nil {
            log.Fatalf("failed to send transaction: %v", err)
        }

        log.Printf("Broadcasted tx: %s\n\n", getTxLink(stakingOperation.NetworkID(), sig.String()))
    }
}

func decodePrivateKey(privateKeyString string) (*ed25519.PrivateKey, error) {
    // Decode the base58 encoded private key
    privateKeyBytes := base58.Decode(privateKeyString)
    if len(privateKeyBytes) != ed25519.PrivateKeySize {
        log.Fatalf("invalid private key length: expected %d bytes, got %d bytes", ed25519.PrivateKeySize, len(privateKeyBytes))
    }

    // Convert the byte slice to an ed25519 private key
    privateKey := ed25519.PrivateKey(privateKeyBytes)

    return &privateKey, nil
}

func getTxLink(networkID, signature string) string {
    if networkID == coinbase.SolanaMainnet {
        return fmt.Sprintf("https://explorer.solana.com/tx/%s", signature)
    } else if networkID == coinbase.SolanaDevnet {
        return fmt.Sprintf("https://explorer.solana.com/tx/%s?cluster=devnet", signature)
    }

    return ""
}