@jup-ag/goosefx-ssl-sdk
Version:
SDK for interacting with GooseFX Single-sided Liquidity pools
576 lines (564 loc) • 632 kB
TypeScript
import * as lo from '@solana/buffer-layout';
import { PublicKey, Connection, TransactionInstruction, AccountInfo } from '@solana/web3.js';
import { PriceStatus } from '@pythnetwork/client';
import * as _solana_spl_token from '@solana/spl-token';
import { Program } from '@project-serum/anchor';
interface ControllerLayout {
sighash: Uint8Array;
seed: Buffer;
bump: number;
admin: PublicKey;
suspended: number;
decimals: number;
mint: PublicKey;
dailyReward: bigint;
totalStakingShare: bigint;
stakingBalance: bigint;
lastDistributionTime: bigint;
withdrawFee: number;
}
declare const CONTROLLER_LAYOUT: lo.Structure<ControllerLayout>;
interface LiquidityAccountLayout {
sighash: Uint8Array;
mint: PublicKey;
bump: number;
share: bigint;
ptMinted: bigint;
amountDeposited: bigint;
}
declare const LIQUIDITY_ACCOUNT_LAYOUT: lo.Structure<LiquidityAccountLayout>;
interface Oracle {
elements: Array<{
address: PublicKey;
inverse: boolean;
}>;
n: bigint;
padding: Uint8Array;
}
interface OracleComponent {
address: PublicKey;
inverse: boolean;
padding: Uint8Array;
}
declare const ORACLE_ELEMENT_LAYOUT: lo.Structure<OracleComponent>;
declare const ORACLE_LAYOUT: lo.Structure<Oracle>;
interface PairLayout {
sighash: Uint8Array;
controller: PublicKey;
mints: Array<PublicKey>;
oracles: Array<Oracle>;
nOracle: bigint;
fee_collector: PublicKey;
A: number;
feeRates: Array<number>;
maxDelay: bigint;
confidence: bigint;
balancer: PublicKey;
excessiveConfiscateRate: number;
feeCollector: PublicKey;
platformFeeRate: Array<number>;
rebalanceRebates: Array<number>;
volumes: Array<bigint>;
enableRebalanceSwap: boolean;
}
declare const PAIR_LAYOUT: lo.Structure<PairLayout>;
interface SSLLayout {
sighash: Uint8Array;
controller: PublicKey;
mint: PublicKey;
decimals: number;
bump: number;
ptBump: number;
suspended: boolean;
cranker: PublicKey;
weight: bigint;
swappedLiabilityNative: bigint;
totalShare: bigint;
}
declare const SSL_LAYOUT: lo.Structure<SSLLayout>;
interface StakingAccountLayout {
sighash: Uint8Array;
controller: PublicKey;
bump: number;
share: bigint;
amountStaked: bigint;
}
declare const STAKING_ACCOUNT_LAYOUT: lo.Structure<StakingAccountLayout>;
/* tslint:disable */
/* eslint-disable */
/**
* @param {Uint8Array} ssl_in
* @param {Uint8Array} ssl_out
* @param {Uint8Array} pair
* @param {bigint} liability_in
* @param {bigint} liability_out
* @param {bigint} swapped_liability_in
* @param {bigint} swapped_liability_out
* @param {OracleRegistry} oracles
* @param {bigint} amount_in
* @param {number} niter
* @returns {SwapResult}
*/
declare function swap(ssl_in: Uint8Array, ssl_out: Uint8Array, pair: Uint8Array, liability_in: bigint, liability_out: bigint, swapped_liability_in: bigint, swapped_liability_out: bigint, oracles: OracleRegistry, amount_in: bigint, niter: number): SwapResult;
/**
* Initialize Javascript logging and panic handler
*/
declare function solana_program_init(): void;
/**
*/
declare class Hash {
free(): void;
/**
* Create a new Hash object
*
* * `value` - optional hash as a base58 encoded string, `Uint8Array`, `[number]`
* @param {any} value
*/
constructor(value: any);
/**
* Return the base58 string representation of the hash
* @returns {string}
*/
toString(): string;
/**
* Checks if two `Hash`s are equal
* @param {Hash} other
* @returns {boolean}
*/
equals(other: Hash): boolean;
/**
* Return the `Uint8Array` representation of the hash
* @returns {Uint8Array}
*/
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://docs.solana.com/developing/programming-model/calling-between-programs
*
* 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 — it is a separate field of `Instruction`
* - The transaction's fee-paying account — 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.
*/
declare class Instruction {
free(): void;
}
/**
*/
declare class Instructions {
free(): void;
/**
*/
constructor();
/**
* @param {Instruction} instruction
*/
push(instruction: Instruction): void;
}
/**
* A vanilla Ed25519 key pair
*/
declare class Keypair {
free(): void;
/**
* Create a new `Keypair `
*/
constructor();
/**
* Convert a `Keypair` to a `Uint8Array`
* @returns {Uint8Array}
*/
toBytes(): Uint8Array;
/**
* Recover a `Keypair` from a `Uint8Array`
* @param {Uint8Array} bytes
* @returns {Keypair}
*/
static fromBytes(bytes: Uint8Array): Keypair;
/**
* Return the `Pubkey` for this `Keypair`
* @returns {Pubkey}
*/
pubkey(): Pubkey;
}
/**
* 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.
*/
declare class Message {
free(): void;
/**
* The id of a recent ledger entry.
*/
recent_blockhash: Hash;
}
/**
*/
declare class OracleRegistry {
free(): void;
/**
*/
constructor();
/**
* @param {Uint8Array} key
* @param {Uint8Array} data
*/
add_oracle(key: Uint8Array, data: Uint8Array): void;
}
/**
*/
declare class Pubkey {
free(): void;
/**
* Create a new Pubkey object
*
* * `value` - optional public key as a base58 encoded string, `Uint8Array`, `[number]`
* @param {any} value
*/
constructor(value: any);
/**
* Return the base58 string representation of the public key
* @returns {string}
*/
toString(): string;
/**
* Check if a `Pubkey` is on the ed25519 curve.
* @returns {boolean}
*/
isOnCurve(): boolean;
/**
* Checks if two `Pubkey`s are equal
* @param {Pubkey} other
* @returns {boolean}
*/
equals(other: Pubkey): boolean;
/**
* Return the `Uint8Array` representation of the public key
* @returns {Uint8Array}
*/
toBytes(): Uint8Array;
/**
* Derive a Pubkey from another Pubkey, string seed, and a program id
* @param {Pubkey} base
* @param {string} seed
* @param {Pubkey} owner
* @returns {Pubkey}
*/
static createWithSeed(base: Pubkey, seed: string, owner: Pubkey): Pubkey;
/**
* Derive a program address from seeds and a program id
* @param {any[]} seeds
* @param {Pubkey} program_id
* @returns {Pubkey}
*/
static createProgramAddress(seeds: any[], program_id: Pubkey): Pubkey;
/**
* Find a valid program address
*
* Returns:
* * `[PubKey, number]` - the program address and bump seed
* @param {any[]} seeds
* @param {Pubkey} program_id
* @returns {any}
*/
static findProgramAddress(seeds: any[], program_id: Pubkey): any;
}
/**
*/
declare class SwapResult {
free(): void;
/**
*/
amount_in: bigint;
/**
*/
amount_out: bigint;
/**
*/
fee_paid: bigint;
/**
*/
insta_price: number;
/**
*/
iter: number;
/**
*/
oracle_price: number;
/**
*/
price_impact: number;
/**
*/
swap_price: number;
}
/**
* An atomically-commited 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.
*/
declare class Transaction {
free(): void;
/**
* Create a new `Transaction`
* @param {Instructions} instructions
* @param {Pubkey | undefined} payer
*/
constructor(instructions: Instructions, payer?: Pubkey);
/**
* Return a message containing all data that should be signed.
* @returns {Message}
*/
message(): Message;
/**
* Return the serialized message data to sign.
* @returns {Uint8Array}
*/
messageData(): Uint8Array;
/**
* Verify the transaction
*/
verify(): void;
/**
* @param {Keypair} keypair
* @param {Hash} recent_blockhash
*/
partialSign(keypair: Keypair, recent_blockhash: Hash): void;
/**
* @returns {boolean}
*/
isSigned(): boolean;
/**
* @returns {Uint8Array}
*/
toBytes(): Uint8Array;
/**
* @param {Uint8Array} bytes
* @returns {Transaction}
*/
static fromBytes(bytes: Uint8Array): Transaction;
}
type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
interface InitOutput {
readonly memory: WebAssembly.Memory;
readonly __wbg_oracleregistry_free: (a: number) => void;
readonly oracleregistry_new: () => number;
readonly oracleregistry_add_oracle: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
readonly __wbg_swapresult_free: (a: number) => void;
readonly __wbg_get_swapresult_amount_in: (a: number) => number;
readonly __wbg_set_swapresult_amount_in: (a: number, b: number) => void;
readonly __wbg_get_swapresult_fee_paid: (a: number) => number;
readonly __wbg_set_swapresult_fee_paid: (a: number, b: number) => void;
readonly __wbg_get_swapresult_amount_out: (a: number) => number;
readonly __wbg_set_swapresult_amount_out: (a: number, b: number) => void;
readonly __wbg_get_swapresult_price_impact: (a: number) => number;
readonly __wbg_set_swapresult_price_impact: (a: number, b: number) => void;
readonly __wbg_get_swapresult_swap_price: (a: number) => number;
readonly __wbg_set_swapresult_swap_price: (a: number, b: number) => void;
readonly __wbg_get_swapresult_insta_price: (a: number) => number;
readonly __wbg_set_swapresult_insta_price: (a: number, b: number) => void;
readonly __wbg_get_swapresult_oracle_price: (a: number) => number;
readonly __wbg_set_swapresult_oracle_price: (a: number, b: number) => void;
readonly __wbg_get_swapresult_iter: (a: number) => number;
readonly __wbg_set_swapresult_iter: (a: number, b: number) => void;
readonly swap: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;
readonly __wbg_transaction_free: (a: number) => void;
readonly transaction_constructor: (a: number, b: number) => number;
readonly transaction_message: (a: number) => number;
readonly transaction_messageData: (a: number, b: number) => void;
readonly transaction_verify: (a: number, b: number) => void;
readonly transaction_partialSign: (a: number, b: number, c: number) => void;
readonly transaction_isSigned: (a: number) => number;
readonly transaction_toBytes: (a: number, b: number) => void;
readonly transaction_fromBytes: (a: number, b: number, c: number) => void;
readonly __wbg_keypair_free: (a: number) => void;
readonly keypair_constructor: () => number;
readonly keypair_toBytes: (a: number, b: number) => void;
readonly keypair_fromBytes: (a: number, b: number, c: number) => void;
readonly keypair_pubkey: (a: number) => number;
readonly __wbg_instruction_free: (a: number) => void;
readonly systeminstruction_createAccount: (a: number, b: number, c: number, d: number, e: number) => number;
readonly systeminstruction_createAccountWithSeed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
readonly systeminstruction_assign: (a: number, b: number) => number;
readonly systeminstruction_assignWithSeed: (a: number, b: number, c: number, d: number, e: number) => number;
readonly systeminstruction_transfer: (a: number, b: number, c: number) => number;
readonly systeminstruction_transferWithSeed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
readonly systeminstruction_allocate: (a: number, b: number) => number;
readonly systeminstruction_allocateWithSeed: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
readonly systeminstruction_createNonceAccount: (a: number, b: number, c: number, d: number) => number;
readonly systeminstruction_advanceNonceAccount: (a: number, b: number) => number;
readonly systeminstruction_withdrawNonceAccount: (a: number, b: number, c: number, d: number) => number;
readonly systeminstruction_authorizeNonceAccount: (a: number, b: number, c: number) => number;
readonly __wbg_message_free: (a: number) => void;
readonly __wbg_get_message_recent_blockhash: (a: number) => number;
readonly __wbg_set_message_recent_blockhash: (a: number, b: number) => void;
readonly __wbg_pubkey_free: (a: number) => void;
readonly pubkey_constructor: (a: number, b: number) => void;
readonly pubkey_toString: (a: number, b: number) => void;
readonly pubkey_isOnCurve: (a: number) => number;
readonly pubkey_equals: (a: number, b: number) => number;
readonly pubkey_toBytes: (a: number, b: number) => void;
readonly pubkey_createWithSeed: (a: number, b: number, c: number, d: number, e: number) => void;
readonly pubkey_createProgramAddress: (a: number, b: number, c: number, d: number) => void;
readonly pubkey_findProgramAddress: (a: number, b: number, c: number, d: number) => void;
readonly solana_program_init: () => void;
readonly hash_constructor: (a: number, b: number) => void;
readonly hash_toString: (a: number, b: number) => void;
readonly hash_equals: (a: number, b: number) => number;
readonly hash_toBytes: (a: number, b: number) => void;
readonly __wbg_instructions_free: (a: number) => void;
readonly instructions_constructor: () => number;
readonly instructions_push: (a: number, b: number) => void;
readonly __wbg_hash_free: (a: number) => void;
readonly __wbindgen_malloc: (a: number) => number;
readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
readonly __wbindgen_free: (a: number, b: number) => void;
readonly __wbindgen_exn_store: (a: number) => void;
}
type SyncInitInput = BufferSource | WebAssembly.Module;
/**
* Instantiates the given `module`, which can either be bytes or
* a precompiled `WebAssembly.Module`.
*
* @param {SyncInitInput} module
*
* @returns {InitOutput}
*/
declare function initSync(module: SyncInitInput): InitOutput;
/**
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
* for everything else, calls `WebAssembly.instantiate` directly.
*
* @param {InitInput | Promise<InitInput>} module_or_path
*
* @returns {Promise<InitOutput>}
*/
declare function init (module_or_path: InitInput | Promise<InitInput>): Promise<InitOutput>;
declare const wasm_swap: typeof swap;
declare const wasm_solana_program_init: typeof solana_program_init;
type wasm_Hash = Hash;
declare const wasm_Hash: typeof Hash;
type wasm_Instruction = Instruction;
declare const wasm_Instruction: typeof Instruction;
type wasm_Instructions = Instructions;
declare const wasm_Instructions: typeof Instructions;
type wasm_Keypair = Keypair;
declare const wasm_Keypair: typeof Keypair;
type wasm_Message = Message;
declare const wasm_Message: typeof Message;
type wasm_OracleRegistry = OracleRegistry;
declare const wasm_OracleRegistry: typeof OracleRegistry;
type wasm_Pubkey = Pubkey;
declare const wasm_Pubkey: typeof Pubkey;
type wasm_SwapResult = SwapResult;
declare const wasm_SwapResult: typeof SwapResult;
type wasm_Transaction = Transaction;
declare const wasm_Transaction: typeof Transaction;
type wasm_InitInput = InitInput;
type wasm_InitOutput = InitOutput;
type wasm_SyncInitInput = SyncInitInput;
declare const wasm_initSync: typeof initSync;
declare namespace wasm {
export {
init as default,
wasm_swap as swap,
wasm_solana_program_init as solana_program_init,
wasm_Hash as Hash,
wasm_Instruction as Instruction,
wasm_Instructions as Instructions,
wasm_Keypair as Keypair,
wasm_Message as Message,
wasm_OracleRegistry as OracleRegistry,
wasm_Pubkey as Pubkey,
wasm_SwapResult as SwapResult,
wasm_Transaction as Transaction,
wasm_InitInput as InitInput,
wasm_InitOutput as InitOutput,
wasm_SyncInitInput as SyncInitInput,
wasm_initSync as initSync,
};
}
declare const data: "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