Class AssociatedToken

Hierarchy

AssociatedToken

Constructors

constructor

new AssociatedToken(address: PublicKey, info: null | Account, amount: TokenAmount): AssociatedToken
Creates an instance of AssociatedToken.

Memberof
AssociatedToken
Parameters
- address: PublicKey
- info: null | Account
- amount: TokenAmount
Returns AssociatedToken
- Defined in libraries/ts/margin/src/token/associatedToken.ts:351

Properties

address

address: PublicKey

amount

amount: TokenAmount

exists

exists: boolean

info

info: null | Account

`Static` `Readonly` NATIVE_DECIMALS

NATIVE_DECIMALS: 9 = 9

Methods

`Static` decodeAccount

decodeAccount(data: null | AccountInfo<Buffer>, address: Address, decimals: number): AssociatedToken
Decode a token account. From @solana/spl-token

Returns
Parameters
- data: null | AccountInfo<Buffer>
- address: Address
- decimals: number
Returns AssociatedToken
- Defined in libraries/ts/margin/src/token/associatedToken.ts:361

`Static` decodeMint

decodeMint(info: AccountInfo<Buffer>, address: PublicKey): Mint
Decode a mint account

Returns
Parameters
- info: AccountInfo<Buffer>
- address: PublicKey
Returns Mint
- Defined in libraries/ts/margin/src/token/associatedToken.ts:395

`Static` decodeNative

decodeNative(info: null | AccountInfo<Buffer>, address: Address): AssociatedToken
Decode a token account. From @solana/spl-token

Returns
Parameters
- info: null | AccountInfo<Buffer>
- address: Address
Returns AssociatedToken
- Defined in libraries/ts/margin/src/token/associatedToken.ts:419

`Static` derive

derive(mint: Address, owner: Address): PublicKey
Get the address for the associated token account

Static

Returns
Public key of the associated token account

Memberof
AssociatedToken
Parameters
- mint: Address
  
  Token mint account
- owner: Address
  
  Owner of the new account
Returns PublicKey
- Defined in libraries/ts/margin/src/token/associatedToken.ts:50

`Static` exists

exists(connection: Connection, mint: Address, owner: Address): Promise<boolean>
Parameters
- connection: Connection
- mint: Address
- owner: Address
Returns Promise<boolean>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:87

`Static` existsAux

existsAux(connection: Connection, mint: Address, owner: Address, address: Address): Promise<boolean>
Parameters
- connection: Connection
- mint: Address
- owner: Address
- address: Address
Returns Promise<boolean>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:94

`Static` isNative

isNative(owner: Address, mint: Address, tokenAccountOrNative: Address): boolean
Returns true when the mint is native and the token account is actually the native wallet

Static

Returns

Memberof
AssociatedToken
Parameters
- owner: Address
- mint: Address
- tokenAccountOrNative: Address
Returns boolean
- Defined in libraries/ts/margin/src/token/associatedToken.ts:440

`Static` load

load(__namedParameters: {
    connection: Connection;
    decimals: number;
    mint: Address;
    owner: Address;
}): Promise<AssociatedToken>
TODO:

Static

Returns

Memberof
AssociatedToken
Parameters
- __namedParameters: {
      connection: Connection;
      decimals: number;
      mint: Address;
      owner: Address;
  }
  - connection: Connection
  - decimals: number
  - mint: Address
  - owner: Address
Returns Promise<AssociatedToken>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:66

`Static` loadAux

loadAux(connection: Connection, address: Address, decimals: number): Promise<AssociatedToken>
Parameters
- connection: Connection
- address: Address
- decimals: number
Returns Promise<AssociatedToken>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:117

`Static` loadMint

loadMint(connection: Connection, mint: Address): Promise<undefined | Mint>
TODO: Get mint info

Static

Returns

Memberof
AssociatedToken
Parameters
- connection: Connection
- mint: Address
Returns Promise<undefined | Mint>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:334

`Static` loadMultiple

loadMultiple(__namedParameters: {
    connection: Connection;
    decimals: number | number[];
    mints: Address[];
    owner: Address;
}): Promise<AssociatedToken[]>
Loads multiple token accounts, loads wrapped SOL. Batches by 100 (RPC limit)
Parameters
- __namedParameters: {
      connection: Connection;
      decimals: number | number[];
      mints: Address[];
      owner: Address;
  }
  - connection: Connection
  - decimals: number | number[]
  - mints: Address[]
  - owner: Address
Returns Promise<AssociatedToken[]>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:136

`Static` loadMultipleAux

loadMultipleAux(__namedParameters: {
    addresses: Address[];
    connection: Connection;
    decimals?: number | number[];
}): Promise<AssociatedToken[]>
Loads multiple token accounts and their mints by address. Batches by 100 (RPC limit)
Parameters
- __namedParameters: {
      addresses: Address[];
      connection: Connection;
      decimals?: number | number[];
  }
  - addresses: Address[]
  - connection: Connection
  - Optional decimals?: number | number[]
Returns Promise<AssociatedToken[]>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:260

`Static` loadMultipleOrNative

