signet

1.6.0

1.6.1 1.6.0 1.5.0 1.4.2 1.4.1 1.4.0 1.3.12 1.3.11 1.3.10 1.3.9 1.3.8 1.3.7 1.3.6 1.3.5 1.3.4 1.3.3 1.3.2 1.3.1 1.3.0 1.2.9 1.2.8 1.2.7 1.2.6 1.2.5 1.2.4 1.2.3 1.2.2 1.2.1 1.2.0 1.1.2 1.1.1 1.1.0 1.0.0-echo8 1.0.0-echo7 1.0.0-echo6 1.0.0-echo5 1.0.0-echo4 1.0.0-echo3 1.0.0-echo2 1.0.0-echo1 1.0.0-delta8 1.0.0-delta7 1.0.0-delta6 1.0.0-delta5 1.0.0-delta4 1.0.0-delta3 1.0.0-delta2 1.0.0-delta1 1.0.0-charlie9 1.0.0-charlie8 1.0.0-charlie7 1.0.0-charlie6 1.0.0-charlie5 1.0.0-charlie4 1.0.0-charlie3 1.0.0-charlie2 1.0.0-charlie1 1.0.0-beta9 1.0.0-beta8 1.0.0-beta7 1.0.0-beta6 1.0.0-beta5 1.0.0-beta4 1.0.0-beta3 1.0.0-beta2 1.0.0-beta1 1.0.0-alpha9 1.0.0-alpha8 1.0.0-alpha7 1.0.0-alpha6 1.0.0-alpha5 1.0.0-alpha4 1.0.0-alpha3 1.0.0-alpha2 1.0.0-alpha10 1.0.0-alpha1 0.2.0-alpha6 0.2.0-alpha5 0.2.0-alpha4 0.2.0-alpha1 0.1.10 0.1.9 0.1.8 0.1.7 0.1.6 0.1.5 0.1.4 0.1.3 0.1.2 0.1.1 0.1.0 0.1.0-rc7 0.1.0-rc6 0.1.0-rc5 0.1.0-rc4 0.1.0-rc3 0.1.0-rc2 0.1.0-rc1 0.1.0-rc0

Lightweight Ethereum and Solana RPC client for Elixir

HexDocs

Current section

Files

Jump to

Readme 99 Versions 8 Dependencies 2 Dependants Files Activity

signet test support solana_client.ex

Raw

test/support/solana_client.ex

