Struct CreateTriggerOrder 

pub struct CreateTriggerOrder {
    pub input_mint: String,
    pub output_mint: String,
    pub maker: String,
    pub payer: String,
    pub params: Params,
    pub compute_unit_price: Option<String>,
    pub fee_account: Option<String>,
    pub wrap_and_unwrap_sol: Option<bool>,
}

Request for a base64-encoded unsigned trigger order creation transaction

Official API docs

Fields

input_mint: String

The mint address of the input token.

Example: "So11111111111111111111111111111111111111112" (SOL)

output_mint: String

The mint address of the output token.

Example: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"

maker: String

Maker address

payer: String

fee payer address

params: Params

making and taking amount inputs

compute_unit_price: Option<String>

In microlamports, defaults to 95th percentile of priority fees Default value: auto

fee_account: Option<String>

A token account (via the Referral Program) that will receive the fees

wrap_and_unwrap_sol: Option<bool>

If either input or output mint is native SOL Default value: true

Implementations

impl CreateTriggerOrder

pub fn new( input_mint: &str, output_mint: &str, maker: &str, payer: &str, making_amount: u64, taking_amount: u64, ) -> Self

Creates a new trigger order with required parameters

pub fn compute_unit_price(self, price: &str) -> Self

Sets the compute unit price in microlamports Default value: auto

pub fn fee_account(self, account: &str) -> Self

Sets the fee account for referral program

pub fn wrap_and_unwrap_sol(self, wrap: bool) -> Self

Sets whether to wrap and unwrap SOL

pub fn expired_at(self, expired_at: &str) -> Self

Sets the expiration time for the order

pub fn slippage_bps(self, slippage: &str) -> Self

Sets the slippage in basis points Default value: 0

pub fn fee_bps(self, fee: &str) -> Self

Sets the fee in basis points (requires fee_account to be set)

Trait Implementations

impl Debug for CreateTriggerOrder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateTriggerOrder

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CreateTriggerOrder

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.