loadMultipleOrNative(__namedParameters: {
    connection: Connection;
    decimals?: number | number[];
    mints?: Address[];
    owner: Address;
}): Promise<AssociatedToken[]>
Loads multiple associated token accounts by owner. If the native mint is provided, loads the native SOL balance of the owner instead. If a mints array is not provided, loads all associated token accounts and the SOL balance of the owner. Batches by 100 (RPC limit)
Parameters
- __namedParameters: {
      connection: Connection;
      decimals?: number | number[];
      mints?: Address[];
      owner: Address;
  }
  - connection: Connection
  - Optional decimals?: number | number[]
  - Optional mints?: Address[]
  - owner: Address
Returns Promise<AssociatedToken[]>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:161

`Static` withBeginTransferFromSource

withBeginTransferFromSource(__namedParameters: {
    feesBuffer: BN;
    instructions: TransactionInstruction[];
    mint: Address;
    provider: AnchorProvider;
    source: Address | TokenFormat;
}): Promise<PublicKey>
Parameters
- __namedParameters: {
      feesBuffer: BN;
      instructions: TransactionInstruction[];
      mint: Address;
      provider: AnchorProvider;
      source: Address | TokenFormat;
  }
  - feesBuffer: BN
  - instructions: TransactionInstruction[]
  - mint: Address
  - provider: AnchorProvider
  - source: Address | TokenFormat
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:692

`Static` withBeginTransferToDestination

withBeginTransferToDestination(__namedParameters: {
    destination: Address | TokenFormat;
    instructions: TransactionInstruction[];
    mint: Address;
    provider: AnchorProvider;
}): Promise<PublicKey>
Parameters
- __namedParameters: {
      destination: Address | TokenFormat;
      instructions: TransactionInstruction[];
      mint: Address;
      provider: AnchorProvider;
  }
  - destination: Address | TokenFormat
  - instructions: TransactionInstruction[]
  - mint: Address
  - provider: AnchorProvider
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:727

`Static` withClose

withClose(instructions: TransactionInstruction[], owner: Address, mint: Address, rentDestination: Address): void
Add close associated token account IX

Static

Memberof
AssociatedToken
Parameters
- instructions: TransactionInstruction[]
- owner: Address
- mint: Address
- rentDestination: Address
Returns void
- Defined in libraries/ts/margin/src/token/associatedToken.ts:524

`Static` withCreate

withCreate(instructions: TransactionInstruction[], provider: AnchorProvider, owner: Address, mint: Address): Promise<PublicKey>
If the associated token account does not exist for this mint, add instruction to create the token account.If ATA exists, do nothing.

Static

Returns
returns the public key of the token account

Memberof
AssociatedToken
Parameters
- instructions: TransactionInstruction[]
- provider: AnchorProvider
- owner: Address
- mint: Address
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:458

`Static` withCreateAux

withCreateAux(instructions: TransactionInstruction[], provider: AnchorProvider, owner: Address, mint: Address, address: Address): Promise<void>
If the token account does not exist, add instructions to create and initialize the token account. If the account exists do nothing.

Static

Returns
returns the public key of the token account

Memberof
AssociatedToken
Parameters
- instructions: TransactionInstruction[]
- provider: AnchorProvider
- owner: Address
- mint: Address
- address: Address
Returns Promise<void>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:490

`Static` withCreateOrUnwrapIfNativeMint

withCreateOrUnwrapIfNativeMint(preInstructions: TransactionInstruction[], postInstructions: TransactionInstruction[], provider: AnchorProvider, mint: Address): Promise<PublicKey>
Create the associated token account as a pre-instruction. Unwraps sol as a post-instruction.

Static

Memberof
AssociatedToken
Parameters
- preInstructions: TransactionInstruction[]
- postInstructions: TransactionInstruction[]
- provider: AnchorProvider
- mint: Address
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:673

`Static` withCreateOrWrapIfNativeMint

withCreateOrWrapIfNativeMint(instructions: TransactionInstruction[], provider: AnchorProvider, mint: Address, feesBuffer: BN): Promise<PublicKey>
Create the associated token account. Funds it if native.

Static

Memberof
AssociatedToken
Parameters
- instructions: TransactionInstruction[]
- provider: AnchorProvider
- mint: Address
- feesBuffer: BN
  
  How much tokens should remain unwrapped to pay for fees
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:644

`Static` withEndTransfer

withEndTransfer(__namedParameters: {
    destination: Address | TokenFormat;
    instructions: TransactionInstruction[];
    mint: Address;
    provider: AnchorProvider;
}): void
Ends the transfer by unwraps the token if it is the native mint.
Parameters
- __namedParameters: {
      destination: Address | TokenFormat;
      instructions: TransactionInstruction[];
      mint: Address;
      provider: AnchorProvider;
  }
  - destination: Address | TokenFormat
  - instructions: TransactionInstruction[]
  - mint: Address
  - provider: AnchorProvider
Returns void
- Defined in libraries/ts/margin/src/token/associatedToken.ts:765

`Static` withTransfer

withTransfer(instructions: TransactionInstruction[], mint: Address, sourceOwner: Address, destinationOwner: Address, amount: BN): void
Transfer tokens from one owner to another
Parameters
- instructions: TransactionInstruction[]
- mint: Address
- sourceOwner: Address
- destinationOwner: Address
- amount: BN
Returns void
- Defined in libraries/ts/margin/src/token/associatedToken.ts:542

`Static` withUnwrapIfNativeMint

withUnwrapIfNativeMint(instructions: TransactionInstruction[], owner: Address, mint: Address): void
Unwraps all SOL if the mint is native and the tokenAccount is the owner
Parameters
- instructions: TransactionInstruction[]
- owner: Address
- mint: Address
Returns void
- Defined in libraries/ts/margin/src/token/associatedToken.ts:625

`Static` withUnwrapNative

withUnwrapNative(instructions: TransactionInstruction[], owner: Address): void
Unwraps all SOL in the associated token account.
Parameters
- instructions: TransactionInstruction[]
- owner: Address
Returns void
- Defined in libraries/ts/margin/src/token/associatedToken.ts:591

`Static` withWrapIfNativeMint

withWrapIfNativeMint(instructions: TransactionInstruction[], provider: AnchorProvider, mint: Address, feesBuffer: BN): Promise<PublicKey>
Add wrap SOL IX
Parameters
- instructions: TransactionInstruction[]
- provider: AnchorProvider
- mint: Address
- feesBuffer: BN
  
  How much tokens should remain unwrapped to pay for fees
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:602

`Static` withWrapNative

withWrapNative(instructions: TransactionInstruction[], provider: AnchorProvider, feesBuffer: BN): Promise<PublicKey>
Wraps SOL in an associated token account. The account will only be created if it doesn't exist.
Parameters
- instructions: TransactionInstruction[]
- provider: AnchorProvider
- feesBuffer: BN
  
  How much tokens should remain unwrapped to pay for fees
Returns Promise<PublicKey>
- Defined in libraries/ts/margin/src/token/associatedToken.ts:561

`Static` zero

zero(mint: Address, owner: Address, decimals: number): AssociatedToken
Parameters
- mint: Address
- owner: Address
- decimals: number
Returns AssociatedToken
- Defined in libraries/ts/margin/src/token/associatedToken.ts:123

`Static` zeroAux

zeroAux(address: Address, decimals: number): AssociatedToken
Parameters
- address: Address
- decimals: number
Returns AssociatedToken
- Defined in libraries/ts/margin/src/token/associatedToken.ts:128

Class AssociatedToken

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Memberof

Parameters

address: PublicKey

info: null | Account

amount: TokenAmount

Returns AssociatedToken

Properties

address

amount

exists

info

Static Readonly NATIVE_DECIMALS

Methods

Static decodeAccount

Returns

Parameters

data: null | AccountInfo<Buffer>

address: Address

decimals: number

Returns AssociatedToken

Static decodeMint

Returns

Parameters

info: AccountInfo<Buffer>

address: PublicKey

Returns Mint

Static decodeNative

Returns

Parameters

info: null | AccountInfo<Buffer>

address: Address

Returns AssociatedToken

Static derive

Static

Returns

Memberof

Parameters

mint: Address

owner: Address

Returns PublicKey

Static exists

Parameters

connection: Connection

mint: Address

owner: Address

Returns Promise<boolean>

Static existsAux

Parameters

connection: Connection

mint: Address

owner: Address

address: Address

Returns Promise<boolean>

Static isNative

Static

Returns

Memberof

Parameters

owner: Address

mint: Address

tokenAccountOrNative: Address

Returns boolean

Static load

Static

Returns

Memberof

Parameters

__namedParameters: { connection: Connection; decimals: number; mint: Address; owner: Address; }

connection: Connection

decimals: number

mint: Address

owner: Address

`Static` `Readonly` NATIVE_DECIMALS

`Static` decodeAccount

`Static` decodeMint

`Static` decodeNative

`Static` derive

`Static` exists

`Static` existsAux

`Static` isNative

`Static` load

__namedParameters: {
connection: Connection;
decimals: number;
mint: Address;
owner: Address;
}

`Static` loadAux

`Static` loadMint

`Static` loadMultiple

__namedParameters: {
connection: Connection;
decimals: number | number[];
mints: Address[];
owner: Address;
}

`Static` loadMultipleAux

__namedParameters: {
addresses: Address[];
connection: Connection;
decimals?: number | number[];
}

`Optional` decimals?: number | number[]

`Static` loadMultipleOrNative

__namedParameters: {
connection: Connection;
decimals?: number | number[];
mints?: Address[];
owner: Address;
}

`Optional` decimals?: number | number[]

`Optional` mints?: Address[]

`Static` withBeginTransferFromSource

__namedParameters: {
feesBuffer: BN;
instructions: TransactionInstruction[];
mint: Address;
provider: AnchorProvider;
source: Address | TokenFormat;
}

`Static` withBeginTransferToDestination

__namedParameters: {
destination: Address | TokenFormat;
instructions: TransactionInstruction[];
mint: Address;
provider: AnchorProvider;
}

`Static` withClose

`Static` withCreate