Crate superstream

Superstream is a protocol and a collection of libraries for real-time money streaming on Solana. It allows anyone to continuously stream money to anyone else transparently and efficiently.

Superstream protocol is completely open-source. View it on GitHub.

Learn more about Superstream on superstream.finance.

Usage in CPI (Cross-Program Invocation)

NOTE: For a complete example, see superstream-cpi-example

• Add the dependency in your program’s Cargo.toml

superstream = { version = "0.3.1", features = ["cpi"] }

• Invoke Superstream’s instruction. In the example below, we are calling Superstream’s cancel instruction.

#[program]
pub mod superstream_cpi_example {
    /// Cancel a stream.
    pub fn cancel(ctx: Context<Cancel>, seed: u64, name: String, recipient: Pubkey) -> Result<()> {
        let cpi_program = ctx.accounts.superstream_program.to_account_info();
        let cpi_accounts = superstream::cpi::accounts::Cancel {
            stream: ctx.accounts.stream.to_account_info(),
            signer: ctx.accounts.signer.to_account_info(),
            sender: ctx.accounts.sender.to_account_info(),
            mint: ctx.accounts.sender.to_account_info(),
            signer_token: ctx.accounts.signer_token.to_account_info(),
            sender_token: ctx.accounts.sender_token.to_account_info(),
            recipient_token: ctx.accounts.recipient_token.to_account_info(),
            escrow_token: ctx.accounts.escrow_token.to_account_info(),
            token_program: ctx.accounts.token_program.to_account_info(),
        };
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);

        superstream::cpi::cancel(cpi_ctx, seed, name, recipient)
    }

    // ... other stuff
}

/// Accounts struct for cancelling a stream.
#[derive(Accounts)]
pub struct Cancel<'info> {
    /// Stream PDA account.
    #[account(mut)]
    pub stream: AccountInfo<'info>,

    /// Signer wallet.
    pub signer: Signer<'info>,

    /// Stream sender account.
    pub sender: AccountInfo<'info>,
    /// SPL token mint account.
    pub mint: Box<Account<'info, Mint>>,

    /// Associated token account of the signer.
    #[account(mut)]
    pub signer_token: Box<Account<'info, TokenAccount>>,
    /// Associated token account of the sender.
    #[account(mut)]
    pub sender_token: Box<Account<'info, TokenAccount>>,
    /// Associated token account of the recipient.
    #[account(mut)]
    pub recipient_token: Box<Account<'info, TokenAccount>>,
    /// Associated token escrow account holding the funds for this stream.
    #[account(mut)]
    pub escrow_token: Box<Account<'info, TokenAccount>>,

    /// SPL token program.
    pub token_program: Program<'info, Token>,

    /// Superstream program.
    pub superstream_program: Program<'info, superstream::program::Superstream>,
}

// ... other stuff

Modules

accounts

An Anchor generated module, providing a set of structs mirroring the structs deriving Accounts, where each field is a Pubkey. This is useful for specifying accounts for a client.

error

Module for superstream error handling.

instruction

An Anchor generated module containing the program’s set of instructions, where each method handler in the #[program] mod is associated with a struct defining the input arguments to the method. These should be used directly, when one wants to serialize Anchor instruction data, for example, when speciying instructions on a client.

program

Module representing the program.

state

Module for superstream state management.

superstream

Module for superstream cpi methods and other utilities.

Structs

Cancel

Accounts struct for cancelling a stream.

ChangeSenderNonPrepaid

Accounts struct for changing the sender of a non-prepaid stream.

Create

Accounts struct for creating a new stream.

PauseNonPrepaid

Accounts struct for pausing a non-prepaid stream.

ResumeNonPrepaid

Accounts struct for resuming a non-prepaid stream.

TopupNonPrepaid

Accounts struct for topping up a non-prepaid stream.

WithdrawAndChangeRecipient

Accounts struct for withdrawing recipient funds from a stream and changing recipient of a stream.

WithdrawExcessTopupNonPrepaidEnded

Accounts struct for withdrawing excess sender topup from a non-prepaid stream.

Constants

STREAM_ACCOUNT_SEED

PDA account seed to create new stream PDA accounts.

Statics

ID

The static program ID

Functions

check_id

Confirms that a given pubkey is equivalent to the program ID

entry

The Anchor codegen exposes a programming model where a user defines a set of methods inside of a #[program] module in a way similar to writing RPC request handlers. The macro then generates a bunch of code wrapping these user defined methods into something that can be executed on Solana.

entrypoint^⚠

Safety

id

Returns the program ID