@jup-ag/whirlpools-sdk
Version:
Typescript SDK to interact with Orca's Whirlpool program.
2,268 lines (2,233 loc) • 187 kB
JavaScript
"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __export = (target, all) => {
for (var name2 in all)
__defProp(target, name2, { get: all[name2], enumerable: true });
};
var __decorateClass = (decorators, target, key, kind) => {
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
for (var i = decorators.length - 1, decorator; i >= 0; i--)
if (decorator = decorators[i])
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
if (kind && result)
__defProp(target, key, result);
return result;
};
// src/index.ts
var _decimaljs = require('decimal.js'); var _decimaljs2 = _interopRequireDefault(_decimaljs);
// src/context.ts
var _anchor = require('@project-serum/anchor'); var anchor = _interopRequireWildcard(_anchor); var anchor2 = _interopRequireWildcard(_anchor); var anchor3 = _interopRequireWildcard(_anchor);
// src/artifacts/whirlpool.json
var whirlpool_exports = {};
__export(whirlpool_exports, {
accounts: () => accounts,
default: () => whirlpool_default,
errors: () => errors,
instructions: () => instructions,
name: () => name,
types: () => types,
version: () => version
});
var version = "0.1.0";
var name = "whirlpool";
var instructions = [
{
name: "initializeConfig",
accounts: [
{
name: "config",
isMut: true,
isSigner: true
},
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "systemProgram",
isMut: false,
isSigner: false
}
],
args: [
{
name: "feeAuthority",
type: "publicKey"
},
{
name: "collectProtocolFeesAuthority",
type: "publicKey"
},
{
name: "rewardEmissionsSuperAuthority",
type: "publicKey"
},
{
name: "defaultProtocolFeeRate",
type: "u16"
}
]
},
{
name: "initializePool",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "tokenMintA",
isMut: false,
isSigner: false
},
{
name: "tokenMintB",
isMut: false,
isSigner: false
},
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "tokenVaultA",
isMut: true,
isSigner: true
},
{
name: "tokenVaultB",
isMut: true,
isSigner: true
},
{
name: "feeTier",
isMut: false,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "systemProgram",
isMut: false,
isSigner: false
},
{
name: "rent",
isMut: false,
isSigner: false
}
],
args: [
{
name: "bumps",
type: {
defined: "WhirlpoolBumps"
}
},
{
name: "tickSpacing",
type: "u16"
},
{
name: "initialSqrtPrice",
type: "u128"
}
]
},
{
name: "initializeTickArray",
accounts: [
{
name: "whirlpool",
isMut: false,
isSigner: false
},
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "tickArray",
isMut: true,
isSigner: false
},
{
name: "systemProgram",
isMut: false,
isSigner: false
}
],
args: [
{
name: "startTickIndex",
type: "i32"
}
]
},
{
name: "initializeFeeTier",
accounts: [
{
name: "config",
isMut: false,
isSigner: false
},
{
name: "feeTier",
isMut: true,
isSigner: false
},
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
},
{
name: "systemProgram",
isMut: false,
isSigner: false
}
],
args: [
{
name: "tickSpacing",
type: "u16"
},
{
name: "defaultFeeRate",
type: "u16"
}
]
},
{
name: "initializeReward",
accounts: [
{
name: "rewardAuthority",
isMut: false,
isSigner: true
},
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "rewardMint",
isMut: false,
isSigner: false
},
{
name: "rewardVault",
isMut: true,
isSigner: true
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "systemProgram",
isMut: false,
isSigner: false
},
{
name: "rent",
isMut: false,
isSigner: false
}
],
args: [
{
name: "rewardIndex",
type: "u8"
}
]
},
{
name: "setRewardEmissions",
accounts: [
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "rewardAuthority",
isMut: false,
isSigner: true
},
{
name: "rewardVault",
isMut: false,
isSigner: false
}
],
args: [
{
name: "rewardIndex",
type: "u8"
},
{
name: "emissionsPerSecondX64",
type: "u128"
}
]
},
{
name: "openPosition",
accounts: [
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "owner",
isMut: false,
isSigner: false
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionMint",
isMut: true,
isSigner: true
},
{
name: "positionTokenAccount",
isMut: true,
isSigner: false
},
{
name: "whirlpool",
isMut: false,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "systemProgram",
isMut: false,
isSigner: false
},
{
name: "rent",
isMut: false,
isSigner: false
},
{
name: "associatedTokenProgram",
isMut: false,
isSigner: false
}
],
args: [
{
name: "bumps",
type: {
defined: "OpenPositionBumps"
}
},
{
name: "tickLowerIndex",
type: "i32"
},
{
name: "tickUpperIndex",
type: "i32"
}
]
},
{
name: "openPositionWithMetadata",
accounts: [
{
name: "funder",
isMut: true,
isSigner: true
},
{
name: "owner",
isMut: false,
isSigner: false
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionMint",
isMut: true,
isSigner: true
},
{
name: "positionMetadataAccount",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: true,
isSigner: false
},
{
name: "whirlpool",
isMut: false,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "systemProgram",
isMut: false,
isSigner: false
},
{
name: "rent",
isMut: false,
isSigner: false
},
{
name: "associatedTokenProgram",
isMut: false,
isSigner: false
},
{
name: "metadataProgram",
isMut: false,
isSigner: false
},
{
name: "metadataUpdateAuth",
isMut: false,
isSigner: false
}
],
args: [
{
name: "bumps",
type: {
defined: "OpenPositionWithMetadataBumps"
}
},
{
name: "tickLowerIndex",
type: "i32"
},
{
name: "tickUpperIndex",
type: "i32"
}
]
},
{
name: "increaseLiquidity",
accounts: [
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "positionAuthority",
isMut: false,
isSigner: true
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: false,
isSigner: false
},
{
name: "tokenOwnerAccountA",
isMut: true,
isSigner: false
},
{
name: "tokenOwnerAccountB",
isMut: true,
isSigner: false
},
{
name: "tokenVaultA",
isMut: true,
isSigner: false
},
{
name: "tokenVaultB",
isMut: true,
isSigner: false
},
{
name: "tickArrayLower",
isMut: true,
isSigner: false
},
{
name: "tickArrayUpper",
isMut: true,
isSigner: false
}
],
args: [
{
name: "liquidityAmount",
type: "u128"
},
{
name: "tokenMaxA",
type: "u64"
},
{
name: "tokenMaxB",
type: "u64"
}
]
},
{
name: "decreaseLiquidity",
accounts: [
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "positionAuthority",
isMut: false,
isSigner: true
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: false,
isSigner: false
},
{
name: "tokenOwnerAccountA",
isMut: true,
isSigner: false
},
{
name: "tokenOwnerAccountB",
isMut: true,
isSigner: false
},
{
name: "tokenVaultA",
isMut: true,
isSigner: false
},
{
name: "tokenVaultB",
isMut: true,
isSigner: false
},
{
name: "tickArrayLower",
isMut: true,
isSigner: false
},
{
name: "tickArrayUpper",
isMut: true,
isSigner: false
}
],
args: [
{
name: "liquidityAmount",
type: "u128"
},
{
name: "tokenMinA",
type: "u64"
},
{
name: "tokenMinB",
type: "u64"
}
]
},
{
name: "updateFeesAndRewards",
accounts: [
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "tickArrayLower",
isMut: false,
isSigner: false
},
{
name: "tickArrayUpper",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "collectFees",
accounts: [
{
name: "whirlpool",
isMut: false,
isSigner: false
},
{
name: "positionAuthority",
isMut: false,
isSigner: true
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: false,
isSigner: false
},
{
name: "tokenOwnerAccountA",
isMut: true,
isSigner: false
},
{
name: "tokenVaultA",
isMut: true,
isSigner: false
},
{
name: "tokenOwnerAccountB",
isMut: true,
isSigner: false
},
{
name: "tokenVaultB",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "collectReward",
accounts: [
{
name: "whirlpool",
isMut: false,
isSigner: false
},
{
name: "positionAuthority",
isMut: false,
isSigner: true
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: false,
isSigner: false
},
{
name: "rewardOwnerAccount",
isMut: true,
isSigner: false
},
{
name: "rewardVault",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
}
],
args: [
{
name: "rewardIndex",
type: "u8"
}
]
},
{
name: "collectProtocolFees",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "collectProtocolFeesAuthority",
isMut: false,
isSigner: true
},
{
name: "tokenVaultA",
isMut: true,
isSigner: false
},
{
name: "tokenVaultB",
isMut: true,
isSigner: false
},
{
name: "tokenDestinationA",
isMut: true,
isSigner: false
},
{
name: "tokenDestinationB",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "swap",
accounts: [
{
name: "tokenProgram",
isMut: false,
isSigner: false
},
{
name: "tokenAuthority",
isMut: false,
isSigner: true
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "tokenOwnerAccountA",
isMut: true,
isSigner: false
},
{
name: "tokenVaultA",
isMut: true,
isSigner: false
},
{
name: "tokenOwnerAccountB",
isMut: true,
isSigner: false
},
{
name: "tokenVaultB",
isMut: true,
isSigner: false
},
{
name: "tickArray0",
isMut: true,
isSigner: false
},
{
name: "tickArray1",
isMut: true,
isSigner: false
},
{
name: "tickArray2",
isMut: true,
isSigner: false
},
{
name: "oracle",
isMut: false,
isSigner: false
}
],
args: [
{
name: "amount",
type: "u64"
},
{
name: "otherAmountThreshold",
type: "u64"
},
{
name: "sqrtPriceLimit",
type: "u128"
},
{
name: "amountSpecifiedIsInput",
type: "bool"
},
{
name: "aToB",
type: "bool"
}
]
},
{
name: "closePosition",
accounts: [
{
name: "positionAuthority",
isMut: false,
isSigner: true
},
{
name: "receiver",
isMut: true,
isSigner: false
},
{
name: "position",
isMut: true,
isSigner: false
},
{
name: "positionMint",
isMut: true,
isSigner: false
},
{
name: "positionTokenAccount",
isMut: true,
isSigner: false
},
{
name: "tokenProgram",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "setDefaultFeeRate",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "feeTier",
isMut: true,
isSigner: false
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
}
],
args: [
{
name: "defaultFeeRate",
type: "u16"
}
]
},
{
name: "setDefaultProtocolFeeRate",
accounts: [
{
name: "whirlpoolsConfig",
isMut: true,
isSigner: false
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
}
],
args: [
{
name: "defaultProtocolFeeRate",
type: "u16"
}
]
},
{
name: "setFeeRate",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
}
],
args: [
{
name: "feeRate",
type: "u16"
}
]
},
{
name: "setProtocolFeeRate",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
}
],
args: [
{
name: "protocolFeeRate",
type: "u16"
}
]
},
{
name: "setFeeAuthority",
accounts: [
{
name: "whirlpoolsConfig",
isMut: true,
isSigner: false
},
{
name: "feeAuthority",
isMut: false,
isSigner: true
},
{
name: "newFeeAuthority",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "setCollectProtocolFeesAuthority",
accounts: [
{
name: "whirlpoolsConfig",
isMut: true,
isSigner: false
},
{
name: "collectProtocolFeesAuthority",
isMut: false,
isSigner: true
},
{
name: "newCollectProtocolFeesAuthority",
isMut: false,
isSigner: false
}
],
args: []
},
{
name: "setRewardAuthority",
accounts: [
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "rewardAuthority",
isMut: false,
isSigner: true
},
{
name: "newRewardAuthority",
isMut: false,
isSigner: false
}
],
args: [
{
name: "rewardIndex",
type: "u8"
}
]
},
{
name: "setRewardAuthorityBySuperAuthority",
accounts: [
{
name: "whirlpoolsConfig",
isMut: false,
isSigner: false
},
{
name: "whirlpool",
isMut: true,
isSigner: false
},
{
name: "rewardEmissionsSuperAuthority",
isMut: false,
isSigner: true
},
{
name: "newRewardAuthority",
isMut: false,
isSigner: false
}
],
args: [
{
name: "rewardIndex",
type: "u8"
}
]
},
{
name: "setRewardEmissionsSuperAuthority",
accounts: [
{
name: "whirlpoolsConfig",
isMut: true,
isSigner: false
},
{
name: "rewardEmissionsSuperAuthority",
isMut: false,
isSigner: true
},
{
name: "newRewardEmissionsSuperAuthority",
isMut: false,
isSigner: false
}
],
args: []
}
];
var accounts = [
{
name: "WhirlpoolsConfig",
type: {
kind: "struct",
fields: [
{
name: "feeAuthority",
type: "publicKey"
},
{
name: "collectProtocolFeesAuthority",
type: "publicKey"
},
{
name: "rewardEmissionsSuperAuthority",
type: "publicKey"
},
{
name: "defaultProtocolFeeRate",
type: "u16"
}
]
}
},
{
name: "FeeTier",
type: {
kind: "struct",
fields: [
{
name: "whirlpoolsConfig",
type: "publicKey"
},
{
name: "tickSpacing",
type: "u16"
},
{
name: "defaultFeeRate",
type: "u16"
}
]
}
},
{
name: "Position",
type: {
kind: "struct",
fields: [
{
name: "whirlpool",
type: "publicKey"
},
{
name: "positionMint",
type: "publicKey"
},
{
name: "liquidity",
type: "u128"
},
{
name: "tickLowerIndex",
type: "i32"
},
{
name: "tickUpperIndex",
type: "i32"
},
{
name: "feeGrowthCheckpointA",
type: "u128"
},
{
name: "feeOwedA",
type: "u64"
},
{
name: "feeGrowthCheckpointB",
type: "u128"
},
{
name: "feeOwedB",
type: "u64"
},
{
name: "rewardInfos",
type: {
array: [
{
defined: "PositionRewardInfo"
},
3
]
}
}
]
}
},
{
name: "TickArray",
type: {
kind: "struct",
fields: [
{
name: "startTickIndex",
type: "i32"
},
{
name: "ticks",
type: {
array: [
{
defined: "Tick"
},
88
]
}
},
{
name: "whirlpool",
type: "publicKey"
}
]
}
},
{
name: "Whirlpool",
type: {
kind: "struct",
fields: [
{
name: "whirlpoolsConfig",
type: "publicKey"
},
{
name: "whirlpoolBump",
type: {
array: [
"u8",
1
]
}
},
{
name: "tickSpacing",
type: "u16"
},
{
name: "tickSpacingSeed",
type: {
array: [
"u8",
2
]
}
},
{
name: "feeRate",
type: "u16"
},
{
name: "protocolFeeRate",
type: "u16"
},
{
name: "liquidity",
type: "u128"
},
{
name: "sqrtPrice",
type: "u128"
},
{
name: "tickCurrentIndex",
type: "i32"
},
{
name: "protocolFeeOwedA",
type: "u64"
},
{
name: "protocolFeeOwedB",
type: "u64"
},
{
name: "tokenMintA",
type: "publicKey"
},
{
name: "tokenVaultA",
type: "publicKey"
},
{
name: "feeGrowthGlobalA",
type: "u128"
},
{
name: "tokenMintB",
type: "publicKey"
},
{
name: "tokenVaultB",
type: "publicKey"
},
{
name: "feeGrowthGlobalB",
type: "u128"
},
{
name: "rewardLastUpdatedTimestamp",
type: "u64"
},
{
name: "rewardInfos",
type: {
array: [
{
defined: "WhirlpoolRewardInfo"
},
3
]
}
}
]
}
}
];
var types = [
{
name: "OpenPositionBumps",
type: {
kind: "struct",
fields: [
{
name: "positionBump",
type: "u8"
}
]
}
},
{
name: "OpenPositionWithMetadataBumps",
type: {
kind: "struct",
fields: [
{
name: "positionBump",
type: "u8"
},
{
name: "metadataBump",
type: "u8"
}
]
}
},
{
name: "PositionRewardInfo",
type: {
kind: "struct",
fields: [
{
name: "growthInsideCheckpoint",
type: "u128"
},
{
name: "amountOwed",
type: "u64"
}
]
}
},
{
name: "Tick",
type: {
kind: "struct",
fields: [
{
name: "initialized",
type: "bool"
},
{
name: "liquidityNet",
type: "i128"
},
{
name: "liquidityGross",
type: "u128"
},
{
name: "feeGrowthOutsideA",
type: "u128"
},
{
name: "feeGrowthOutsideB",
type: "u128"
},
{
name: "rewardGrowthsOutside",
type: {
array: [
"u128",
3
]
}
}
]
}
},
{
name: "WhirlpoolRewardInfo",
type: {
kind: "struct",
fields: [
{
name: "mint",
type: "publicKey"
},
{
name: "vault",
type: "publicKey"
},
{
name: "authority",
type: "publicKey"
},
{
name: "emissionsPerSecondX64",
type: "u128"
},
{
name: "growthGlobalX64",
type: "u128"
}
]
}
},
{
name: "WhirlpoolBumps",
type: {
kind: "struct",
fields: [
{
name: "whirlpoolBump",
type: "u8"
}
]
}
},
{
name: "CurrIndex",
type: {
kind: "enum",
variants: [
{
name: "Below"
},
{
name: "Inside"
},
{
name: "Above"
}
]
}
},
{
name: "TickLabel",
type: {
kind: "enum",
variants: [
{
name: "Upper"
},
{
name: "Lower"
}
]
}
},
{
name: "Direction",
type: {
kind: "enum",
variants: [
{
name: "Left"
},
{
name: "Right"
}
]
}
}
];
var errors = [
{
code: 6e3,
name: "InvalidEnum",
msg: "Enum value could not be converted"
},
{
code: 6001,
name: "InvalidStartTick",
msg: "Invalid start tick index provided."
},
{
code: 6002,
name: "TickArrayExistInPool",
msg: "Tick-array already exists in this whirlpool"
},
{
code: 6003,
name: "TickArrayIndexOutofBounds",
msg: "Attempt to search for a tick-array failed"
},
{
code: 6004,
name: "InvalidTickSpacing",
msg: "Tick-spacing is not supported"
},
{
code: 6005,
name: "ClosePositionNotEmpty",
msg: "Position is not empty It cannot be closed"
},
{
code: 6006,
name: "DivideByZero",
msg: "Unable to divide by zero"
},
{
code: 6007,
name: "NumberCastError",
msg: "Unable to cast number into BigInt"
},
{
code: 6008,
name: "NumberDownCastError",
msg: "Unable to down cast number"
},
{
code: 6009,
name: "TickNotFound",
msg: "Tick not found within tick array"
},
{
code: 6010,
name: "InvalidTickIndex",
msg: "Provided tick index is either out of bounds or uninitializable"
},
{
code: 6011,
name: "SqrtPriceOutOfBounds",
msg: "Provided sqrt price out of bounds"
},
{
code: 6012,
name: "LiquidityZero",
msg: "Liquidity amount must be greater than zero"
},
{
code: 6013,
name: "LiquidityTooHigh",
msg: "Liquidity amount must be less than i64::MAX"
},
{
code: 6014,
name: "LiquidityOverflow",
msg: "Liquidity overflow"
},
{
code: 6015,
name: "LiquidityUnderflow",
msg: "Liquidity underflow"
},
{
code: 6016,
name: "LiquidityNetError",
msg: "Tick liquidity net underflowed or overflowed"
},
{
code: 6017,
name: "TokenMaxExceeded",
msg: "Exceeded token max"
},
{
code: 6018,
name: "TokenMinSubceeded",
msg: "Did not meet token min"
},
{
code: 6019,
name: "MissingOrInvalidDelegate",
msg: "Position token account has a missing or invalid delegate"
},
{
code: 6020,
name: "InvalidPositionTokenAmount",
msg: "Position token amount must be 1"
},
{
code: 6021,
name: "InvalidTimestampConversion",
msg: "Timestamp should be convertible from i64 to u64"
},
{
code: 6022,
name: "InvalidTimestamp",
msg: "Timestamp should be greater than the last updated timestamp"
},
{
code: 6023,
name: "InvalidTickArraySequence",
msg: "Invalid tick array sequence provided for instruction."
},
{
code: 6024,
name: "InvalidTokenMintOrder",
msg: "Token Mint in wrong order"
},
{
code: 6025,
name: "RewardNotInitialized",
msg: "Reward not initialized"
},
{
code: 6026,
name: "InvalidRewardIndex",
msg: "Invalid reward index"
},
{
code: 6027,
name: "RewardVaultAmountInsufficient",
msg: "Reward vault requires amount to support emissions for at least one day"
},
{
code: 6028,
name: "FeeRateMaxExceeded",
msg: "Exceeded max fee rate"
},
{
code: 6029,
name: "ProtocolFeeRateMaxExceeded",
msg: "Exceeded max protocol fee rate"
},
{
code: 6030,
name: "MultiplicationShiftRightOverflow",
msg: "Multiplication with shift right overflow"
},
{
code: 6031,
name: "MulDivOverflow",
msg: "Muldiv overflow"
},
{
code: 6032,
name: "MulDivInvalidInput",
msg: "Invalid div_u256 input"
},
{
code: 6033,
name: "MultiplicationOverflow",
msg: "Multiplication overflow"
},
{
code: 6034,
name: "InvalidSqrtPriceLimitDirection",
msg: "Provided SqrtPriceLimit not in the same direction as the swap."
},
{
code: 6035,
name: "ZeroTradableAmount",
msg: "There are no tradable amount to swap."
},
{
code: 6036,
name: "AmountOutBelowMinimum",
msg: "Amount out below minimum threshold"
},
{
code: 6037,
name: "AmountInAboveMaximum",
msg: "Amount in above maximum threshold"
},
{
code: 6038,
name: "TickArraySequenceInvalidIndex",
msg: "Invalid index for tick array sequence"
},
{
code: 6039,
name: "AmountCalcOverflow",
msg: "Amount calculated overflows"
},
{
code: 6040,
name: "AmountRemainingOverflow",
msg: "Amount remaining overflows"
}
];
var whirlpool_default = {
version,
name,
instructions,
accounts,
types,
errors
};
// src/network/public/fetcher.ts
var _tinyinvariant = require('tiny-invariant'); var _tinyinvariant2 = _interopRequireDefault(_tinyinvariant);
var _spltoken = require('@solana/spl-token');
// src/network/public/parsing.ts
var _web3js = require('@solana/web3.js');
// src/types/public/constants.ts
var ORCA_WHIRLPOOL_PROGRAM_ID = new (0, _web3js.PublicKey)(
"whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
);
var ORCA_WHIRLPOOLS_CONFIG = new (0, _web3js.PublicKey)("2LecshUwdy9xi7meFgHtFJQNSKk4KdTrcpvaB56dP2NQ");
var NUM_REWARDS = 3;
var MAX_TICK_INDEX = 443636;
var MIN_TICK_INDEX = -443636;
var MAX_SQRT_PRICE = "79226673515401279992447579055";
var MIN_SQRT_PRICE = "4295048016";
var TICK_ARRAY_SIZE = 88;
var METADATA_PROGRAM_ADDRESS = new (0, _web3js.PublicKey)(
"metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
);
var MAX_SWAP_TICK_ARRAYS = 3;
var PROTOCOL_FEE_RATE_MUL_VALUE = new (0, _anchor.BN)(1e4);
var FEE_RATE_MUL_VALUE = new (0, _anchor.BN)(1e6);
// src/types/public/anchor-types.ts
var AccountName = /* @__PURE__ */ ((AccountName2) => {
AccountName2["WhirlpoolsConfig"] = "WhirlpoolsConfig";
AccountName2["Position"] = "Position";
AccountName2["TickArray"] = "TickArray";
AccountName2["Whirlpool"] = "Whirlpool";
AccountName2["FeeTier"] = "FeeTier";
return AccountName2;
})(AccountName || {});
var IDL = whirlpool_default;
var WHIRLPOOL_CODER = new (0, _anchor.BorshAccountsCoder)(IDL);
var WHIRLPOOL_ACCOUNT_SIZE = WHIRLPOOL_CODER.size(IDL.accounts[4]);
// src/instructions/close-position-ix.ts
function closePositionIx(program, params) {
const {
positionAuthority,
receiver,
position,
positionMint,
positionTokenAccount
} = params;
const ix = program.instruction.closePosition({
accounts: {
positionAuthority,
receiver,
position,
positionMint,
positionTokenAccount,
tokenProgram: _spltoken.TOKEN_PROGRAM_ID
}
});
return {
instructions: [ix],
cleanupInstructions: [],
signers: []
};
}
// src/instructions/collect-fees-ix.ts
function collectFeesIx(program, params) {
const {
whirlpool,
positionAuthority,
position,
positionTokenAccount,
tokenOwnerAccountA,
tokenOwnerAccountB,
tokenVaultA,
tokenVaultB
} = params;
const ix = program.instruction.collectFees({
accounts: {
whirlpool,
positionAuthority,
position,
positionTokenAccount,
tokenOwnerAccountA,
tokenOwnerAccountB,
tokenVaultA,
tokenVaultB,
tokenProgram: _spltoken.TOKEN_PROGRAM_ID
}
});
return {
instructions: [ix],
cleanupInstructions: [],
signers: []
};
}
// src/instructions/collect-protocol-fees-ix.ts
function collectProtocolFeesIx(program, params) {
const {
whirlpoolsConfig,
whirlpool,
collectProtocolFeesAuthority,
tokenVaultA,
tokenVaultB,
tokenOwnerAccountA: tokenDestinationA,
tokenOwnerAccountB: tokenDestinationB
} = params;
const ix = program.instruction.collectProtocolFees({
accounts: {
whirlpoolsConfig,
whirlpool,
collectProtocolFeesAuthority,
tokenVaultA,
tokenVaultB,
tokenDestinationA,
tokenDestinationB,
tokenProgram: _spltoken.TOKEN_PROGRAM_ID
}
});
return {
instructions: [ix],
cleanupInstructions: [],
signers: []
};
}
// src/instructions/collect-reward-ix.ts
function collectRewardIx(program, params) {
const {
whirlpool,
positionAuthority,
position,
positionTokenAccount,
rewardOwnerAccount,
rewardVault,
rewardIndex
} = params;
const ix = program.instruction.collectReward(rewardIndex, {
accounts: {
whirlpool,
positionAuthority,
position,
positionTokenAccount,
rewardOwnerAccount,
rewardVault,
tokenProgram: _spltoken.TOKEN_PROGRAM_ID
}
});
return {
instructions: [ix],
cleanupInstructions: [],
signers: []
};
}
// src/instructions/composites/collect-all-txn.ts
var _commonsdk = require('@orca-so/common-sdk');
var _tokeninstructions = require('@orca-so/common-sdk/dist/helpers/token-instructions');
// src/ix.ts
var WhirlpoolIx = class {
static initializeConfigIx(program, params) {
return initializeConfigIx(program, params);
}
static initializeFeeTierIx(program, params) {
return initializeFeeTierIx(program, params);
}
static initializePoolIx(program, params) {
return initializePoolIx(program, params);
}
static initializeRewardIx(program, params) {
return initializeRewardIx(program, params);
}
static initTickArrayIx(program, params) {
return initTickArrayIx(program, params);
}
static openPositionIx(program, params) {
return openPositionIx(program, params);
}
static openPositionWithMetadataIx(program, params) {
return openPositionWithMetadataIx(program, params);
}
static increaseLiquidityIx(program, params) {
return increaseLiquidityIx(program, params);
}
static decreaseLiquidityIx(program, params) {
return decreaseLiquidityIx(program, params);
}
static closePositionIx(program, params) {
return closePositionIx(program, params);
}
static swapIx(program, params) {
return swapIx(program, params);
}
static updateFeesAndRewardsIx(program, params) {
return updateFeesAndRewardsIx(program, params);
}
static collectFeesIx(program, params) {
return collectFeesIx(program, params);
}
static collectProtocolFeesIx(program, params) {
return collectProtocolFeesIx(program, params);
}
static collectRewardIx(program, params) {
return collectRewardIx(program, params);
}
static setCollectProtocolFeesAuthorityIx(program, params) {
return setCollectProtocolFeesAuthorityIx(program, params);
}
static setDefaultFeeRateIx(program, params) {
return setDefaultFeeRateIx(program, params);
}
static setDefaultProtocolFeeRateIx(program, params) {
return setDefaultProtocolFeeRateIx(program, params);
}
static setFeeAuthorityIx(program, params) {
return setFeeAuthorityIx(program, params);
}
static setFeeRateIx(program, params) {
return setFeeRateIx(program, params);
}
static setProtocolFeeRateIx(program, params) {
return setProtocolFeeRateIx(program, params);
}
static setRewardAuthorityBySuperAuthorityIx(program, params) {
return setRewardAuthorityBySuperAuthorityIx(program, params);
}
static setRewardAuthorityIx(program, params) {
return setRewardAuthorityIx(program, params);
}
static setRewardEmissionsIx(program, params) {
return setRewardEmissionsIx(program, params);
}
static setRewardEmissionsSuperAuthorityIx(program, params) {
return setRewardEmissionsSuperAuthorityIx(program, params);
}
static collectAllForPositionsTxns(ctx, params, refresh) {
return collectAllForPositionAddressesTxns(ctx, params, refresh);
}
};
// src/utils/public/ix-utils.ts
function toTx(ctx, ix) {
return new (0, _commonsdk.TransactionBuilder)(ctx.provider.connection, ctx.provider.wallet).addInstruction(ix);
}
// src/utils/public/pda-utils.ts
// src/utils/public/price-math.ts
// src/utils/public/tick-utils.ts
var TickUtil = class {
constructor() {
}
static getOffsetIndex(tickIndex, arrayStartIndex, tickSpacing) {
return Math.floor((tickIndex - arrayStartIndex) / tickSpacing);
}
static getStartTickIndex(tickIndex, tickSpacing, offset = 0) {
const realIndex = Math.floor(tickIndex / tickSpacing / TICK_ARRAY_SIZE);
const startTickIndex = (realIndex + offset) * tickSpacing * TICK_ARRAY_SIZE;
const ticksInArray = TICK_ARRAY_SIZE * tickSpacing;
const minTickIndex = MIN_TICK_INDEX - (MIN_TICK_INDEX % ticksInArray + ticksInArray);
_tinyinvariant2.default.call(void 0, startTickIndex >= minTickIndex, `startTickIndex is too small - - ${startTickIndex}`);
_tinyinvariant2.default.call(void 0, startTickIndex <= MAX_TICK_INDEX, `startTickIndex is too large - ${startTickIndex}`);
return startTickIndex;
}
static getInitializableTickIndex(tickIndex, tickSpacing) {
return tickIndex - tickIndex % tickSpacing;
}
static getNextInitializableTickIndex(tickIndex, tickSpacing) {
return TickUtil.getInitializableTickIndex(tickIndex, tickSpacing) + tickSpacing;
}
static getPrevInitializableTickIndex(tickIndex, tickSpacing) {
return TickUtil.getInitializableTickIndex(tickIndex, tickSpacing) - tickSpacing;
}
static findPreviousInitializedTickIndex(account, currentTickIndex, tickSpacing) {
return TickUtil.findInitializedTick(
account,
currentTickIndex,
tickSpacing,
0 /* Left */
);
}
static findNextInitializedTickIndex(account, currentTickIndex, tickSpacing) {
return TickUtil.findInitializedTick(
account,
currentTickIndex,
tickSpacing,
1 /* Right */
);
}
static findInitializedTick(account, currentTickIndex, tickSpacing, searchDirection) {
var _a;
const currentTickArrayIndex = tickIndexToInnerIndex(
account.startTickIndex,
currentTickIndex,
tickSpacing
);
const increment = searchDirection === 1 /* Right */ ? 1 : -1;
let stepInitializedTickArrayIndex = searchDirection === 1 /* Right */ ? currentTickArrayIndex + increment : currentTickArrayIndex;
while (stepInitializedTickArrayIndex >= 0 && stepInitializedTickArrayIndex < account.ticks.length) {
if ((_a = account.ticks[stepInitializedTickArrayIndex]) == null ? void 0 : _a.initialized) {
return innerIndexToTickIndex(
account.startTickIndex,
stepInitializedTickArrayIndex,
tickSpacing
);
}
stepInitializedTickArrayIndex += increment;
}
return null;
}
static checkTickInBounds(tick) {
return tick <= MAX_TICK_INDEX && tick >= MIN_TICK_INDEX;
}
static isTickInitializable(tick, tickSpacing) {
return tick % tickSpacing === 0;
}
static invertTick(tick) {
return -tick;
}
};
var TickArrayUtil = class {
static getTickFromArray(tickArray, tickIndex, tickSpacing) {
const realIndex = tickIndexToInnerIndex(tickArray.startTickIndex, tickIndex, tickSpacing);
const tick = tickArray.ticks[realIndex];
_tinyinvariant2.default.call(void 0,
!!tick,
`tick realIndex out of range - start - ${tickArray.startTickIndex} index - ${tickIndex}, realIndex - ${realIndex}`
);
return tick;
}
static async getTickArrayPDAs(tick, tickSpacing, numOfTickArrays, programId, whirlpoolAddress, aToB) {
let arrayIndexList = [...Array(numOfTickArrays).keys()];
if (aToB) {
arrayIndexList = arrayIndexList.map((value) => -value);
}
return arrayIndexList.map((value) => {
const startTick = TickUtil.getStartTickIndex(tick, tickSpacing, value);
return PDAUtil.getTickArray(programId, whirlpoolAddress, startTick);
});
}
static async getUninitializedArraysPDAs(ticks, programId, whirlpoolAddress, tickSpacing, fetcher, refresh) {
const startTicks = ticks.map((tick) => TickUtil.getStartTickIndex(tick, tickSpacing));
const removeDupeTicks = [...new Set(startTicks)];
const tickArrayPDAs = removeDupeTicks.map(
(tick) => PDAUtil.getTickArray(programId, whirlpoolAddress, tick)
);
const fetchedArrays = await fetcher.listTickArrays(
tickArrayPDAs.map((pda) => pda.publicKey),
refresh
);
const uninitializedIndices = TickArrayUtil.getUninitializedArrays(fetchedArrays);
return uninitializedIndices.map((index) => {
return {
startIndex: removeDupeTicks[index],
pda: tickArrayPDAs[index]
};
});
}
static getUninitializedArrays(tickArrays) {
return tickArrays.map((value, index) => {
if (!value) {
return index;
}
return -1;
}).filter((index) => index >= 0);
}
};
function tickIndexToInnerIndex(startTickIndex, tickIndex, tickSpacing) {
return Math.floor((tickIndex - startTickIndex) / tickSpacing);
}
function innerIndexToTickIndex(startTickIndex, tickArrayIndex, tickSpacing) {
return startTickIndex + tickArrayIndex * tickSpacing;
}
// src/utils/public/price-math.ts
var BIT_PRECISION = 14;
var LOG_B_2_X32 = "59543866431248";
var LOG_B_P_ERR_MARGIN_LOWER_X64 = "184467440737095516";
var LOG_B_P_ERR_MARGIN_UPPER_X64 = "15793534762490258745";
var PriceMath = class {
static priceToSqrtPriceX64(price, decimalsA, decimalsB) {
return _commonsdk.MathUtil.toX64(price.mul(_decimaljs2.default.pow(10, decimalsB - decimalsA)).sqrt());
}
static sqrtPriceX64ToPrice(sqrtPriceX64, decimalsA, decimalsB) {
return _commonsdk.MathUtil.fromX64(sqrtPriceX64).pow(2).mul(_decimaljs2.default.pow(10, decimalsA - decimalsB));
}
static tickIndexToSqrtPriceX64(tickIndex) {
if (tickIndex > 0) {
return new (0, _anchor.BN)(tickIndexToSqrtPricePositive(tickIndex));
} else {
return new (0, _anchor.BN)(tickIndexToSqrtPriceNegative(tickIndex));
}
}
static sqrtPriceX64ToTickIndex(sqrtPriceX64) {
if (sqrtPriceX64.gt(new (0, _anchor.BN)(MAX_SQRT_PRICE)) || sqrtPriceX64.lt(new (0, _anchor.BN)(MIN_SQRT_PRICE))) {
throw new Error("Provided sqrtPrice is not within the supported sqrtPrice range.");
}
const msb = sqrtPriceX64.bitLength() - 1;
const adjustedMsb = new (0, _anchor.BN)(msb - 64);
const log2pIntegerX32 = signedShiftLeft(adjustedMsb, 32, 128);
let bit = new (0, _anchor.BN)("8000000000000000", "hex");
let precision = 0;
let log2pFractionX64 = new (0, _anchor.BN)(0);
let r = msb >= 64 ? sqrtPriceX64.shrn(msb - 63) : sqrtPriceX64.shln(63 - msb);
while (bit.gt(new (0, _anchor.BN)(0)) && precision < BIT_PRECISION) {
r = r.mul(r);
let rMoreThanTwo = r.shrn(127);
r = r.shrn(63 + rMoreThanTwo.toNumber());
log2pFractionX64 = log2pFractionX64.add(bit.mul(rMoreThanTwo));
bit = bit.shrn(1);
precision += 1;
}
const log2pFractionX32 = log2pFractionX64.shrn(32);
const log2pX32 = log2pIntegerX32.add(log2pFractionX32);
const logbpX64 = log2pX32.mul(new (0, _anchor.BN)(LOG_B_2_X32));
const tickLow = signedShiftRight(
logbpX64.sub(new (0, _anchor.BN)(LOG_B_P_ERR_MARGIN_LOWER_X64)),
64,
128
).toNumber();
const tickHigh = signedShiftRight(
logbpX64.add(new (0, _anchor.BN)(LOG_B_P_ERR_MARGIN_UPPER_X64)),
64,
128
).toNumber();
if (tickLow == tickHigh) {
return tickLow;
} else {
const derivedTickHighSqrtPriceX64 = PriceMath.tickIndexToSqrtPriceX64(tickHigh);
if (derivedTickHighSqrtPriceX64.lte(sqrtPriceX64)) {
return tickHigh;
} else {
return tickLow;
}
}
}
static tickIndexToPrice(tickIndex, decimalsA, decimalsB) {
return PriceMath.sqrtPriceX64ToPrice(
PriceMath.tickIndexToSqrtPriceX64(tickIndex),
decimalsA,
decimalsB
);
}
static priceToTickIndex(price, decimalsA, decimalsB) {
return PriceMath.sqrtPriceX64ToTickIndex(
PriceMath.priceToSqrtPriceX64(price, decimalsA, decimalsB)
);
}
static priceToInitializableTickIndex(price, decimalsA, decimalsB, tickSpacing) {
return TickUtil.getInitializableTickIndex(
PriceMath.priceToTickIndex(price, decimalsA, decimalsB),
tickSpacing
);
}
static invertPrice(price, decimalsA, decimalsB) {
const tick = PriceMath.priceToTickIndex(price, decimalsA, decimalsB);
const invTick = TickUtil.invertTick(tick);
return PriceMath.tickIndexToPrice(invTick, decimalsB, decimalsA);
}
static invertSqrtPriceX64(sqrtPriceX64) {
const tick = PriceMath.sqrtPriceX64ToTickIndex(sqrtPriceX64);
const invTick = TickUtil.invertTick(tick);
return PriceMath.tickIndexToSqrtPriceX64(invTick);
}
};
function tickIndexToSqrtPricePositive(tick) {
let ratio;
if ((tick & 1) != 0) {
ratio = new (0, _anchor.BN)("79232123823359799118286999567");
} else {
ratio = new (0, _anchor.BN)("79228162514264337593543950336");
}
if ((tick & 2) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79236085330515764027303304731")), 96, 256);
}
if ((tick & 4) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79244008939048815603706035061")), 96, 256);
}
if ((tick & 8) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79259858533276714757314932305")), 96, 256);
}
if ((tick & 16) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79291567232598584799939703904")), 96, 256);
}
if ((tick & 32) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79355022692464371645785046466")), 96, 256);
}
if ((tick & 64) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79482085999252804386437311141")), 96, 256);
}
if ((tick & 128) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("79736823300114093921829183326")), 96, 256);
}
if ((tick & 256) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("80248749790819932309965073892")), 96, 256);
}
if ((tick & 512) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("81282483887344747381513967011")), 96, 256);
}
if ((tick & 1024) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("83390072131320151908154831281")), 96, 256);
}
if ((tick & 2048) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("87770609709833776024991924138")), 96, 256);
}
if ((tick & 4096) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("97234110755111693312479820773")), 96, 256);
}
if ((tick & 8192) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("119332217159966728226237229890")), 96, 256);
}
if ((tick & 16384) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("179736315981702064433883588727")), 96, 256);
}
if ((tick & 32768) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("407748233172238350107850275304")), 96, 256);
}
if ((tick & 65536) != 0) {
ratio = signedShiftRight(ratio.mul(new (0, _anchor.BN)("2098478828474011932436660412517")), 96, 256);
}
if ((tick & 131072) != 0) {
ratio = signedShiftRight(ratio.mul(new (0,