Preplay examples - Sodae

Each example subscribes with SubscribeDeshred, answers keepalive pings, reconnects with backoff, and exits with the server’s error code when a stream is refused for a reason retrying will not fix.

Without an argument, it receives every transaction and prints one line per slot with the transaction count.
With a program id, it asks the server for only the transactions that use that program and prints each one with its signer, version, lookup-table count, number of addresses loaded from lookup tables, and each instruction’s program, account count and data size.

All three read SODAE_TOKEN and, optionally, SODAE_PREPLAY_URL.

Run

git clone https://github.com/sodae-io/sodae-docs
cd sodae-docs

Plaintext
TLS

cd examples/rust
export SODAE_TOKEN=your-api-key
cargo run --example preplay
cargo run --example preplay -- pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

cd examples/typescript
npm install
export SODAE_TOKEN=your-api-key
npm run preplay
npm run preplay -- pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

cd examples/go
export SODAE_TOKEN=your-api-key
go run ./preplay
go run ./preplay pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

cd examples/rust
export SODAE_TOKEN=your-api-key
export SODAE_PREPLAY_URL=https://ams.tls.sodae.io:10311
cargo run --example preplay
cargo run --example preplay -- pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

cd examples/typescript
npm install
export SODAE_TOKEN=your-api-key
export SODAE_PREPLAY_URL=https://ams.tls.sodae.io:10311
npm run preplay
npm run preplay -- pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

cd examples/go
export SODAE_TOKEN=your-api-key
export SODAE_PREPLAY_URL=https://ams.tls.sodae.io:10311
go run ./preplay
go run ./preplay pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA

Output

451924839 transactions=446
451924840 transactions=486

451924853 5AtEQrbW2RjHKnND6wvEvhSZLPg1cTu625gEA4y63UzaoY4sZxS5FiRHesdddnAK3yQcY4255oUseqwUiwxkqX2A signer=3KXgVpyEgcMq5TRX1d4rh6YngeQUNwLnqXereQ6xszSY version=0 lookups=0 loaded=0
  ComputeBudget111111111111111111111111111111 accounts=0 data=5B
  ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL accounts=6 data=1B
  11111111111111111111111111111111 accounts=2 data=12B
  TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA accounts=1 data=1B
  pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA accounts=23 data=24B
  TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA accounts=3 data=1B

Core of each client

let mut client = GeyserGrpcClient::build_from_shared(endpoint)?
    .x_token(Some(token))?
    .max_decoding_message_size(64 * 1024 * 1024)
    .connect()
    .await?;

let request = SubscribeDeshredRequest {
    deshred_transactions: HashMap::from([(
        "preplay".to_string(),
        SubscribeRequestFilterDeshredTransactions {
            vote: Some(false),
            account_include: vec![program.to_string()],
            ..Default::default()
        },
    )]),
    ..Default::default()
};
let (mut sink, mut updates) = client.subscribe_deshred_with_request(Some(request)).await?;

while let Some(update) = updates.next().await {
    match update?.update_oneof {
        Some(UpdateOneof::Ping(_)) => {
            sink.send(SubscribeDeshredRequest {
                ping: Some(SubscribeRequestPing { id: 1 }),
                ..Default::default()
            })
            .await?;
        }
        Some(UpdateOneof::DeshredTransaction(update)) => {
            let tx = update.transaction.unwrap();
            println!("{} {}", update.slot, bs58::encode(&tx.signature).into_string());
        }
        _ => {}
    }
}

import Client from "@triton-one/yellowstone-grpc";
import bs58 from "bs58";

const client = new Client("http://ams.rpc.sodae.io:10301", token, {
  grpcMaxDecodingMessageSize: 64 * 1024 * 1024,
});
await client.connect();
const stream = await client.subscribeDeshred();
stream.write({
  deshredTransactions: {
    preplay: { vote: false, accountInclude: [program], accountExclude: [], accountRequired: [] },
  },
  slots: {},
});

stream.on("data", (update) => {
  if (update.ping) {
    stream.write({ deshredTransactions: {}, slots: {}, ping: { id: 1 } });
  } else if (update.deshredTransaction?.transaction) {
    const { slot, transaction } = update.deshredTransaction;
    console.log(slot, bs58.encode(transaction.signature));
  }
});

conn, err := grpc.NewClient("ams.rpc.sodae.io:10301",
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(64<<20)))
ctx := metadata.AppendToOutgoingContext(context.Background(), "x-token", token)
stream, err := pb.NewGeyserClient(conn).SubscribeDeshred(ctx)

vote := false
err = stream.Send(&pb.SubscribeDeshredRequest{
    DeshredTransactions: map[string]*pb.SubscribeRequestFilterDeshredTransactions{
        "preplay": {Vote: &vote, AccountInclude: []string{program}},
    },
})

for {
    update, err := stream.Recv()
    if err != nil {
        return err
    }
    switch u := update.UpdateOneof.(type) {
    case *pb.SubscribeUpdateDeshred_Ping:
        stream.Send(&pb.SubscribeDeshredRequest{Ping: &pb.SubscribeRequestPing{Id: 1}})
    case *pb.SubscribeUpdateDeshred_DeshredTransaction:
        tx := u.DeshredTransaction.GetTransaction()
        fmt.Println(u.DeshredTransaction.Slot, base58.Encode(tx.GetSignature()))
    }
}

Over TLS

Only the connection changes. The examples switch to TLS when the URL starts with https://.

let mut client = GeyserGrpcClient::build_from_shared("https://ams.tls.sodae.io:10311")?
    .x_token(Some(token))?
    .tls_config(ClientTlsConfig::new().with_native_roots())?
    .max_decoding_message_size(64 * 1024 * 1024)
    .connect()
    .await?;

const client = new Client("https://ams.tls.sodae.io:10311", token, {
  grpcMaxDecodingMessageSize: 64 * 1024 * 1024,
});
await client.connect();

conn, err := grpc.NewClient("ams.tls.sodae.io:10311",
    grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
    grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(64<<20)))

In your own Rust project, enable tonic’s tls-ring feature next to tls-native-roots. The complete programs: