@orca-so/whirlpools-client
Version:
Typescript client to interact with Orca's on-chain Whirlpool program.
1,533 lines (1,504 loc) • 494 kB
JavaScript
// src/generated/accounts/adaptiveFeeTier.ts
import {
assertAccountExists,
assertAccountsExist,
combineCodec,
decodeAccount,
fetchEncodedAccount,
fetchEncodedAccounts,
fixDecoderSize,
fixEncoderSize,
getAddressDecoder,
getAddressEncoder,
getBytesDecoder,
getBytesEncoder,
getStructDecoder,
getStructEncoder,
getU16Decoder,
getU16Encoder,
getU32Decoder,
getU32Encoder,
transformEncoder
} from "@solana/kit";
var ADAPTIVE_FEE_TIER_DISCRIMINATOR = new Uint8Array([
147,
16,
144,
116,
47,
146,
149,
46
]);
function getAdaptiveFeeTierDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
ADAPTIVE_FEE_TIER_DISCRIMINATOR
);
}
function getAdaptiveFeeTierEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["whirlpoolsConfig", getAddressEncoder()],
["feeTierIndex", getU16Encoder()],
["tickSpacing", getU16Encoder()],
["initializePoolAuthority", getAddressEncoder()],
["delegatedFeeAuthority", getAddressEncoder()],
["defaultBaseFeeRate", getU16Encoder()],
["filterPeriod", getU16Encoder()],
["decayPeriod", getU16Encoder()],
["reductionFactor", getU16Encoder()],
["adaptiveFeeControlFactor", getU32Encoder()],
["maxVolatilityAccumulator", getU32Encoder()],
["tickGroupSize", getU16Encoder()],
["majorSwapThresholdTicks", getU16Encoder()]
]),
(value) => ({ ...value, discriminator: ADAPTIVE_FEE_TIER_DISCRIMINATOR })
);
}
function getAdaptiveFeeTierDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["whirlpoolsConfig", getAddressDecoder()],
["feeTierIndex", getU16Decoder()],
["tickSpacing", getU16Decoder()],
["initializePoolAuthority", getAddressDecoder()],
["delegatedFeeAuthority", getAddressDecoder()],
["defaultBaseFeeRate", getU16Decoder()],
["filterPeriod", getU16Decoder()],
["decayPeriod", getU16Decoder()],
["reductionFactor", getU16Decoder()],
["adaptiveFeeControlFactor", getU32Decoder()],
["maxVolatilityAccumulator", getU32Decoder()],
["tickGroupSize", getU16Decoder()],
["majorSwapThresholdTicks", getU16Decoder()]
]);
}
function getAdaptiveFeeTierCodec() {
return combineCodec(getAdaptiveFeeTierEncoder(), getAdaptiveFeeTierDecoder());
}
function decodeAdaptiveFeeTier(encodedAccount) {
return decodeAccount(
encodedAccount,
getAdaptiveFeeTierDecoder()
);
}
async function fetchAdaptiveFeeTier(rpc, address, config) {
const maybeAccount = await fetchMaybeAdaptiveFeeTier(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAdaptiveFeeTier(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAdaptiveFeeTier(maybeAccount);
}
async function fetchAllAdaptiveFeeTier(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAdaptiveFeeTier(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAdaptiveFeeTier(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeAdaptiveFeeTier(maybeAccount)
);
}
function getAdaptiveFeeTierSize() {
return 128;
}
// src/generated/accounts/dynamicTickArray.ts
import {
assertAccountExists as assertAccountExists2,
assertAccountsExist as assertAccountsExist2,
combineCodec as combineCodec24,
decodeAccount as decodeAccount2,
fetchEncodedAccount as fetchEncodedAccount2,
fetchEncodedAccounts as fetchEncodedAccounts2,
fixDecoderSize as fixDecoderSize5,
fixEncoderSize as fixEncoderSize5,
getAddressDecoder as getAddressDecoder9,
getAddressEncoder as getAddressEncoder9,
getArrayDecoder as getArrayDecoder4,
getArrayEncoder as getArrayEncoder4,
getBytesDecoder as getBytesDecoder5,
getBytesEncoder as getBytesEncoder5,
getI32Decoder as getI32Decoder6,
getI32Encoder as getI32Encoder6,
getStructDecoder as getStructDecoder21,
getStructEncoder as getStructEncoder21,
getU128Decoder as getU128Decoder12,
getU128Encoder as getU128Encoder12,
transformEncoder as transformEncoder2
} from "@solana/kit";
// src/generated/types/accountsType.ts
import {
combineCodec as combineCodec2,
getEnumDecoder,
getEnumEncoder
} from "@solana/kit";
var AccountsType = /* @__PURE__ */ ((AccountsType2) => {
AccountsType2[AccountsType2["TransferHookA"] = 0] = "TransferHookA";
AccountsType2[AccountsType2["TransferHookB"] = 1] = "TransferHookB";
AccountsType2[AccountsType2["TransferHookReward"] = 2] = "TransferHookReward";
AccountsType2[AccountsType2["TransferHookInput"] = 3] = "TransferHookInput";
AccountsType2[AccountsType2["TransferHookIntermediate"] = 4] = "TransferHookIntermediate";
AccountsType2[AccountsType2["TransferHookOutput"] = 5] = "TransferHookOutput";
AccountsType2[AccountsType2["SupplementalTickArrays"] = 6] = "SupplementalTickArrays";
AccountsType2[AccountsType2["SupplementalTickArraysOne"] = 7] = "SupplementalTickArraysOne";
AccountsType2[AccountsType2["SupplementalTickArraysTwo"] = 8] = "SupplementalTickArraysTwo";
AccountsType2[AccountsType2["TransferHookDepositA"] = 9] = "TransferHookDepositA";
AccountsType2[AccountsType2["TransferHookDepositB"] = 10] = "TransferHookDepositB";
AccountsType2[AccountsType2["TransferHookWithdrawalA"] = 11] = "TransferHookWithdrawalA";
AccountsType2[AccountsType2["TransferHookWithdrawalB"] = 12] = "TransferHookWithdrawalB";
return AccountsType2;
})(AccountsType || {});
function getAccountsTypeEncoder() {
return getEnumEncoder(AccountsType);
}
function getAccountsTypeDecoder() {
return getEnumDecoder(AccountsType);
}
function getAccountsTypeCodec() {
return combineCodec2(getAccountsTypeEncoder(), getAccountsTypeDecoder());
}
// src/generated/types/adaptiveFeeConstants.ts
import {
combineCodec as combineCodec3,
fixDecoderSize as fixDecoderSize2,
fixEncoderSize as fixEncoderSize2,
getBytesDecoder as getBytesDecoder2,
getBytesEncoder as getBytesEncoder2,
getStructDecoder as getStructDecoder2,
getStructEncoder as getStructEncoder2,
getU16Decoder as getU16Decoder2,
getU16Encoder as getU16Encoder2,
getU32Decoder as getU32Decoder2,
getU32Encoder as getU32Encoder2
} from "@solana/kit";
function getAdaptiveFeeConstantsEncoder() {
return getStructEncoder2([
["filterPeriod", getU16Encoder2()],
["decayPeriod", getU16Encoder2()],
["reductionFactor", getU16Encoder2()],
["adaptiveFeeControlFactor", getU32Encoder2()],
["maxVolatilityAccumulator", getU32Encoder2()],
["tickGroupSize", getU16Encoder2()],
["majorSwapThresholdTicks", getU16Encoder2()],
["reserved", fixEncoderSize2(getBytesEncoder2(), 16)]
]);
}
function getAdaptiveFeeConstantsDecoder() {
return getStructDecoder2([
["filterPeriod", getU16Decoder2()],
["decayPeriod", getU16Decoder2()],
["reductionFactor", getU16Decoder2()],
["adaptiveFeeControlFactor", getU32Decoder2()],
["maxVolatilityAccumulator", getU32Decoder2()],
["tickGroupSize", getU16Decoder2()],
["majorSwapThresholdTicks", getU16Decoder2()],
["reserved", fixDecoderSize2(getBytesDecoder2(), 16)]
]);
}
function getAdaptiveFeeConstantsCodec() {
return combineCodec3(
getAdaptiveFeeConstantsEncoder(),
getAdaptiveFeeConstantsDecoder()
);
}
// src/generated/types/adaptiveFeeVariables.ts
import {
combineCodec as combineCodec4,
fixDecoderSize as fixDecoderSize3,
fixEncoderSize as fixEncoderSize3,
getBytesDecoder as getBytesDecoder3,
getBytesEncoder as getBytesEncoder3,
getI32Decoder,
getI32Encoder,
getStructDecoder as getStructDecoder3,
getStructEncoder as getStructEncoder3,
getU32Decoder as getU32Decoder3,
getU32Encoder as getU32Encoder3,
getU64Decoder,
getU64Encoder
} from "@solana/kit";
function getAdaptiveFeeVariablesEncoder() {
return getStructEncoder3([
["lastReferenceUpdateTimestamp", getU64Encoder()],
["lastMajorSwapTimestamp", getU64Encoder()],
["volatilityReference", getU32Encoder3()],
["tickGroupIndexReference", getI32Encoder()],
["volatilityAccumulator", getU32Encoder3()],
["reserved", fixEncoderSize3(getBytesEncoder3(), 16)]
]);
}
function getAdaptiveFeeVariablesDecoder() {
return getStructDecoder3([
["lastReferenceUpdateTimestamp", getU64Decoder()],
["lastMajorSwapTimestamp", getU64Decoder()],
["volatilityReference", getU32Decoder3()],
["tickGroupIndexReference", getI32Decoder()],
["volatilityAccumulator", getU32Decoder3()],
["reserved", fixDecoderSize3(getBytesDecoder3(), 16)]
]);
}
function getAdaptiveFeeVariablesCodec() {
return combineCodec4(
getAdaptiveFeeVariablesEncoder(),
getAdaptiveFeeVariablesDecoder()
);
}
// src/generated/types/configFeatureFlag.ts
import {
combineCodec as combineCodec5,
getBooleanDecoder,
getBooleanEncoder,
getDiscriminatedUnionDecoder,
getDiscriminatedUnionEncoder,
getStructDecoder as getStructDecoder4,
getStructEncoder as getStructEncoder4,
getTupleDecoder,
getTupleEncoder
} from "@solana/kit";
function getConfigFeatureFlagEncoder() {
return getDiscriminatedUnionEncoder([
[
"TokenBadge",
getStructEncoder4([["fields", getTupleEncoder([getBooleanEncoder()])]])
]
]);
}
function getConfigFeatureFlagDecoder() {
return getDiscriminatedUnionDecoder([
[
"TokenBadge",
getStructDecoder4([["fields", getTupleDecoder([getBooleanDecoder()])]])
]
]);
}
function getConfigFeatureFlagCodec() {
return combineCodec5(
getConfigFeatureFlagEncoder(),
getConfigFeatureFlagDecoder()
);
}
function configFeatureFlag(kind, data) {
return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
}
function isConfigFeatureFlag(kind, value) {
return value.__kind === kind;
}
// src/generated/types/dynamicTick.ts
import {
combineCodec as combineCodec6,
getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder2,
getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder2,
getStructDecoder as getStructDecoder5,
getStructEncoder as getStructEncoder5,
getTupleDecoder as getTupleDecoder2,
getTupleEncoder as getTupleEncoder2,
getUnitDecoder,
getUnitEncoder
} from "@solana/kit";
function getDynamicTickEncoder() {
return getDiscriminatedUnionEncoder2([
["Uninitialized", getUnitEncoder()],
[
"Initialized",
getStructEncoder5([
["fields", getTupleEncoder2([getDynamicTickDataEncoder()])]
])
]
]);
}
function getDynamicTickDecoder() {
return getDiscriminatedUnionDecoder2([
["Uninitialized", getUnitDecoder()],
[
"Initialized",
getStructDecoder5([
["fields", getTupleDecoder2([getDynamicTickDataDecoder()])]
])
]
]);
}
function getDynamicTickCodec() {
return combineCodec6(getDynamicTickEncoder(), getDynamicTickDecoder());
}
function dynamicTick(kind, data) {
return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
}
function isDynamicTick(kind, value) {
return value.__kind === kind;
}
// src/generated/types/dynamicTickData.ts
import {
combineCodec as combineCodec7,
getArrayDecoder,
getArrayEncoder,
getI128Decoder,
getI128Encoder,
getStructDecoder as getStructDecoder6,
getStructEncoder as getStructEncoder6,
getU128Decoder,
getU128Encoder
} from "@solana/kit";
function getDynamicTickDataEncoder() {
return getStructEncoder6([
["liquidityNet", getI128Encoder()],
["liquidityGross", getU128Encoder()],
["feeGrowthOutsideA", getU128Encoder()],
["feeGrowthOutsideB", getU128Encoder()],
["rewardGrowthsOutside", getArrayEncoder(getU128Encoder(), { size: 3 })]
]);
}
function getDynamicTickDataDecoder() {
return getStructDecoder6([
["liquidityNet", getI128Decoder()],
["liquidityGross", getU128Decoder()],
["feeGrowthOutsideA", getU128Decoder()],
["feeGrowthOutsideB", getU128Decoder()],
["rewardGrowthsOutside", getArrayDecoder(getU128Decoder(), { size: 3 })]
]);
}
function getDynamicTickDataCodec() {
return combineCodec7(getDynamicTickDataEncoder(), getDynamicTickDataDecoder());
}
// src/generated/types/increaseLiquidityMethod.ts
import {
combineCodec as combineCodec8,
getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder3,
getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder3,
getStructDecoder as getStructDecoder7,
getStructEncoder as getStructEncoder7,
getU128Decoder as getU128Decoder2,
getU128Encoder as getU128Encoder2,
getU64Decoder as getU64Decoder2,
getU64Encoder as getU64Encoder2
} from "@solana/kit";
function getIncreaseLiquidityMethodEncoder() {
return getDiscriminatedUnionEncoder3([
[
"ByTokenAmounts",
getStructEncoder7([
["tokenMaxA", getU64Encoder2()],
["tokenMaxB", getU64Encoder2()],
["minSqrtPrice", getU128Encoder2()],
["maxSqrtPrice", getU128Encoder2()]
])
]
]);
}
function getIncreaseLiquidityMethodDecoder() {
return getDiscriminatedUnionDecoder3([
[
"ByTokenAmounts",
getStructDecoder7([
["tokenMaxA", getU64Decoder2()],
["tokenMaxB", getU64Decoder2()],
["minSqrtPrice", getU128Decoder2()],
["maxSqrtPrice", getU128Decoder2()]
])
]
]);
}
function getIncreaseLiquidityMethodCodec() {
return combineCodec8(
getIncreaseLiquidityMethodEncoder(),
getIncreaseLiquidityMethodDecoder()
);
}
function increaseLiquidityMethod(kind, data) {
return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
}
function isIncreaseLiquidityMethod(kind, value) {
return value.__kind === kind;
}
// src/generated/types/liquidityDecreased.ts
import {
combineCodec as combineCodec9,
getAddressDecoder as getAddressDecoder2,
getAddressEncoder as getAddressEncoder2,
getI32Decoder as getI32Decoder2,
getI32Encoder as getI32Encoder2,
getStructDecoder as getStructDecoder8,
getStructEncoder as getStructEncoder8,
getU128Decoder as getU128Decoder3,
getU128Encoder as getU128Encoder3,
getU64Decoder as getU64Decoder3,
getU64Encoder as getU64Encoder3
} from "@solana/kit";
function getLiquidityDecreasedEncoder() {
return getStructEncoder8([
["whirlpool", getAddressEncoder2()],
["position", getAddressEncoder2()],
["tickLowerIndex", getI32Encoder2()],
["tickUpperIndex", getI32Encoder2()],
["liquidity", getU128Encoder3()],
["tokenAAmount", getU64Encoder3()],
["tokenBAmount", getU64Encoder3()],
["tokenATransferFee", getU64Encoder3()],
["tokenBTransferFee", getU64Encoder3()]
]);
}
function getLiquidityDecreasedDecoder() {
return getStructDecoder8([
["whirlpool", getAddressDecoder2()],
["position", getAddressDecoder2()],
["tickLowerIndex", getI32Decoder2()],
["tickUpperIndex", getI32Decoder2()],
["liquidity", getU128Decoder3()],
["tokenAAmount", getU64Decoder3()],
["tokenBAmount", getU64Decoder3()],
["tokenATransferFee", getU64Decoder3()],
["tokenBTransferFee", getU64Decoder3()]
]);
}
function getLiquidityDecreasedCodec() {
return combineCodec9(
getLiquidityDecreasedEncoder(),
getLiquidityDecreasedDecoder()
);
}
// src/generated/types/liquidityIncreased.ts
import {
combineCodec as combineCodec10,
getAddressDecoder as getAddressDecoder3,
getAddressEncoder as getAddressEncoder3,
getI32Decoder as getI32Decoder3,
getI32Encoder as getI32Encoder3,
getStructDecoder as getStructDecoder9,
getStructEncoder as getStructEncoder9,
getU128Decoder as getU128Decoder4,
getU128Encoder as getU128Encoder4,
getU64Decoder as getU64Decoder4,
getU64Encoder as getU64Encoder4
} from "@solana/kit";
function getLiquidityIncreasedEncoder() {
return getStructEncoder9([
["whirlpool", getAddressEncoder3()],
["position", getAddressEncoder3()],
["tickLowerIndex", getI32Encoder3()],
["tickUpperIndex", getI32Encoder3()],
["liquidity", getU128Encoder4()],
["tokenAAmount", getU64Encoder4()],
["tokenBAmount", getU64Encoder4()],
["tokenATransferFee", getU64Encoder4()],
["tokenBTransferFee", getU64Encoder4()]
]);
}
function getLiquidityIncreasedDecoder() {
return getStructDecoder9([
["whirlpool", getAddressDecoder3()],
["position", getAddressDecoder3()],
["tickLowerIndex", getI32Decoder3()],
["tickUpperIndex", getI32Decoder3()],
["liquidity", getU128Decoder4()],
["tokenAAmount", getU64Decoder4()],
["tokenBAmount", getU64Decoder4()],
["tokenATransferFee", getU64Decoder4()],
["tokenBTransferFee", getU64Decoder4()]
]);
}
function getLiquidityIncreasedCodec() {
return combineCodec10(
getLiquidityIncreasedEncoder(),
getLiquidityIncreasedDecoder()
);
}
// src/generated/types/liquidityRepositioned.ts
import {
combineCodec as combineCodec11,
getAddressDecoder as getAddressDecoder4,
getAddressEncoder as getAddressEncoder4,
getBooleanDecoder as getBooleanDecoder2,
getBooleanEncoder as getBooleanEncoder2,
getI32Decoder as getI32Decoder4,
getI32Encoder as getI32Encoder4,
getStructDecoder as getStructDecoder10,
getStructEncoder as getStructEncoder10,
getU128Decoder as getU128Decoder5,
getU128Encoder as getU128Encoder5,
getU64Decoder as getU64Decoder5,
getU64Encoder as getU64Encoder5
} from "@solana/kit";
function getLiquidityRepositionedEncoder() {
return getStructEncoder10([
["whirlpool", getAddressEncoder4()],
["position", getAddressEncoder4()],
["existingRangeTickLowerIndex", getI32Encoder4()],
["existingRangeTickUpperIndex", getI32Encoder4()],
["newRangeTickLowerIndex", getI32Encoder4()],
["newRangeTickUpperIndex", getI32Encoder4()],
["existingRangeLiquidity", getU128Encoder5()],
["newRangeLiquidity", getU128Encoder5()],
["existingRangeTokenAAmount", getU64Encoder5()],
["existingRangeTokenBAmount", getU64Encoder5()],
["newRangeTokenAAmount", getU64Encoder5()],
["newRangeTokenBAmount", getU64Encoder5()],
["tokenATransferAmount", getU64Encoder5()],
["tokenATransferFee", getU64Encoder5()],
["isTokenATransferFromOwner", getBooleanEncoder2()],
["tokenBTransferAmount", getU64Encoder5()],
["tokenBTransferFee", getU64Encoder5()],
["isTokenBTransferFromOwner", getBooleanEncoder2()]
]);
}
function getLiquidityRepositionedDecoder() {
return getStructDecoder10([
["whirlpool", getAddressDecoder4()],
["position", getAddressDecoder4()],
["existingRangeTickLowerIndex", getI32Decoder4()],
["existingRangeTickUpperIndex", getI32Decoder4()],
["newRangeTickLowerIndex", getI32Decoder4()],
["newRangeTickUpperIndex", getI32Decoder4()],
["existingRangeLiquidity", getU128Decoder5()],
["newRangeLiquidity", getU128Decoder5()],
["existingRangeTokenAAmount", getU64Decoder5()],
["existingRangeTokenBAmount", getU64Decoder5()],
["newRangeTokenAAmount", getU64Decoder5()],
["newRangeTokenBAmount", getU64Decoder5()],
["tokenATransferAmount", getU64Decoder5()],
["tokenATransferFee", getU64Decoder5()],
["isTokenATransferFromOwner", getBooleanDecoder2()],
["tokenBTransferAmount", getU64Decoder5()],
["tokenBTransferFee", getU64Decoder5()],
["isTokenBTransferFromOwner", getBooleanDecoder2()]
]);
}
function getLiquidityRepositionedCodec() {
return combineCodec11(
getLiquidityRepositionedEncoder(),
getLiquidityRepositionedDecoder()
);
}
// src/generated/types/lockType.ts
import {
combineCodec as combineCodec12,
getEnumDecoder as getEnumDecoder2,
getEnumEncoder as getEnumEncoder2
} from "@solana/kit";
var LockType = /* @__PURE__ */ ((LockType2) => {
LockType2[LockType2["Permanent"] = 0] = "Permanent";
return LockType2;
})(LockType || {});
function getLockTypeEncoder() {
return getEnumEncoder2(LockType);
}
function getLockTypeDecoder() {
return getEnumDecoder2(LockType);
}
function getLockTypeCodec() {
return combineCodec12(getLockTypeEncoder(), getLockTypeDecoder());
}
// src/generated/types/lockTypeLabel.ts
import {
combineCodec as combineCodec13,
getEnumDecoder as getEnumDecoder3,
getEnumEncoder as getEnumEncoder3
} from "@solana/kit";
var LockTypeLabel = /* @__PURE__ */ ((LockTypeLabel2) => {
LockTypeLabel2[LockTypeLabel2["Permanent"] = 0] = "Permanent";
return LockTypeLabel2;
})(LockTypeLabel || {});
function getLockTypeLabelEncoder() {
return getEnumEncoder3(LockTypeLabel);
}
function getLockTypeLabelDecoder() {
return getEnumDecoder3(LockTypeLabel);
}
function getLockTypeLabelCodec() {
return combineCodec13(getLockTypeLabelEncoder(), getLockTypeLabelDecoder());
}
// src/generated/types/poolInitialized.ts
import {
combineCodec as combineCodec14,
getAddressDecoder as getAddressDecoder5,
getAddressEncoder as getAddressEncoder5,
getStructDecoder as getStructDecoder11,
getStructEncoder as getStructEncoder11,
getU128Decoder as getU128Decoder6,
getU128Encoder as getU128Encoder6,
getU16Decoder as getU16Decoder3,
getU16Encoder as getU16Encoder3,
getU8Decoder,
getU8Encoder
} from "@solana/kit";
function getPoolInitializedEncoder() {
return getStructEncoder11([
["whirlpool", getAddressEncoder5()],
["whirlpoolsConfig", getAddressEncoder5()],
["tokenMintA", getAddressEncoder5()],
["tokenMintB", getAddressEncoder5()],
["tickSpacing", getU16Encoder3()],
["tokenProgramA", getAddressEncoder5()],
["tokenProgramB", getAddressEncoder5()],
["decimalsA", getU8Encoder()],
["decimalsB", getU8Encoder()],
["initialSqrtPrice", getU128Encoder6()]
]);
}
function getPoolInitializedDecoder() {
return getStructDecoder11([
["whirlpool", getAddressDecoder5()],
["whirlpoolsConfig", getAddressDecoder5()],
["tokenMintA", getAddressDecoder5()],
["tokenMintB", getAddressDecoder5()],
["tickSpacing", getU16Decoder3()],
["tokenProgramA", getAddressDecoder5()],
["tokenProgramB", getAddressDecoder5()],
["decimalsA", getU8Decoder()],
["decimalsB", getU8Decoder()],
["initialSqrtPrice", getU128Decoder6()]
]);
}
function getPoolInitializedCodec() {
return combineCodec14(getPoolInitializedEncoder(), getPoolInitializedDecoder());
}
// src/generated/types/positionOpened.ts
import {
combineCodec as combineCodec15,
getAddressDecoder as getAddressDecoder6,
getAddressEncoder as getAddressEncoder6,
getI32Decoder as getI32Decoder5,
getI32Encoder as getI32Encoder5,
getStructDecoder as getStructDecoder12,
getStructEncoder as getStructEncoder12
} from "@solana/kit";
function getPositionOpenedEncoder() {
return getStructEncoder12([
["whirlpool", getAddressEncoder6()],
["position", getAddressEncoder6()],
["tickLowerIndex", getI32Encoder5()],
["tickUpperIndex", getI32Encoder5()]
]);
}
function getPositionOpenedDecoder() {
return getStructDecoder12([
["whirlpool", getAddressDecoder6()],
["position", getAddressDecoder6()],
["tickLowerIndex", getI32Decoder5()],
["tickUpperIndex", getI32Decoder5()]
]);
}
function getPositionOpenedCodec() {
return combineCodec15(getPositionOpenedEncoder(), getPositionOpenedDecoder());
}
// src/generated/types/positionRewardInfo.ts
import {
combineCodec as combineCodec16,
getStructDecoder as getStructDecoder13,
getStructEncoder as getStructEncoder13,
getU128Decoder as getU128Decoder7,
getU128Encoder as getU128Encoder7,
getU64Decoder as getU64Decoder6,
getU64Encoder as getU64Encoder6
} from "@solana/kit";
function getPositionRewardInfoEncoder() {
return getStructEncoder13([
["growthInsideCheckpoint", getU128Encoder7()],
["amountOwed", getU64Encoder6()]
]);
}
function getPositionRewardInfoDecoder() {
return getStructDecoder13([
["growthInsideCheckpoint", getU128Decoder7()],
["amountOwed", getU64Decoder6()]
]);
}
function getPositionRewardInfoCodec() {
return combineCodec16(
getPositionRewardInfoEncoder(),
getPositionRewardInfoDecoder()
);
}
// src/generated/types/remainingAccountsInfo.ts
import {
combineCodec as combineCodec17,
getArrayDecoder as getArrayDecoder2,
getArrayEncoder as getArrayEncoder2,
getStructDecoder as getStructDecoder14,
getStructEncoder as getStructEncoder14
} from "@solana/kit";
function getRemainingAccountsInfoEncoder() {
return getStructEncoder14([
["slices", getArrayEncoder2(getRemainingAccountsSliceEncoder())]
]);
}
function getRemainingAccountsInfoDecoder() {
return getStructDecoder14([
["slices", getArrayDecoder2(getRemainingAccountsSliceDecoder())]
]);
}
function getRemainingAccountsInfoCodec() {
return combineCodec17(
getRemainingAccountsInfoEncoder(),
getRemainingAccountsInfoDecoder()
);
}
// src/generated/types/remainingAccountsSlice.ts
import {
combineCodec as combineCodec18,
getStructDecoder as getStructDecoder15,
getStructEncoder as getStructEncoder15,
getU8Decoder as getU8Decoder2,
getU8Encoder as getU8Encoder2
} from "@solana/kit";
function getRemainingAccountsSliceEncoder() {
return getStructEncoder15([
["accountsType", getAccountsTypeEncoder()],
["length", getU8Encoder2()]
]);
}
function getRemainingAccountsSliceDecoder() {
return getStructDecoder15([
["accountsType", getAccountsTypeDecoder()],
["length", getU8Decoder2()]
]);
}
function getRemainingAccountsSliceCodec() {
return combineCodec18(
getRemainingAccountsSliceEncoder(),
getRemainingAccountsSliceDecoder()
);
}
// src/generated/types/repositionLiquidityMethod.ts
import {
combineCodec as combineCodec19,
getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder4,
getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder4,
getStructDecoder as getStructDecoder16,
getStructEncoder as getStructEncoder16,
getU128Decoder as getU128Decoder8,
getU128Encoder as getU128Encoder8,
getU64Decoder as getU64Decoder7,
getU64Encoder as getU64Encoder7
} from "@solana/kit";
function getRepositionLiquidityMethodEncoder() {
return getDiscriminatedUnionEncoder4([
[
"ByLiquidity",
getStructEncoder16([
["newLiquidityAmount", getU128Encoder8()],
["existingRangeTokenMinA", getU64Encoder7()],
["existingRangeTokenMinB", getU64Encoder7()],
["newRangeTokenMaxA", getU64Encoder7()],
["newRangeTokenMaxB", getU64Encoder7()]
])
]
]);
}
function getRepositionLiquidityMethodDecoder() {
return getDiscriminatedUnionDecoder4([
[
"ByLiquidity",
getStructDecoder16([
["newLiquidityAmount", getU128Decoder8()],
["existingRangeTokenMinA", getU64Decoder7()],
["existingRangeTokenMinB", getU64Decoder7()],
["newRangeTokenMaxA", getU64Decoder7()],
["newRangeTokenMaxB", getU64Decoder7()]
])
]
]);
}
function getRepositionLiquidityMethodCodec() {
return combineCodec19(
getRepositionLiquidityMethodEncoder(),
getRepositionLiquidityMethodDecoder()
);
}
function repositionLiquidityMethod(kind, data) {
return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
}
function isRepositionLiquidityMethod(kind, value) {
return value.__kind === kind;
}
// src/generated/types/tick.ts
import {
combineCodec as combineCodec20,
getArrayDecoder as getArrayDecoder3,
getArrayEncoder as getArrayEncoder3,
getBooleanDecoder as getBooleanDecoder3,
getBooleanEncoder as getBooleanEncoder3,
getI128Decoder as getI128Decoder2,
getI128Encoder as getI128Encoder2,
getStructDecoder as getStructDecoder17,
getStructEncoder as getStructEncoder17,
getU128Decoder as getU128Decoder9,
getU128Encoder as getU128Encoder9
} from "@solana/kit";
function getTickEncoder() {
return getStructEncoder17([
["initialized", getBooleanEncoder3()],
["liquidityNet", getI128Encoder2()],
["liquidityGross", getU128Encoder9()],
["feeGrowthOutsideA", getU128Encoder9()],
["feeGrowthOutsideB", getU128Encoder9()],
["rewardGrowthsOutside", getArrayEncoder3(getU128Encoder9(), { size: 3 })]
]);
}
function getTickDecoder() {
return getStructDecoder17([
["initialized", getBooleanDecoder3()],
["liquidityNet", getI128Decoder2()],
["liquidityGross", getU128Decoder9()],
["feeGrowthOutsideA", getU128Decoder9()],
["feeGrowthOutsideB", getU128Decoder9()],
["rewardGrowthsOutside", getArrayDecoder3(getU128Decoder9(), { size: 3 })]
]);
}
function getTickCodec() {
return combineCodec20(getTickEncoder(), getTickDecoder());
}
// src/generated/types/tokenBadgeAttribute.ts
import {
combineCodec as combineCodec21,
getBooleanDecoder as getBooleanDecoder4,
getBooleanEncoder as getBooleanEncoder4,
getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder5,
getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder5,
getStructDecoder as getStructDecoder18,
getStructEncoder as getStructEncoder18,
getTupleDecoder as getTupleDecoder3,
getTupleEncoder as getTupleEncoder3
} from "@solana/kit";
function getTokenBadgeAttributeEncoder() {
return getDiscriminatedUnionEncoder5([
[
"RequireNonTransferablePosition",
getStructEncoder18([["fields", getTupleEncoder3([getBooleanEncoder4()])]])
]
]);
}
function getTokenBadgeAttributeDecoder() {
return getDiscriminatedUnionDecoder5([
[
"RequireNonTransferablePosition",
getStructDecoder18([["fields", getTupleDecoder3([getBooleanDecoder4()])]])
]
]);
}
function getTokenBadgeAttributeCodec() {
return combineCodec21(
getTokenBadgeAttributeEncoder(),
getTokenBadgeAttributeDecoder()
);
}
function tokenBadgeAttribute(kind, data) {
return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...data ?? {} };
}
function isTokenBadgeAttribute(kind, value) {
return value.__kind === kind;
}
// src/generated/types/traded.ts
import {
combineCodec as combineCodec22,
getAddressDecoder as getAddressDecoder7,
getAddressEncoder as getAddressEncoder7,
getBooleanDecoder as getBooleanDecoder5,
getBooleanEncoder as getBooleanEncoder5,
getStructDecoder as getStructDecoder19,
getStructEncoder as getStructEncoder19,
getU128Decoder as getU128Decoder10,
getU128Encoder as getU128Encoder10,
getU64Decoder as getU64Decoder8,
getU64Encoder as getU64Encoder8
} from "@solana/kit";
function getTradedEncoder() {
return getStructEncoder19([
["whirlpool", getAddressEncoder7()],
["aToB", getBooleanEncoder5()],
["preSqrtPrice", getU128Encoder10()],
["postSqrtPrice", getU128Encoder10()],
["inputAmount", getU64Encoder8()],
["outputAmount", getU64Encoder8()],
["inputTransferFee", getU64Encoder8()],
["outputTransferFee", getU64Encoder8()],
["lpFee", getU64Encoder8()],
["protocolFee", getU64Encoder8()]
]);
}
function getTradedDecoder() {
return getStructDecoder19([
["whirlpool", getAddressDecoder7()],
["aToB", getBooleanDecoder5()],
["preSqrtPrice", getU128Decoder10()],
["postSqrtPrice", getU128Decoder10()],
["inputAmount", getU64Decoder8()],
["outputAmount", getU64Decoder8()],
["inputTransferFee", getU64Decoder8()],
["outputTransferFee", getU64Decoder8()],
["lpFee", getU64Decoder8()],
["protocolFee", getU64Decoder8()]
]);
}
function getTradedCodec() {
return combineCodec22(getTradedEncoder(), getTradedDecoder());
}
// src/generated/types/whirlpoolRewardInfo.ts
import {
combineCodec as combineCodec23,
fixDecoderSize as fixDecoderSize4,
fixEncoderSize as fixEncoderSize4,
getAddressDecoder as getAddressDecoder8,
getAddressEncoder as getAddressEncoder8,
getBytesDecoder as getBytesDecoder4,
getBytesEncoder as getBytesEncoder4,
getStructDecoder as getStructDecoder20,
getStructEncoder as getStructEncoder20,
getU128Decoder as getU128Decoder11,
getU128Encoder as getU128Encoder11
} from "@solana/kit";
function getWhirlpoolRewardInfoEncoder() {
return getStructEncoder20([
["mint", getAddressEncoder8()],
["vault", getAddressEncoder8()],
["extension", fixEncoderSize4(getBytesEncoder4(), 32)],
["emissionsPerSecondX64", getU128Encoder11()],
["growthGlobalX64", getU128Encoder11()]
]);
}
function getWhirlpoolRewardInfoDecoder() {
return getStructDecoder20([
["mint", getAddressDecoder8()],
["vault", getAddressDecoder8()],
["extension", fixDecoderSize4(getBytesDecoder4(), 32)],
["emissionsPerSecondX64", getU128Decoder11()],
["growthGlobalX64", getU128Decoder11()]
]);
}
function getWhirlpoolRewardInfoCodec() {
return combineCodec23(
getWhirlpoolRewardInfoEncoder(),
getWhirlpoolRewardInfoDecoder()
);
}
// src/generated/accounts/dynamicTickArray.ts
var DYNAMIC_TICK_ARRAY_DISCRIMINATOR = new Uint8Array([
17,
216,
246,
142,
225,
199,
218,
56
]);
function getDynamicTickArrayDiscriminatorBytes() {
return fixEncoderSize5(getBytesEncoder5(), 8).encode(
DYNAMIC_TICK_ARRAY_DISCRIMINATOR
);
}
function getDynamicTickArrayEncoder() {
return transformEncoder2(
getStructEncoder21([
["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
["startTickIndex", getI32Encoder6()],
["whirlpool", getAddressEncoder9()],
["tickBitmap", getU128Encoder12()],
["ticks", getArrayEncoder4(getDynamicTickEncoder(), { size: 88 })]
]),
(value) => ({ ...value, discriminator: DYNAMIC_TICK_ARRAY_DISCRIMINATOR })
);
}
function getDynamicTickArrayDecoder() {
return getStructDecoder21([
["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
["startTickIndex", getI32Decoder6()],
["whirlpool", getAddressDecoder9()],
["tickBitmap", getU128Decoder12()],
["ticks", getArrayDecoder4(getDynamicTickDecoder(), { size: 88 })]
]);
}
function getDynamicTickArrayCodec() {
return combineCodec24(
getDynamicTickArrayEncoder(),
getDynamicTickArrayDecoder()
);
}
function decodeDynamicTickArray(encodedAccount) {
return decodeAccount2(
encodedAccount,
getDynamicTickArrayDecoder()
);
}
async function fetchDynamicTickArray(rpc, address, config) {
const maybeAccount = await fetchMaybeDynamicTickArray(rpc, address, config);
assertAccountExists2(maybeAccount);
return maybeAccount;
}
async function fetchMaybeDynamicTickArray(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount2(rpc, address, config);
return decodeDynamicTickArray(maybeAccount);
}
async function fetchAllDynamicTickArray(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeDynamicTickArray(
rpc,
addresses,
config
);
assertAccountsExist2(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeDynamicTickArray(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeDynamicTickArray(maybeAccount)
);
}
// src/generated/accounts/feeTier.ts
import {
assertAccountExists as assertAccountExists3,
assertAccountsExist as assertAccountsExist3,
combineCodec as combineCodec25,
decodeAccount as decodeAccount3,
fetchEncodedAccount as fetchEncodedAccount3,
fetchEncodedAccounts as fetchEncodedAccounts3,
fixDecoderSize as fixDecoderSize6,
fixEncoderSize as fixEncoderSize6,
getAddressDecoder as getAddressDecoder10,
getAddressEncoder as getAddressEncoder10,
getBytesDecoder as getBytesDecoder6,
getBytesEncoder as getBytesEncoder6,
getStructDecoder as getStructDecoder22,
getStructEncoder as getStructEncoder22,
getU16Decoder as getU16Decoder4,
getU16Encoder as getU16Encoder4,
transformEncoder as transformEncoder3
} from "@solana/kit";
var FEE_TIER_DISCRIMINATOR = new Uint8Array([
56,
75,
159,
76,
142,
68,
190,
105
]);
function getFeeTierDiscriminatorBytes() {
return fixEncoderSize6(getBytesEncoder6(), 8).encode(FEE_TIER_DISCRIMINATOR);
}
function getFeeTierEncoder() {
return transformEncoder3(
getStructEncoder22([
["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
["whirlpoolsConfig", getAddressEncoder10()],
["tickSpacing", getU16Encoder4()],
["defaultFeeRate", getU16Encoder4()]
]),
(value) => ({ ...value, discriminator: FEE_TIER_DISCRIMINATOR })
);
}
function getFeeTierDecoder() {
return getStructDecoder22([
["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
["whirlpoolsConfig", getAddressDecoder10()],
["tickSpacing", getU16Decoder4()],
["defaultFeeRate", getU16Decoder4()]
]);
}
function getFeeTierCodec() {
return combineCodec25(getFeeTierEncoder(), getFeeTierDecoder());
}
function decodeFeeTier(encodedAccount) {
return decodeAccount3(
encodedAccount,
getFeeTierDecoder()
);
}
async function fetchFeeTier(rpc, address, config) {
const maybeAccount = await fetchMaybeFeeTier(rpc, address, config);
assertAccountExists3(maybeAccount);
return maybeAccount;
}
async function fetchMaybeFeeTier(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount3(rpc, address, config);
return decodeFeeTier(maybeAccount);
}
async function fetchAllFeeTier(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeFeeTier(rpc, addresses, config);
assertAccountsExist3(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeFeeTier(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeFeeTier(maybeAccount));
}
function getFeeTierSize() {
return 44;
}
// src/generated/accounts/fixedTickArray.ts
import {
assertAccountExists as assertAccountExists4,
assertAccountsExist as assertAccountsExist4,
combineCodec as combineCodec26,
decodeAccount as decodeAccount4,
fetchEncodedAccount as fetchEncodedAccount4,
fetchEncodedAccounts as fetchEncodedAccounts4,
fixDecoderSize as fixDecoderSize7,
fixEncoderSize as fixEncoderSize7,
getAddressDecoder as getAddressDecoder11,
getAddressEncoder as getAddressEncoder11,
getArrayDecoder as getArrayDecoder5,
getArrayEncoder as getArrayEncoder5,
getBytesDecoder as getBytesDecoder7,
getBytesEncoder as getBytesEncoder7,
getI32Decoder as getI32Decoder7,
getI32Encoder as getI32Encoder7,
getStructDecoder as getStructDecoder23,
getStructEncoder as getStructEncoder23,
transformEncoder as transformEncoder4
} from "@solana/kit";
var FIXED_TICK_ARRAY_DISCRIMINATOR = new Uint8Array([
69,
97,
189,
190,
110,
7,
66,
187
]);
function getFixedTickArrayDiscriminatorBytes() {
return fixEncoderSize7(getBytesEncoder7(), 8).encode(
FIXED_TICK_ARRAY_DISCRIMINATOR
);
}
function getFixedTickArrayEncoder() {
return transformEncoder4(
getStructEncoder23([
["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
["startTickIndex", getI32Encoder7()],
["ticks", getArrayEncoder5(getTickEncoder(), { size: 88 })],
["whirlpool", getAddressEncoder11()]
]),
(value) => ({ ...value, discriminator: FIXED_TICK_ARRAY_DISCRIMINATOR })
);
}
function getFixedTickArrayDecoder() {
return getStructDecoder23([
["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
["startTickIndex", getI32Decoder7()],
["ticks", getArrayDecoder5(getTickDecoder(), { size: 88 })],
["whirlpool", getAddressDecoder11()]
]);
}
function getFixedTickArrayCodec() {
return combineCodec26(getFixedTickArrayEncoder(), getFixedTickArrayDecoder());
}
function decodeFixedTickArray(encodedAccount) {
return decodeAccount4(
encodedAccount,
getFixedTickArrayDecoder()
);
}
async function fetchFixedTickArray(rpc, address, config) {
const maybeAccount = await fetchMaybeFixedTickArray(rpc, address, config);
assertAccountExists4(maybeAccount);
return maybeAccount;
}
async function fetchMaybeFixedTickArray(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount4(rpc, address, config);
return decodeFixedTickArray(maybeAccount);
}
async function fetchAllFixedTickArray(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeFixedTickArray(
rpc,
addresses,
config
);
assertAccountsExist4(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeFixedTickArray(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeFixedTickArray(maybeAccount)
);
}
function getFixedTickArraySize() {
return 9988;
}
// src/generated/accounts/lockConfig.ts
import {
assertAccountExists as assertAccountExists5,
assertAccountsExist as assertAccountsExist5,
combineCodec as combineCodec27,
decodeAccount as decodeAccount5,
fetchEncodedAccount as fetchEncodedAccount5,
fetchEncodedAccounts as fetchEncodedAccounts5,
fixDecoderSize as fixDecoderSize8,
fixEncoderSize as fixEncoderSize8,
getAddressDecoder as getAddressDecoder12,
getAddressEncoder as getAddressEncoder12,
getBytesDecoder as getBytesDecoder8,
getBytesEncoder as getBytesEncoder8,
getStructDecoder as getStructDecoder24,
getStructEncoder as getStructEncoder24,
getU64Decoder as getU64Decoder9,
getU64Encoder as getU64Encoder9,
transformEncoder as transformEncoder5
} from "@solana/kit";
var LOCK_CONFIG_DISCRIMINATOR = new Uint8Array([
106,
47,
238,
159,
124,
12,
160,
192
]);
function getLockConfigDiscriminatorBytes() {
return fixEncoderSize8(getBytesEncoder8(), 8).encode(LOCK_CONFIG_DISCRIMINATOR);
}
function getLockConfigEncoder() {
return transformEncoder5(
getStructEncoder24([
["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
["position", getAddressEncoder12()],
["positionOwner", getAddressEncoder12()],
["whirlpool", getAddressEncoder12()],
["lockedTimestamp", getU64Encoder9()],
["lockType", getLockTypeLabelEncoder()]
]),
(value) => ({ ...value, discriminator: LOCK_CONFIG_DISCRIMINATOR })
);
}
function getLockConfigDecoder() {
return getStructDecoder24([
["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
["position", getAddressDecoder12()],
["positionOwner", getAddressDecoder12()],
["whirlpool", getAddressDecoder12()],
["lockedTimestamp", getU64Decoder9()],
["lockType", getLockTypeLabelDecoder()]
]);
}
function getLockConfigCodec() {
return combineCodec27(getLockConfigEncoder(), getLockConfigDecoder());
}
function decodeLockConfig(encodedAccount) {
return decodeAccount5(
encodedAccount,
getLockConfigDecoder()
);
}
async function fetchLockConfig(rpc, address, config) {
const maybeAccount = await fetchMaybeLockConfig(rpc, address, config);
assertAccountExists5(maybeAccount);
return maybeAccount;
}
async function fetchMaybeLockConfig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount5(rpc, address, config);
return decodeLockConfig(maybeAccount);
}
async function fetchAllLockConfig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeLockConfig(rpc, addresses, config);
assertAccountsExist5(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeLockConfig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts5(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeLockConfig(maybeAccount));
}
function getLockConfigSize() {
return 113;
}
// src/generated/accounts/oracle.ts
import {
assertAccountExists as assertAccountExists6,
assertAccountsExist as assertAccountsExist6,
combineCodec as combineCodec28,
decodeAccount as decodeAccount6,
fetchEncodedAccount as fetchEncodedAccount6,
fetchEncodedAccounts as fetchEncodedAccounts6,
fixDecoderSize as fixDecoderSize9,
fixEncoderSize as fixEncoderSize9,
getAddressDecoder as getAddressDecoder13,
getAddressEncoder as getAddressEncoder13,
getBytesDecoder as getBytesDecoder9,
getBytesEncoder as getBytesEncoder9,
getStructDecoder as getStructDecoder25,
getStructEncoder as getStructEncoder25,
getU64Decoder as getU64Decoder10,
getU64Encoder as getU64Encoder10,
transformEncoder as transformEncoder6
} from "@solana/kit";
var ORACLE_DISCRIMINATOR = new Uint8Array([
139,
194,
131,
179,
140,
179,
229,
244
]);
function getOracleDiscriminatorBytes() {
return fixEncoderSize9(getBytesEncoder9(), 8).encode(ORACLE_DISCRIMINATOR);
}
function getOracleEncoder() {
return transformEncoder6(
getStructEncoder25([
["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
["whirlpool", getAddressEncoder13()],
["tradeEnableTimestamp", getU64Encoder10()],
["adaptiveFeeConstants", getAdaptiveFeeConstantsEncoder()],
["adaptiveFeeVariables", getAdaptiveFeeVariablesEncoder()],
["reserved", fixEncoderSize9(getBytesEncoder9(), 128)]
]),
(value) => ({ ...value, discriminator: ORACLE_DISCRIMINATOR })
);
}
function getOracleDecoder() {
return getStructDecoder25([
["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
["whirlpool", getAddressDecoder13()],
["tradeEnableTimestamp", getU64Decoder10()],
["adaptiveFeeConstants", getAdaptiveFeeConstantsDecoder()],
["adaptiveFeeVariables", getAdaptiveFeeVariablesDecoder()],
["reserved", fixDecoderSize9(getBytesDecoder9(), 128)]
]);
}
function getOracleCodec() {
return combineCodec28(getOracleEncoder(), getOracleDecoder());
}
function decodeOracle(encodedAccount) {
return decodeAccount6(
encodedAccount,
getOracleDecoder()
);
}
async function fetchOracle(rpc, address, config) {
const maybeAccount = await fetchMaybeOracle(rpc, address, config);
assertAccountExists6(maybeAccount);
return maybeAccount;
}
async function fetchMaybeOracle(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount6(rpc, address, config);
return decodeOracle(maybeAccount);
}
async function fetchAllOracle(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeOracle(rpc, addresses, config);
assertAccountsExist6(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeOracle(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts6(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeOracle(maybeAccount));
}
function getOracleSize() {
return 254;
}
// src/generated/accounts/position.ts
import {
assertAccountExists as assertAccountExists7,
assertAccountsExist as assertAccountsExist7,
combineCodec as combineCodec29,
decodeAccount as decodeAccount7,
fetchEncodedAccount as fetchEncodedAccount7,
fetchEncodedAccounts as fetchEncodedAccounts7,
fixDecoderSize as fixDecoderSize10,
fixEncoderSize as fixEncoderSize10,
getAddressDecoder as getAddressDecoder14,
getAddressEncoder as getAddressEncoder14,
getArrayDecoder as getArrayDecoder6,
getArrayEncoder as getArrayEncoder6,
getBytesDecoder as getBytesDecoder10,
getBytesEncoder as getBytesEncoder10,
getI32Decoder as getI32Decoder8,
getI32Encoder as getI32Encoder8,
getStructDecoder as getStructDecoder26,
getStructEncoder as getStructEncoder26,
getU128Decoder as getU128Decoder13,
getU128Encoder as getU128Encoder13,
getU64Decoder as getU64Decoder11,
getU64Encoder as getU64Encoder11,
transformEncoder as transformEncoder7
} from "@solana/kit";
var POSITION_DISCRIMINATOR = new Uint8Array([
170,
188,
143,
228,
122,
64,
247,
208
]);
function getPositionDiscriminatorBytes() {
return fixEncoderSize10(getBytesEncoder10(), 8).encode(POSITION_DISCRIMINATOR);
}
function getPositionEncoder() {
return transformEncoder7(
getStructEncoder26([
["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
["whirlpool", getAddressEncoder14()],
["positionMint", getAddressEncoder14()],
["liquidity", getU128Encoder13()],
["tickLowerIndex", getI32Encoder8()],
["tickUpperIndex", getI32Encoder8()],
["feeGrowthCheckpointA", getU128Encoder13()],
["feeOwedA", getU64Encoder11()],
["feeGrowthCheckpointB", getU128Encoder13()],
["feeOwedB", getU64Encoder11()],
[
"rewardInfos",
getArrayEncoder6(getPositionRewardInfoEncoder(), { size: 3 })
]
]),
(value) => ({ ...value, discriminator: POSITION_DISCRIMINATOR })
);
}
function getPositionDecoder() {
return getStructDecoder26([
["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
["whirlpool", getAddressDecoder14()],
["positionMint", getAddressDecoder14()],
["liquidity", getU128Decoder13()],
["tickLowerIndex", getI32Decoder8()],
["tickUpperIndex", getI32Decoder8()],
["feeGrowthCheckpointA", getU128Decoder13()],
["feeOwedA", getU64Decoder11()],
["feeGrowthCheckpointB", getU128Decoder13()],
["feeOwedB", getU64Decoder11()],
[
"rewardInfos",
getArrayDecoder6(getPositionRewardInfoDecoder(), { size: 3 })
]
]);
}
function getPositionCodec() {
return combineCodec29(getPositionEncoder(), getPositionDecoder());
}
function decodePosition(encodedAccount) {
return decodeAccount7(
encodedAccount,
getPositionDecoder()
);
}
async function fetchPosition(rpc, address, config) {
const maybeAccount = await fetchMaybePosition(rpc, address, config);
assertAccountExists7(maybeAccount);
return maybeAccount;
}
async function fetchMaybePosition(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount7(rpc, address, config);
return decodePosition(maybeAccount);
}
async function fetchAllPosition(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybePosition(rpc, addresses, config);
assertAccountsExist7(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybePosition(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts7(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodePosition(maybeAccount));
}
fu