@gmsol-labs/gmsol-sdk 0.5.0-alpha.10

package/index.d.ts

@@ -0,0 +1,825 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Build transactions for creating orders.
+ */
+export function create_orders(kind: CreateOrderKind, orders: CreateOrderParams[], options: CreateOrderOptions): TransactionGroup;
+/**
+ * Apply `factor` to the `value`.
+ */
+export function apply_factor(value: bigint, factor: bigint): bigint | undefined;
+/**
+ * Initialize Javascript logging and panic handler
+ */
+export function solana_program_init(): void;
+/**
+ * Params for calculating market token price.
+ */
+export interface MarketTokenPriceParams {
+    /**
+     * Prices.
+     */
+    prices: Prices;
+    /**
+     * Pnl Factor.
+     */
+    pnl_factor?: PnlFactorKind;
+    /**
+     * Maximize.
+     */
+    maximize: boolean;
+}
+
+/**
+ * Params for calculating market status.
+ */
+export interface MarketStatusParams {
+    /**
+     * Prices.
+     */
+    prices: Prices;
+}
+
+/**
+ * Best Swap path.
+ */
+export interface BestSwapPath {
+    /**
+     * Params.
+     */
+    params: SwapEstimationParams;
+    /**
+     * Exchange rate.
+     */
+    exchange_rate: bigint | undefined;
+    /**
+     * Path.
+     */
+    path: string[];
+    /**
+     * Arbitrage exists.
+     */
+    arbitrage_exists: boolean | undefined;
+}
+
+/**
+ * Options for creating orders.
+ */
+export interface CreateOrderOptions {
+    recent_blockhash: string;
+    payer: StringPubkey;
+    collateral_or_swap_out_token: StringPubkey;
+    hints: Map<StringPubkey, CreateOrderHint>;
+    program?: StoreProgram | undefined;
+    pay_token?: StringPubkey | undefined;
+    receive_token?: StringPubkey | undefined;
+    swap_path?: StringPubkey[] | undefined;
+    skip_wrap_native_on_pay?: boolean | undefined;
+    skip_unwrap_native_on_receive?: boolean | undefined;
+    transaction_group?: TransactionGroupOptions;
+}
+
+/**
+ * A JS version transaction group options.
+ */
+export interface TransactionGroupOptions {
+    max_transaction_size?: number | undefined;
+    max_instructions_per_tx?: number | undefined;
+    compute_unit_price_micro_lamports?: number | undefined;
+    luts?: Map<StringPubkey, StringPubkey[]>;
+}
+
+/**
+ * Serialized transaction group.
+ */
+export type SerializedTransactionGroup = number[][][];
+
+
+/**
+ * A Base58-encoded string representing a public key.
+ */
+export type StringPubkey = string;
+
+
+/**
+ * Config for [`MarketGraph`].
+ */
+export interface MarketGraphConfig {
+    /**
+     * Estimation Params for swap.
+     */
+    swap_estimation_params: SwapEstimationParams;
+    /**
+     * Max steps.
+     */
+    max_steps: number;
+}
+
+/**
+ * Estimation Parameters for Swap.
+ */
+export interface SwapEstimationParams {
+    /**
+     * Value.
+     */
+    value: bigint;
+    /**
+     * Base cost.
+     */
+    base_cost: bigint;
+}
+
+/**
+ * Js Prices.
+ */
+export interface Prices {
+    /**
+     * Index token price.
+     */
+    index_token: Value;
+    /**
+     * Long token price.
+     */
+    long_token: Value;
+    /**
+     * Short token price.
+     */
+    short_token: Value;
+}
+
+/**
+ * Position Status.
+ */
+export interface PositionStatus {
+    /**
+     * Entry price.
+     */
+    entry_price: bigint;
+    /**
+     * Collateral value.
+     */
+    collateral_value: bigint;
+    /**
+     * Pending PnL.
+     */
+    pending_pnl: bigint;
+    /**
+     * Pending borrowing fee value.
+     */
+    pending_borrowing_fee_value: bigint;
+    /**
+     * Pending funding fee value.
+     */
+    pending_funding_fee_value: bigint;
+    /**
+     * Pending claimable funding fee value in long token.
+     */
+    pending_claimable_funding_fee_value_in_long_token: bigint;
+    /**
+     * Pending claimable funding fee value in short token.
+     */
+    pending_claimable_funding_fee_value_in_short_token: bigint;
+    /**
+     * Close order fee value.
+     */
+    close_order_fee_value: bigint;
+    /**
+     * Net value.
+     */
+    net_value: bigint;
+    /**
+     * Leverage.
+     */
+    leverage: bigint;
+    /**
+     * Liquidation price.
+     */
+    liquidation_price: bigint;
+}
+
+/**
+ * Market Status.
+ */
+export interface MarketStatus {
+    /**
+     * Funding fee rate per hour for long.
+     */
+    funding_rate_per_second_for_long: bigint;
+    /**
+     * Funding fee rate per hour for short.
+     */
+    funding_rate_per_second_for_short: bigint;
+    /**
+     * Borrowing fee rate per second for long.
+     */
+    borrowing_rate_per_second_for_long: bigint;
+    /**
+     * Borrowing fee rate per second for short.
+     */
+    borrowing_rate_per_second_for_short: bigint;
+    /**
+     * Pending pnl for long.
+     */
+    pending_pnl_for_long: SignedValue;
+    /**
+     * Pending pnl for short.
+     */
+    pending_pnl_for_short: SignedValue;
+    /**
+     * Reserved value for long.
+     */
+    reserved_value_for_long: bigint;
+    /**
+     * Reserved value for short.
+     */
+    reserved_value_for_short: bigint;
+    /**
+     * Pool value without pnl for long.
+     */
+    pool_value_without_pnl_for_long: Value;
+    /**
+     * Pool avlue without pnl for short.
+     */
+    pool_value_without_pnl_for_short: Value;
+    /**
+     * Liquidity for long.
+     */
+    liquidity_for_long: bigint;
+    /**
+     * Liquidity for short.
+     */
+    liquidity_for_short: bigint;
+    /**
+     * Open interest for long.
+     */
+    open_interest_for_long: bigint;
+    /**
+     * Open interest for short.
+     */
+    open_interest_for_short: bigint;
+    /**
+     * Open interest in tokens for long.
+     */
+    open_interest_in_tokens_for_long: bigint;
+    /**
+     * Open interest in tokens for short.
+     */
+    open_interest_in_tokens_for_short: bigint;
+}
+
+/**
+ * Min max signed values.
+ */
+export interface SignedValue {
+    /**
+     * Min value.
+     */
+    min: bigint;
+    /**
+     * Max value.
+     */
+    max: bigint;
+}
+
+/**
+ * Min max values.
+ */
+export interface Value {
+    /**
+     * Min value.
+     */
+    min: bigint;
+    /**
+     * Max value.
+     */
+    max: bigint;
+}
+
+/**
+ * A store program.
+ */
+export interface StoreProgram {
+    /**
+     * Program ID.
+     */
+    id: StringPubkey;
+    /**
+     * Store address.
+     */
+    store: StringPubkey;
+}
+
+/**
+ * Hint for [`CreateOrder`].
+ */
+export interface CreateOrderHint {
+    /**
+     * Long token.
+     */
+    long_token: StringPubkey;
+    /**
+     * Short token.
+     */
+    short_token: StringPubkey;
+}
+
+/**
+ * Instruction builder for the `create_order` instruction.
+ */
+export interface CreateOrder {
+    /**
+     * Program.
+     */
+    program?: StoreProgram;
+    /**
+     * Payer (a.k.a. owner).
+     */
+    payer: StringPubkey;
+    /**
+     * Reciever.
+     */
+    receiver?: StringPubkey | undefined;
+    /**
+     * Nonce for the order.
+     */
+    nonce?: NonceBytes | undefined;
+    /**
+     * Execution fee paid to the keeper in lamports.
+     */
+    execution_lamports?: number;
+    /**
+     * Order Kind.
+     */
+    kind: CreateOrderKind;
+    /**
+     * Collateral or swap out token.
+     */
+    collateral_or_swap_out_token: StringPubkey;
+    /**
+     * Order Parameters.
+     */
+    params: CreateOrderParams;
+    /**
+     * Pay token.
+     */
+    pay_token?: StringPubkey | undefined;
+    /**
+     * Pay token account.
+     */
+    pay_token_account?: StringPubkey | undefined;
+    /**
+     * Receive token.
+     */
+    receive_token?: StringPubkey | undefined;
+    /**
+     * Swap path.
+     */
+    swap_path?: StringPubkey[];
+    /**
+     * Whether to unwrap the native token when receiving (e.g., convert WSOL to SOL).
+     */
+    unwrap_native_on_receive?: boolean;
+}
+
+/**
+ * Parameters for creating an order.
+ */
+export interface CreateOrderParams {
+    /**
+     * The market token of the market in which the order will be created.
+     */
+    market_token: StringPubkey;
+    /**
+     * Whether the order is for a long or short position.
+     */
+    is_long: boolean;
+    /**
+     * Delta size in USD.
+     */
+    size: bigint;
+    /**
+     * Delta amount of tokens:
+     * - For increase / swap orders, it is the amount of pay tokens.
+     * - For decrease orders, it is the amount of collateral tokens to withdraw.
+     */
+    amount?: bigint;
+    /**
+     * Minimum amount or value of output tokens.
+     *
+     * - Minimum collateral amount for increase-position orders after swap.
+     * - Minimum swap-out amount for swap orders.
+     * - Minimum output value for decrease-position orders.
+     */
+    min_output?: bigint;
+    /**
+     * Trigger price (in unit price).
+     */
+    trigger_price?: bigint | undefined;
+    /**
+     * Acceptable price (in unit price).
+     */
+    acceptable_price?: bigint | undefined;
+    /**
+     * Decrease Position Swap Type.
+     */
+    decrease_position_swap_type?: DecreasePositionSwapType | undefined;
+    /**
+     * Timestamp from which the order becomes valid.
+     */
+    valid_from_ts?: number | undefined;
+}
+
+/**
+ * Swap type for decreasing position.
+ */
+export type DecreasePositionSwapType = "NoSwap" | "PnlTokenToCollateralToken" | "CollateralToPnlToken";
+
+/**
+ * Create Order Kind.
+ */
+export type CreateOrderKind = "MarketSwap" | "MarketIncrease" | "MarketDecrease" | "LimitSwap" | "LimitIncrease" | "LimitDecrease" | "StopLossDecrease";
+
+/**
+ * Pnl Factor Kind.
+ */
+export type PnlFactorKind = "max_after_deposit" | "max_after_withdrawal" | "max_for_trader" | "for_adl" | "min_after_adl";
+
+/**
+ * A hash; the 32-byte output of a hashing algorithm.
+ *
+ * This struct is used most often in `solana-sdk` and related crates to contain
+ * a [SHA-256] hash, but may instead contain a [blake3] hash, as created by the
+ * [`blake3`] module (and used in [`Message::hash`]).
+ *
+ * [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
+ * [blake3]: https://github.com/BLAKE3-team/BLAKE3
+ * [`blake3`]: crate::blake3
+ * [`Message::hash`]: crate::message::Message::hash
+ */
+export class Hash {
+  free(): void;
+  /**
+   * Create a new Hash object
+   *
+   * * `value` - optional hash as a base58 encoded string, `Uint8Array`, `[number]`
+   */
+  constructor(value: any);
+  /**
+   * Return the base58 string representation of the hash
+   */
+  toString(): string;
+  /**
+   * Checks if two `Hash`s are equal
+   */
+  equals(other: Hash): boolean;
+  /**
+   * Return the `Uint8Array` representation of the hash
+   */
+  toBytes(): Uint8Array;
+}
+/**
+ * A directive for a single invocation of a Solana program.
+ *
+ * An instruction specifies which program it is calling, which accounts it may
+ * read or modify, and additional data that serves as input to the program. One
+ * or more instructions are included in transactions submitted by Solana
+ * clients. Instructions are also used to describe [cross-program
+ * invocations][cpi].
+ *
+ * [cpi]: https://solana.com/docs/core/cpi
+ *
+ * During execution, a program will receive a list of account data as one of
+ * its arguments, in the same order as specified during `Instruction`
+ * construction.
+ *
+ * While Solana is agnostic to the format of the instruction data, it has
+ * built-in support for serialization via [`borsh`] and [`bincode`].
+ *
+ * [`borsh`]: https://docs.rs/borsh/latest/borsh/
+ * [`bincode`]: https://docs.rs/bincode/latest/bincode/
+ *
+ * # Specifying account metadata
+ *
+ * When constructing an [`Instruction`], a list of all accounts that may be
+ * read or written during the execution of that instruction must be supplied as
+ * [`AccountMeta`] values.
+ *
+ * Any account whose data may be mutated by the program during execution must
+ * be specified as writable. During execution, writing to an account that was
+ * not specified as writable will cause the transaction to fail. Writing to an
+ * account that is not owned by the program will cause the transaction to fail.
+ *
+ * Any account whose lamport balance may be mutated by the program during
+ * execution must be specified as writable. During execution, mutating the
+ * lamports of an account that was not specified as writable will cause the
+ * transaction to fail. While _subtracting_ lamports from an account not owned
+ * by the program will cause the transaction to fail, _adding_ lamports to any
+ * account is allowed, as long is it is mutable.
+ *
+ * Accounts that are not read or written by the program may still be specified
+ * in an `Instruction`'s account list. These will affect scheduling of program
+ * execution by the runtime, but will otherwise be ignored.
+ *
+ * When building a transaction, the Solana runtime coalesces all accounts used
+ * by all instructions in that transaction, along with accounts and permissions
+ * required by the runtime, into a single account list. Some accounts and
+ * account permissions required by the runtime to process a transaction are
+ * _not_ required to be included in an `Instruction`s account list. These
+ * include:
+ *
+ * - The program ID &mdash; it is a separate field of `Instruction`
+ * - The transaction's fee-paying account &mdash; it is added during [`Message`]
+ *   construction. A program may still require the fee payer as part of the
+ *   account list if it directly references it.
+ *
+ * [`Message`]: crate::message::Message
+ *
+ * Programs may require signatures from some accounts, in which case they
+ * should be specified as signers during `Instruction` construction. The
+ * program must still validate during execution that the account is a signer.
+ */
+export class Instruction {
+  private constructor();
+  free(): void;
+}
+export class Instructions {
+  free(): void;
+  constructor();
+  push(instruction: Instruction): void;
+}
+/**
+ * A vanilla Ed25519 key pair
+ */
+export class Keypair {
+  free(): void;
+  /**
+   * Create a new `Keypair `
+   */
+  constructor();
+  /**
+   * Convert a `Keypair` to a `Uint8Array`
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Recover a `Keypair` from a `Uint8Array`
+   */
+  static fromBytes(bytes: Uint8Array): Keypair;
+  /**
+   * Return the `Pubkey` for this `Keypair`
+   */
+  pubkey(): Pubkey;
+}
+/**
+ * Wrapper of [`Market`].
+ */
+export class Market {
+  private constructor();
+  free(): void;
+  /**
+   * Create from base64 encoded account data.
+   */
+  static decode_from_base64(data: string): Market;
+  /**
+   * Create from account data.
+   */
+  static decode(data: Uint8Array): Market;
+  /**
+   * Convert into [`JsMarketModel`]
+   */
+  to_model(supply: bigint): MarketModel;
+}
+/**
+ * A JS binding for [`MarkegGraph`].
+ */
+export class MarketGraph {
+  free(): void;
+  /**
+   * Create an empty market graph.
+   */
+  constructor(config: MarketGraphConfig);
+  /**
+   * Insert market from base64 encoded data.
+   */
+  insert_market_from_base64(data: string, supply: bigint): boolean;
+  /**
+   * Update token price.
+   */
+  update_token_price(token: string, price: Value): void;
+  /**
+   * Update value.
+   */
+  update_value(value: bigint): void;
+  /**
+   * Update base cost.
+   */
+  update_base_cost(base_cost: bigint): void;
+  /**
+   * Update max steps.
+   */
+  update_max_steps(max_steps: number): void;
+  /**
+   * Get market by its market token.
+   */
+  get_market(market_token: string): MarketModel | undefined;
+  /**
+   * Get all market tokens.
+   */
+  market_tokens(): string[];
+  /**
+   * Get all index tokens.
+   */
+  index_tokens(): string[];
+  /**
+   * Compute best swap path.
+   */
+  best_swap_path(source: string, target: string, skip_bellman_ford: boolean): BestSwapPath;
+}
+/**
+ * Wrapper of [`MarketModel`].
+ */
+export class MarketModel {
+  private constructor();
+  free(): void;
+  /**
+   * Get market token price.
+   */
+  market_token_price(params: MarketTokenPriceParams): bigint;
+  /**
+   * Get market status.
+   */
+  status(params: MarketStatusParams): MarketStatus;
+}
+/**
+ * A Solana transaction message (legacy).
+ *
+ * See the [`message`] module documentation for further description.
+ *
+ * [`message`]: crate::message
+ *
+ * Some constructors accept an optional `payer`, the account responsible for
+ * paying the cost of executing a transaction. In most cases, callers should
+ * specify the payer explicitly in these constructors. In some cases though,
+ * the caller is not _required_ to specify the payer, but is still allowed to:
+ * in the `Message` structure, the first account is always the fee-payer, so if
+ * the caller has knowledge that the first account of the constructed
+ * transaction's `Message` is both a signer and the expected fee-payer, then
+ * redundantly specifying the fee-payer is not strictly required.
+ */
+export class Message {
+  private constructor();
+  free(): void;
+  /**
+   * The id of a recent ledger entry.
+   */
+  recent_blockhash: Hash;
+}
+/**
+ * JS version of [`Position`].
+ */
+export class Position {
+  private constructor();
+  free(): void;
+  /**
+   * Create from base64 encoded account data.
+   */
+  static decode_from_base64(data: string): Position;
+  /**
+   * Convert to a [`JsPositionModel`].
+   */
+  to_model(market: MarketModel): PositionModel;
+}
+/**
+ * JS version of [`PositionModel`].
+ */
+export class PositionModel {
+  private constructor();
+  free(): void;
+  /**
+   * Get position status.
+   */
+  status(prices: Prices): PositionStatus;
+  /**
+   * Get position size.
+   */
+  size(): bigint;
+  /**
+   * Get position size in tokens.
+   */
+  size_in_tokens(): bigint;
+  /**
+   * Get collateral amount.
+   */
+  collateral_amount(): bigint;
+}
+/**
+ * The address of a [Solana account][acc].
+ *
+ * Some account addresses are [ed25519] public keys, with corresponding secret
+ * keys that are managed off-chain. Often, though, account addresses do not
+ * have corresponding secret keys &mdash; as with [_program derived
+ * addresses_][pdas] &mdash; or the secret key is not relevant to the operation
+ * of a program, and may have even been disposed of. As running Solana programs
+ * can not safely create or manage secret keys, the full [`Keypair`] is not
+ * defined in `solana-program` but in `solana-sdk`.
+ *
+ * [acc]: https://solana.com/docs/core/accounts
+ * [ed25519]: https://ed25519.cr.yp.to/
+ * [pdas]: https://solana.com/docs/core/cpi#program-derived-addresses
+ * [`Keypair`]: https://docs.rs/solana-sdk/latest/solana_sdk/signer/keypair/struct.Keypair.html
+ */
+export class Pubkey {
+  free(): void;
+  /**
+   * Create a new Pubkey object
+   *
+   * * `value` - optional public key as a base58 encoded string, `Uint8Array`, `[number]`
+   */
+  constructor(value: any);
+  /**
+   * Return the base58 string representation of the public key
+   */
+  toString(): string;
+  /**
+   * Check if a `Pubkey` is on the ed25519 curve.
+   */
+  isOnCurve(): boolean;
+  /**
+   * Checks if two `Pubkey`s are equal
+   */
+  equals(other: Pubkey): boolean;
+  /**
+   * Return the `Uint8Array` representation of the public key
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Derive a Pubkey from another Pubkey, string seed, and a program id
+   */
+  static createWithSeed(base: Pubkey, seed: string, owner: Pubkey): Pubkey;
+  /**
+   * Derive a program address from seeds and a program id
+   */
+  static createProgramAddress(seeds: any[], program_id: Pubkey): Pubkey;
+  /**
+   * Find a valid program address
+   *
+   * Returns:
+   * * `[PubKey, number]` - the program address and bump seed
+   */
+  static findProgramAddress(seeds: any[], program_id: Pubkey): any;
+}
+/**
+ * An atomically-committed sequence of instructions.
+ *
+ * While [`Instruction`]s are the basic unit of computation in Solana,
+ * they are submitted by clients in [`Transaction`]s containing one or
+ * more instructions, and signed by one or more [`Signer`]s.
+ *
+ * [`Signer`]: crate::signer::Signer
+ *
+ * See the [module documentation] for more details about transactions.
+ *
+ * [module documentation]: self
+ *
+ * Some constructors accept an optional `payer`, the account responsible for
+ * paying the cost of executing a transaction. In most cases, callers should
+ * specify the payer explicitly in these constructors. In some cases though,
+ * the caller is not _required_ to specify the payer, but is still allowed to:
+ * in the [`Message`] structure, the first account is always the fee-payer, so
+ * if the caller has knowledge that the first account of the constructed
+ * transaction's `Message` is both a signer and the expected fee-payer, then
+ * redundantly specifying the fee-payer is not strictly required.
+ */
+export class Transaction {
+  free(): void;
+  /**
+   * Create a new `Transaction`
+   */
+  constructor(instructions: Instructions, payer?: Pubkey | null);
+  /**
+   * Return a message containing all data that should be signed.
+   */
+  message(): Message;
+  /**
+   * Return the serialized message data to sign.
+   */
+  messageData(): Uint8Array;
+  /**
+   * Verify the transaction
+   */
+  verify(): void;
+  partialSign(keypair: Keypair, recent_blockhash: Hash): void;
+  isSigned(): boolean;
+  toBytes(): Uint8Array;
+  static fromBytes(bytes: Uint8Array): Transaction;
+}
+/**
+ * A JS binding for transaction group.
+ */
+export class TransactionGroup {
+  private constructor();
+  free(): void;
+  /**
+   * Returns serialized transaciton group.
+   */
+  serialize(): SerializedTransactionGroup;
+}