defmodule Signet.Solana.Test.Client do
  @moduledoc """
  Mock Solana JSON-RPC client for testing.

  Uses address-based dispatch to return different responses:
  - Standard addresses return normal responses
  - Specific "magic" addresses trigger error cases or edge cases
  """

  # Known test addresses (Base58-encoded)
  # All-zeros seed → "4zvwRjXUKGfvwnParsHAS3HuSVzV5cA4McphgmoCtajS"
  @nonexistent_account "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
  @error_account "11111111111111111111111111111112"

  def request(%Finch.Request{body: body}, _finch_name, _opts) do
    %{"jsonrpc" => "2.0", "method" => method, "params" => params, "id" => id} =
      Jason.decode!(body)

    result = dispatch(method, params)

    return_body =
      case result do
        {:rpc_error, error} ->
          Jason.encode!(%{"jsonrpc" => "2.0", "error" => error, "id" => id})

        _ ->
          Jason.encode!(%{"jsonrpc" => "2.0", "result" => result, "id" => id})
      end

    {:ok, %Finch.Response{status: 200, body: return_body}}
  end

  # ---------------------------------------------------------------------------
  # getBalance
  # ---------------------------------------------------------------------------

  defp dispatch("getBalance", [@error_account | _]) do
    {:rpc_error, %{"code" => -32600, "message" => "Invalid request"}}
  end

  defp dispatch("getBalance", [_pubkey | _]) do
    %{"context" => %{"slot" => 256_000}, "value" => 1_500_000_000}
  end

  # ---------------------------------------------------------------------------
  # getAccountInfo
  # ---------------------------------------------------------------------------

  defp dispatch("getAccountInfo", [@nonexistent_account, _config]) do
    %{"context" => %{"slot" => 256_000}, "value" => nil}
  end

  defp dispatch("getAccountInfo", [_pubkey, %{"encoding" => "base64"}]) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => %{
        "data" => ["AQAAAAA=", "base64"],
        "executable" => false,
        "lamports" => 1_461_600,
        "owner" => "11111111111111111111111111111111",
        "rentEpoch" => 18_446_744_073_709_551_615,
        "space" => 5
      }
    }
  end

  defp dispatch("getAccountInfo", [_pubkey, _config]) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => %{
        "data" => ["AQAAAAA=", "base64"],
        "executable" => false,
        "lamports" => 1_461_600,
        "owner" => "11111111111111111111111111111111",
        "rentEpoch" => 18_446_744_073_709_551_615,
        "space" => 5
      }
    }
  end

  # ---------------------------------------------------------------------------
  # getMultipleAccounts
  # ---------------------------------------------------------------------------

  defp dispatch("getMultipleAccounts", [pubkeys, _config]) do
    values =
      Enum.map(pubkeys, fn
        @nonexistent_account ->
          nil

        _ ->
          %{
            "data" => ["", "base64"],
            "executable" => false,
            "lamports" => 500_000,
            "owner" => "11111111111111111111111111111111",
            "rentEpoch" => 0,
            "space" => 0
          }
      end)

    %{"context" => %{"slot" => 256_000}, "value" => values}
  end

  # ---------------------------------------------------------------------------
  # getLatestBlockhash
  # ---------------------------------------------------------------------------

  defp dispatch("getLatestBlockhash", _) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => %{
        "blockhash" => "4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZAMdL4VZHirAn",
        "lastValidBlockHeight" => 256_200
      }
    }
  end

  # ---------------------------------------------------------------------------
  # getSlot / getBlockHeight
  # ---------------------------------------------------------------------------

  defp dispatch("getSlot", _), do: 256_000
  defp dispatch("getBlockHeight", _), do: 255_980

  # ---------------------------------------------------------------------------
  # getTransaction
  # ---------------------------------------------------------------------------

  defp dispatch("getTransaction", ["not_found_sig" | _]) do
    nil
  end

  defp dispatch("getTransaction", [_sig | _]) do
    %{
      "blockTime" => 1_708_300_522,
      "slot" => 255_900,
      "version" => "legacy",
      "meta" => %{
        "err" => nil,
        "fee" => 5000,
        "preBalances" => [10_000_000_000, 0, 1],
        "postBalances" => [8_999_995_000, 1_000_000_000, 1],
        "logMessages" => [
          "Program 11111111111111111111111111111111 invoke [1]",
          "Program 11111111111111111111111111111111 success"
        ],
        "innerInstructions" => [],
        "rewards" => nil,
        "loadedAddresses" => %{"readonly" => [], "writable" => []},
        "computeUnitsConsumed" => 150
      },
      "transaction" => %{
        "signatures" => [
          "4Lz3raap9pEVGjT4EuVmNxTzMEj3EhVFKBonVFcnjiMwFKwEqh9TuPRYSv3TpK6ia4W33kMtJMdRJiL"
        ],
        "message" => %{
          "accountKeys" => [
            "4zvwRjXUKGfvwnParsHAS3HuSVzV5cA4McphgmoCtajS",
            "FVen3X669xLzsi6N2V91DoiyzHzg1uAgqiT8jZ9nS96Z",
            "11111111111111111111111111111111"
          ],
          "header" => %{
            "numRequiredSignatures" => 1,
            "numReadonlySignedAccounts" => 0,
            "numReadonlyUnsignedAccounts" => 1
          },
          "instructions" => [
            %{
              "programIdIndex" => 2,
              "accounts" => [0, 1],
              "data" => "3Bxs4h24hBtQy9rw"
            }
          ],
          "recentBlockhash" => "4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZAMdL4VZHirAn"
        }
      }
    }
  end

  # ---------------------------------------------------------------------------
  # getSignatureStatuses
  # ---------------------------------------------------------------------------

  defp dispatch("getSignatureStatuses", [sigs | _]) do
    values =
      Enum.map(sigs, fn
        "confirmed_sig" ->
          %{
            "slot" => 255_900,
            "confirmations" => 10,
            "err" => nil,
            "confirmationStatus" => "confirmed"
          }

        "failed_sig" ->
          %{
            "slot" => 255_900,
            "confirmations" => nil,
            "err" => %{"InstructionError" => [0, "InsufficientFunds"]},
            "confirmationStatus" => "finalized"
          }

        "unknown_sig" ->
          nil

        _ ->
          %{
            "slot" => 255_900,
            "confirmations" => nil,
            "err" => nil,
            "confirmationStatus" => "finalized"
          }
      end)

    %{"context" => %{"slot" => 256_000}, "value" => values}
  end

  # ---------------------------------------------------------------------------
  # getMinimumBalanceForRentExemption
  # ---------------------------------------------------------------------------

  defp dispatch("getMinimumBalanceForRentExemption", [165 | _]), do: 2_039_280
  defp dispatch("getMinimumBalanceForRentExemption", [0 | _]), do: 890_880
  defp dispatch("getMinimumBalanceForRentExemption", _), do: 890_880

  # ---------------------------------------------------------------------------
  # getTokenAccountBalance
  # ---------------------------------------------------------------------------

  defp dispatch("getTokenAccountBalance", [_pubkey | _]) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => %{
        "amount" => "1000000000",
        "decimals" => 9,
        "uiAmount" => 1.0,
        "uiAmountString" => "1"
      }
    }
  end

  # ---------------------------------------------------------------------------
  # getTokenAccountsByOwner
  # ---------------------------------------------------------------------------

  # Filter by mint - returns matching token accounts
  defp dispatch("getTokenAccountsByOwner", [_owner, %{"mint" => _mint}, _config]) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => [
        %{
          "pubkey" => "AyVfCw5fBuVTkzG4bBPiDfCkuS1YGrh2i6pRgLHMwmZr",
          "account" => %{
            "data" => %{
              "parsed" => %{
                "info" => %{
                  "isNative" => false,
                  "mint" => "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                  "owner" => "4zvwRjXUKGfvwnParsHAS3HuSVzV5cA4McphgmoCtajS",
                  "state" => "initialized",
                  "tokenAmount" => %{
                    "amount" => "1500000000",
                    "decimals" => 6,
                    "uiAmount" => 1500.0,
                    "uiAmountString" => "1500"
                  }
                },
                "type" => "account"
              },
              "program" => "spl-token",
              "space" => 165
            },
            "executable" => false,
            "lamports" => 2_039_280,
            "owner" => "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
            "rentEpoch" => 18_446_744_073_709_551_615,
            "space" => 165
          }
        }
      ]
    }
  end

  # Filter by programId - returns all token accounts
  defp dispatch("getTokenAccountsByOwner", [_owner, %{"programId" => program_id}, _config]) do
    accounts =
      case program_id do
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" ->
          [
            token_account_fixture(
              "AyVfCw5fBuVTkzG4bBPiDfCkuS1YGrh2i6pRgLHMwmZr",
              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
              "1500000000",
              6
            ),
            token_account_fixture(
              "BzVfCw5fBuVTkzG4bBPiDfCkuS1YGrh2i6pRgLHMwmZs",
              "So11111111111111111111111111111111111111112",
              "5000000000",
              9
            )
          ]

        "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" ->
          [
            token_account_fixture(
              "CzVfCw5fBuVTkzG4bBPiDfCkuS1YGrh2i6pRgLHMwmZt",
              "2DEy3MN8J2zKWVoYTPKg4wifoDBavX6XpSgbRsfuLAMn",
              "999000000000",
              9
            )
          ]

        _ ->
          []
      end

    %{"context" => %{"slot" => 256_000}, "value" => accounts}
  end

  # ---------------------------------------------------------------------------
  # getRecentPrioritizationFees
  # ---------------------------------------------------------------------------

  defp dispatch("getRecentPrioritizationFees", _) do
    [
      %{"slot" => 255_998, "prioritizationFee" => 0},
      %{"slot" => 255_999, "prioritizationFee" => 1000},
      %{"slot" => 256_000, "prioritizationFee" => 500}
    ]
  end

  # ---------------------------------------------------------------------------
  # getHealth / getVersion
  # ---------------------------------------------------------------------------

  defp dispatch("getHealth", _), do: "ok"

  defp dispatch("getVersion", _) do
    %{"solana-core" => "1.18.26", "feature-set" => 2_891_131_721}
  end

  # ---------------------------------------------------------------------------
  # sendTransaction
  # ---------------------------------------------------------------------------

  defp dispatch("sendTransaction", [_encoded, _config]) do
    "4Lz3raap9pEVGjT4EuVmNxTzMEj3EhVFKBonVFcnjiMwFKwEqh9TuPRYSv3TpK6ia4W33kMtJMdRJiL"
  end

  # ---------------------------------------------------------------------------
  # simulateTransaction
  # ---------------------------------------------------------------------------

  defp dispatch("simulateTransaction", [_encoded, _config]) do
    %{
      "context" => %{"slot" => 256_000},
      "value" => %{
        "err" => nil,
        "logs" => [
          "Program 11111111111111111111111111111111 invoke [1]",
          "Program 11111111111111111111111111111111 success"
        ],
        "unitsConsumed" => 150
      }
    }
  end

  # ---------------------------------------------------------------------------
  # requestAirdrop
  # ---------------------------------------------------------------------------

  defp dispatch("requestAirdrop", [_pubkey, _lamports | _]) do
    "2ZE3FQsWzjbkyNKP5qEDGjJEsaWmVFBCKSBMxpZUTgBs1PWDM1jN6hUEyFz1"
  end

  # ---------------------------------------------------------------------------
  # Fallback
  # ---------------------------------------------------------------------------

  defp dispatch(method, _params) do
    {:rpc_error, %{"code" => -32601, "message" => "Method not found: #{method}"}}
  end

  # ---------------------------------------------------------------------------
  # Helpers
  # ---------------------------------------------------------------------------

  defp token_account_fixture(pubkey, mint, amount, decimals) do
    %{
      "pubkey" => pubkey,
      "account" => %{
        "data" => %{
          "parsed" => %{
            "info" => %{
              "isNative" => false,
              "mint" => mint,
              "owner" => "4zvwRjXUKGfvwnParsHAS3HuSVzV5cA4McphgmoCtajS",
              "state" => "initialized",
              "tokenAmount" => %{
                "amount" => amount,
                "decimals" => decimals,
                "uiAmount" => String.to_integer(amount) / :math.pow(10, decimals),
                "uiAmountString" => "#{String.to_integer(amount) / :math.pow(10, decimals)}"
              }
            },
            "type" => "account"
          },
          "program" => "spl-token",
          "space" => 165
        },
        "executable" => false,
        "lamports" => 2_039_280,
        "owner" => "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
        "rentEpoch" => 18_446_744_073_709_551_615,
        "space" => 165
      }
    }
  end
end

Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT