@orca-so/whirlpools-client
Version:
Typescript client to interact with Orca's on-chain Whirlpool program.
1,555 lines (1,529 loc) • 375 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 combineCodec14,
decodeAccount as decodeAccount2,
fetchEncodedAccount as fetchEncodedAccount2,
fetchEncodedAccounts as fetchEncodedAccounts2,
fixDecoderSize as fixDecoderSize4,
fixEncoderSize as fixEncoderSize4,
getAddressDecoder as getAddressDecoder3,
getAddressEncoder as getAddressEncoder3,
getArrayDecoder as getArrayDecoder4,
getArrayEncoder as getArrayEncoder4,
getBytesDecoder as getBytesDecoder4,
getBytesEncoder as getBytesEncoder4,
getI32Decoder as getI32Decoder2,
getI32Encoder as getI32Encoder2,
getStructDecoder as getStructDecoder11,
getStructEncoder as getStructEncoder11,
getU128Decoder as getU128Decoder5,
getU128Encoder as getU128Encoder5,
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";
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/dynamicTick.ts
import {
combineCodec as combineCodec5,
getDiscriminatedUnionDecoder,
getDiscriminatedUnionEncoder,
getStructDecoder as getStructDecoder4,
getStructEncoder as getStructEncoder4,
getTupleDecoder,
getTupleEncoder,
getUnitDecoder,
getUnitEncoder
} from "@solana/kit";
function getDynamicTickEncoder() {
return getDiscriminatedUnionEncoder([
["Uninitialized", getUnitEncoder()],
[
"Initialized",
getStructEncoder4([
["fields", getTupleEncoder([getDynamicTickDataEncoder()])]
])
]
]);
}
function getDynamicTickDecoder() {
return getDiscriminatedUnionDecoder([
["Uninitialized", getUnitDecoder()],
[
"Initialized",
getStructDecoder4([
["fields", getTupleDecoder([getDynamicTickDataDecoder()])]
])
]
]);
}
function getDynamicTickCodec() {
return combineCodec5(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 combineCodec6,
getArrayDecoder,
getArrayEncoder,
getI128Decoder,
getI128Encoder,
getStructDecoder as getStructDecoder5,
getStructEncoder as getStructEncoder5,
getU128Decoder,
getU128Encoder
} from "@solana/kit";
function getDynamicTickDataEncoder() {
return getStructEncoder5([
["liquidityNet", getI128Encoder()],
["liquidityGross", getU128Encoder()],
["feeGrowthOutsideA", getU128Encoder()],
["feeGrowthOutsideB", getU128Encoder()],
["rewardGrowthsOutside", getArrayEncoder(getU128Encoder(), { size: 3 })]
]);
}
function getDynamicTickDataDecoder() {
return getStructDecoder5([
["liquidityNet", getI128Decoder()],
["liquidityGross", getU128Decoder()],
["feeGrowthOutsideA", getU128Decoder()],
["feeGrowthOutsideB", getU128Decoder()],
["rewardGrowthsOutside", getArrayDecoder(getU128Decoder(), { size: 3 })]
]);
}
function getDynamicTickDataCodec() {
return combineCodec6(getDynamicTickDataEncoder(), getDynamicTickDataDecoder());
}
// src/generated/types/lockType.ts
import {
combineCodec as combineCodec7,
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 combineCodec7(getLockTypeEncoder(), getLockTypeDecoder());
}
// src/generated/types/lockTypeLabel.ts
import {
combineCodec as combineCodec8,
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 combineCodec8(getLockTypeLabelEncoder(), getLockTypeLabelDecoder());
}
// src/generated/types/positionRewardInfo.ts
import {
combineCodec as combineCodec9,
getStructDecoder as getStructDecoder6,
getStructEncoder as getStructEncoder6,
getU128Decoder as getU128Decoder2,
getU128Encoder as getU128Encoder2,
getU64Decoder as getU64Decoder2,
getU64Encoder as getU64Encoder2
} from "@solana/kit";
function getPositionRewardInfoEncoder() {
return getStructEncoder6([
["growthInsideCheckpoint", getU128Encoder2()],
["amountOwed", getU64Encoder2()]
]);
}
function getPositionRewardInfoDecoder() {
return getStructDecoder6([
["growthInsideCheckpoint", getU128Decoder2()],
["amountOwed", getU64Decoder2()]
]);
}
function getPositionRewardInfoCodec() {
return combineCodec9(
getPositionRewardInfoEncoder(),
getPositionRewardInfoDecoder()
);
}
// src/generated/types/remainingAccountsInfo.ts
import {
combineCodec as combineCodec10,
getArrayDecoder as getArrayDecoder2,
getArrayEncoder as getArrayEncoder2,
getStructDecoder as getStructDecoder7,
getStructEncoder as getStructEncoder7
} from "@solana/kit";
function getRemainingAccountsInfoEncoder() {
return getStructEncoder7([
["slices", getArrayEncoder2(getRemainingAccountsSliceEncoder())]
]);
}
function getRemainingAccountsInfoDecoder() {
return getStructDecoder7([
["slices", getArrayDecoder2(getRemainingAccountsSliceDecoder())]
]);
}
function getRemainingAccountsInfoCodec() {
return combineCodec10(
getRemainingAccountsInfoEncoder(),
getRemainingAccountsInfoDecoder()
);
}
// src/generated/types/remainingAccountsSlice.ts
import {
combineCodec as combineCodec11,
getStructDecoder as getStructDecoder8,
getStructEncoder as getStructEncoder8,
getU8Decoder,
getU8Encoder
} from "@solana/kit";
function getRemainingAccountsSliceEncoder() {
return getStructEncoder8([
["accountsType", getAccountsTypeEncoder()],
["length", getU8Encoder()]
]);
}
function getRemainingAccountsSliceDecoder() {
return getStructDecoder8([
["accountsType", getAccountsTypeDecoder()],
["length", getU8Decoder()]
]);
}
function getRemainingAccountsSliceCodec() {
return combineCodec11(
getRemainingAccountsSliceEncoder(),
getRemainingAccountsSliceDecoder()
);
}
// src/generated/types/tick.ts
import {
combineCodec as combineCodec12,
getArrayDecoder as getArrayDecoder3,
getArrayEncoder as getArrayEncoder3,
getBooleanDecoder,
getBooleanEncoder,
getI128Decoder as getI128Decoder2,
getI128Encoder as getI128Encoder2,
getStructDecoder as getStructDecoder9,
getStructEncoder as getStructEncoder9,
getU128Decoder as getU128Decoder3,
getU128Encoder as getU128Encoder3
} from "@solana/kit";
function getTickEncoder() {
return getStructEncoder9([
["initialized", getBooleanEncoder()],
["liquidityNet", getI128Encoder2()],
["liquidityGross", getU128Encoder3()],
["feeGrowthOutsideA", getU128Encoder3()],
["feeGrowthOutsideB", getU128Encoder3()],
["rewardGrowthsOutside", getArrayEncoder3(getU128Encoder3(), { size: 3 })]
]);
}
function getTickDecoder() {
return getStructDecoder9([
["initialized", getBooleanDecoder()],
["liquidityNet", getI128Decoder2()],
["liquidityGross", getU128Decoder3()],
["feeGrowthOutsideA", getU128Decoder3()],
["feeGrowthOutsideB", getU128Decoder3()],
["rewardGrowthsOutside", getArrayDecoder3(getU128Decoder3(), { size: 3 })]
]);
}
function getTickCodec() {
return combineCodec12(getTickEncoder(), getTickDecoder());
}
// src/generated/types/whirlpoolRewardInfo.ts
import {
combineCodec as combineCodec13,
getAddressDecoder as getAddressDecoder2,
getAddressEncoder as getAddressEncoder2,
getStructDecoder as getStructDecoder10,
getStructEncoder as getStructEncoder10,
getU128Decoder as getU128Decoder4,
getU128Encoder as getU128Encoder4
} from "@solana/kit";
function getWhirlpoolRewardInfoEncoder() {
return getStructEncoder10([
["mint", getAddressEncoder2()],
["vault", getAddressEncoder2()],
["authority", getAddressEncoder2()],
["emissionsPerSecondX64", getU128Encoder4()],
["growthGlobalX64", getU128Encoder4()]
]);
}
function getWhirlpoolRewardInfoDecoder() {
return getStructDecoder10([
["mint", getAddressDecoder2()],
["vault", getAddressDecoder2()],
["authority", getAddressDecoder2()],
["emissionsPerSecondX64", getU128Decoder4()],
["growthGlobalX64", getU128Decoder4()]
]);
}
function getWhirlpoolRewardInfoCodec() {
return combineCodec13(
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 fixEncoderSize4(getBytesEncoder4(), 8).encode(
DYNAMIC_TICK_ARRAY_DISCRIMINATOR
);
}
function getDynamicTickArrayEncoder() {
return transformEncoder2(
getStructEncoder11([
["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
["startTickIndex", getI32Encoder2()],
["whirlpool", getAddressEncoder3()],
["tickBitmap", getU128Encoder5()],
["ticks", getArrayEncoder4(getDynamicTickEncoder(), { size: 88 })]
]),
(value) => ({ ...value, discriminator: DYNAMIC_TICK_ARRAY_DISCRIMINATOR })
);
}
function getDynamicTickArrayDecoder() {
return getStructDecoder11([
["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
["startTickIndex", getI32Decoder2()],
["whirlpool", getAddressDecoder3()],
["tickBitmap", getU128Decoder5()],
["ticks", getArrayDecoder4(getDynamicTickDecoder(), { size: 88 })]
]);
}
function getDynamicTickArrayCodec() {
return combineCodec14(
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 combineCodec15,
decodeAccount as decodeAccount3,
fetchEncodedAccount as fetchEncodedAccount3,
fetchEncodedAccounts as fetchEncodedAccounts3,
fixDecoderSize as fixDecoderSize5,
fixEncoderSize as fixEncoderSize5,
getAddressDecoder as getAddressDecoder4,
getAddressEncoder as getAddressEncoder4,
getBytesDecoder as getBytesDecoder5,
getBytesEncoder as getBytesEncoder5,
getStructDecoder as getStructDecoder12,
getStructEncoder as getStructEncoder12,
getU16Decoder as getU16Decoder3,
getU16Encoder as getU16Encoder3,
transformEncoder as transformEncoder3
} from "@solana/kit";
var FEE_TIER_DISCRIMINATOR = new Uint8Array([
56,
75,
159,
76,
142,
68,
190,
105
]);
function getFeeTierDiscriminatorBytes() {
return fixEncoderSize5(getBytesEncoder5(), 8).encode(FEE_TIER_DISCRIMINATOR);
}
function getFeeTierEncoder() {
return transformEncoder3(
getStructEncoder12([
["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
["whirlpoolsConfig", getAddressEncoder4()],
["tickSpacing", getU16Encoder3()],
["defaultFeeRate", getU16Encoder3()]
]),
(value) => ({ ...value, discriminator: FEE_TIER_DISCRIMINATOR })
);
}
function getFeeTierDecoder() {
return getStructDecoder12([
["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
["whirlpoolsConfig", getAddressDecoder4()],
["tickSpacing", getU16Decoder3()],
["defaultFeeRate", getU16Decoder3()]
]);
}
function getFeeTierCodec() {
return combineCodec15(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 combineCodec16,
decodeAccount as decodeAccount4,
fetchEncodedAccount as fetchEncodedAccount4,
fetchEncodedAccounts as fetchEncodedAccounts4,
fixDecoderSize as fixDecoderSize6,
fixEncoderSize as fixEncoderSize6,
getAddressDecoder as getAddressDecoder5,
getAddressEncoder as getAddressEncoder5,
getArrayDecoder as getArrayDecoder5,
getArrayEncoder as getArrayEncoder5,
getBytesDecoder as getBytesDecoder6,
getBytesEncoder as getBytesEncoder6,
getI32Decoder as getI32Decoder3,
getI32Encoder as getI32Encoder3,
getStructDecoder as getStructDecoder13,
getStructEncoder as getStructEncoder13,
transformEncoder as transformEncoder4
} from "@solana/kit";
var FIXED_TICK_ARRAY_DISCRIMINATOR = new Uint8Array([
69,
97,
189,
190,
110,
7,
66,
187
]);
function getFixedTickArrayDiscriminatorBytes() {
return fixEncoderSize6(getBytesEncoder6(), 8).encode(
FIXED_TICK_ARRAY_DISCRIMINATOR
);
}
function getFixedTickArrayEncoder() {
return transformEncoder4(
getStructEncoder13([
["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
["startTickIndex", getI32Encoder3()],
["ticks", getArrayEncoder5(getTickEncoder(), { size: 88 })],
["whirlpool", getAddressEncoder5()]
]),
(value) => ({ ...value, discriminator: FIXED_TICK_ARRAY_DISCRIMINATOR })
);
}
function getFixedTickArrayDecoder() {
return getStructDecoder13([
["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
["startTickIndex", getI32Decoder3()],
["ticks", getArrayDecoder5(getTickDecoder(), { size: 88 })],
["whirlpool", getAddressDecoder5()]
]);
}
function getFixedTickArrayCodec() {
return combineCodec16(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 combineCodec17,
decodeAccount as decodeAccount5,
fetchEncodedAccount as fetchEncodedAccount5,
fetchEncodedAccounts as fetchEncodedAccounts5,
fixDecoderSize as fixDecoderSize7,
fixEncoderSize as fixEncoderSize7,
getAddressDecoder as getAddressDecoder6,
getAddressEncoder as getAddressEncoder6,
getBytesDecoder as getBytesDecoder7,
getBytesEncoder as getBytesEncoder7,
getStructDecoder as getStructDecoder14,
getStructEncoder as getStructEncoder14,
getU64Decoder as getU64Decoder3,
getU64Encoder as getU64Encoder3,
transformEncoder as transformEncoder5
} from "@solana/kit";
var LOCK_CONFIG_DISCRIMINATOR = new Uint8Array([
106,
47,
238,
159,
124,
12,
160,
192
]);
function getLockConfigDiscriminatorBytes() {
return fixEncoderSize7(getBytesEncoder7(), 8).encode(LOCK_CONFIG_DISCRIMINATOR);
}
function getLockConfigEncoder() {
return transformEncoder5(
getStructEncoder14([
["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
["position", getAddressEncoder6()],
["positionOwner", getAddressEncoder6()],
["whirlpool", getAddressEncoder6()],
["lockedTimestamp", getU64Encoder3()],
["lockType", getLockTypeLabelEncoder()]
]),
(value) => ({ ...value, discriminator: LOCK_CONFIG_DISCRIMINATOR })
);
}
function getLockConfigDecoder() {
return getStructDecoder14([
["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
["position", getAddressDecoder6()],
["positionOwner", getAddressDecoder6()],
["whirlpool", getAddressDecoder6()],
["lockedTimestamp", getU64Decoder3()],
["lockType", getLockTypeLabelDecoder()]
]);
}
function getLockConfigCodec() {
return combineCodec17(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 combineCodec18,
decodeAccount as decodeAccount6,
fetchEncodedAccount as fetchEncodedAccount6,
fetchEncodedAccounts as fetchEncodedAccounts6,
fixDecoderSize as fixDecoderSize8,
fixEncoderSize as fixEncoderSize8,
getAddressDecoder as getAddressDecoder7,
getAddressEncoder as getAddressEncoder7,
getBytesDecoder as getBytesDecoder8,
getBytesEncoder as getBytesEncoder8,
getStructDecoder as getStructDecoder15,
getStructEncoder as getStructEncoder15,
getU64Decoder as getU64Decoder4,
getU64Encoder as getU64Encoder4,
transformEncoder as transformEncoder6
} from "@solana/kit";
var ORACLE_DISCRIMINATOR = new Uint8Array([
139,
194,
131,
179,
140,
179,
229,
244
]);
function getOracleDiscriminatorBytes() {
return fixEncoderSize8(getBytesEncoder8(), 8).encode(ORACLE_DISCRIMINATOR);
}
function getOracleEncoder() {
return transformEncoder6(
getStructEncoder15([
["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
["whirlpool", getAddressEncoder7()],
["tradeEnableTimestamp", getU64Encoder4()],
["adaptiveFeeConstants", getAdaptiveFeeConstantsEncoder()],
["adaptiveFeeVariables", getAdaptiveFeeVariablesEncoder()],
["reserved", fixEncoderSize8(getBytesEncoder8(), 128)]
]),
(value) => ({ ...value, discriminator: ORACLE_DISCRIMINATOR })
);
}
function getOracleDecoder() {
return getStructDecoder15([
["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
["whirlpool", getAddressDecoder7()],
["tradeEnableTimestamp", getU64Decoder4()],
["adaptiveFeeConstants", getAdaptiveFeeConstantsDecoder()],
["adaptiveFeeVariables", getAdaptiveFeeVariablesDecoder()],
["reserved", fixDecoderSize8(getBytesDecoder8(), 128)]
]);
}
function getOracleCodec() {
return combineCodec18(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 combineCodec19,
decodeAccount as decodeAccount7,
fetchEncodedAccount as fetchEncodedAccount7,
fetchEncodedAccounts as fetchEncodedAccounts7,
fixDecoderSize as fixDecoderSize9,
fixEncoderSize as fixEncoderSize9,
getAddressDecoder as getAddressDecoder8,
getAddressEncoder as getAddressEncoder8,
getArrayDecoder as getArrayDecoder6,
getArrayEncoder as getArrayEncoder6,
getBytesDecoder as getBytesDecoder9,
getBytesEncoder as getBytesEncoder9,
getI32Decoder as getI32Decoder4,
getI32Encoder as getI32Encoder4,
getStructDecoder as getStructDecoder16,
getStructEncoder as getStructEncoder16,
getU128Decoder as getU128Decoder6,
getU128Encoder as getU128Encoder6,
getU64Decoder as getU64Decoder5,
getU64Encoder as getU64Encoder5,
transformEncoder as transformEncoder7
} from "@solana/kit";
var POSITION_DISCRIMINATOR = new Uint8Array([
170,
188,
143,
228,
122,
64,
247,
208
]);
function getPositionDiscriminatorBytes() {
return fixEncoderSize9(getBytesEncoder9(), 8).encode(POSITION_DISCRIMINATOR);
}
function getPositionEncoder() {
return transformEncoder7(
getStructEncoder16([
["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
["whirlpool", getAddressEncoder8()],
["positionMint", getAddressEncoder8()],
["liquidity", getU128Encoder6()],
["tickLowerIndex", getI32Encoder4()],
["tickUpperIndex", getI32Encoder4()],
["feeGrowthCheckpointA", getU128Encoder6()],
["feeOwedA", getU64Encoder5()],
["feeGrowthCheckpointB", getU128Encoder6()],
["feeOwedB", getU64Encoder5()],
[
"rewardInfos",
getArrayEncoder6(getPositionRewardInfoEncoder(), { size: 3 })
]
]),
(value) => ({ ...value, discriminator: POSITION_DISCRIMINATOR })
);
}
function getPositionDecoder() {
return getStructDecoder16([
["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
["whirlpool", getAddressDecoder8()],
["positionMint", getAddressDecoder8()],
["liquidity", getU128Decoder6()],
["tickLowerIndex", getI32Decoder4()],
["tickUpperIndex", getI32Decoder4()],
["feeGrowthCheckpointA", getU128Decoder6()],
["feeOwedA", getU64Decoder5()],
["feeGrowthCheckpointB", getU128Decoder6()],
["feeOwedB", getU64Decoder5()],
[
"rewardInfos",
getArrayDecoder6(getPositionRewardInfoDecoder(), { size: 3 })
]
]);
}
function getPositionCodec() {
return combineCodec19(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));
}
function getPositionSize() {
return 216;
}
// src/generated/accounts/positionBundle.ts
import {
assertAccountExists as assertAccountExists8,
assertAccountsExist as assertAccountsExist8,
combineCodec as combineCodec20,
decodeAccount as decodeAccount8,
fetchEncodedAccount as fetchEncodedAccount8,
fetchEncodedAccounts as fetchEncodedAccounts8,
fixDecoderSize as fixDecoderSize10,
fixEncoderSize as fixEncoderSize10,
getAddressDecoder as getAddressDecoder9,
getAddressEncoder as getAddressEncoder9,
getBytesDecoder as getBytesDecoder10,
getBytesEncoder as getBytesEncoder10,
getStructDecoder as getStructDecoder17,
getStructEncoder as getStructEncoder17,
transformEncoder as transformEncoder8
} from "@solana/kit";
var POSITION_BUNDLE_DISCRIMINATOR = new Uint8Array([
129,
169,
175,
65,
185,
95,
32,
100
]);
function getPositionBundleDiscriminatorBytes() {
return fixEncoderSize10(getBytesEncoder10(), 8).encode(
POSITION_BUNDLE_DISCRIMINATOR
);
}
function getPositionBundleEncoder() {
return transformEncoder8(
getStructEncoder17([
["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
["positionBundleMint", getAddressEncoder9()],
["positionBitmap", fixEncoderSize10(getBytesEncoder10(), 32)]
]),
(value) => ({ ...value, discriminator: POSITION_BUNDLE_DISCRIMINATOR })
);
}
function getPositionBundleDecoder() {
return getStructDecoder17([
["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
["positionBundleMint", getAddressDecoder9()],
["positionBitmap", fixDecoderSize10(getBytesDecoder10(), 32)]
]);
}
function getPositionBundleCodec() {
return combineCodec20(getPositionBundleEncoder(), getPositionBundleDecoder());
}
function decodePositionBundle(encodedAccount) {
return decodeAccount8(
encodedAccount,
getPositionBundleDecoder()
);
}
async function fetchPositionBundle(rpc, address, config) {
const maybeAccount = await fetchMaybePositionBundle(rpc, address, config);
assertAccountExists8(maybeAccount);
return maybeAccount;
}
async function fetchMaybePositionBundle(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount8(rpc, address, config);
return decodePositionBundle(maybeAccount);
}
async function fetchAllPositionBundle(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybePositionBundle(
rpc,
addresses,
config
);
assertAccountsExist8(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybePositionBundle(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts8(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodePositionBundle(maybeAccount)
);
}
function getPositionBundleSize() {
return 72;
}
// src/generated/accounts/tokenBadge.ts
import {
assertAccountExists as assertAccountExists9,
assertAccountsExist as assertAccountsExist9,
combineCodec as combineCodec21,
decodeAccount as decodeAccount9,
fetchEncodedAccount as fetchEncodedAccount9,
fetchEncodedAccounts as fetchEncodedAccounts9,
fixDecoderSize as fixDecoderSize11,
fixEncoderSize as fixEncoderSize11,
getAddressDecoder as getAddressDecoder10,
getAddressEncoder as getAddressEncoder10,
getBytesDecoder as getBytesDecoder11,
getBytesEncoder as getBytesEncoder11,
getStructDecoder as getStructDecoder18,
getStructEncoder as getStructEncoder18,
transformEncoder as transformEncoder9
} from "@solana/kit";
var TOKEN_BADGE_DISCRIMINATOR = new Uint8Array([
116,
219,
204,
229,
249,
116,
255,
150
]);
function getTokenBadgeDiscriminatorBytes() {
return fixEncoderSize11(getBytesEncoder11(), 8).encode(TOKEN_BADGE_DISCRIMINATOR);
}
function getTokenBadgeEncoder() {
return transformEncoder9(
getStructEncoder18([
["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
["whirlpoolsConfig", getAddressEncoder10()],
["tokenMint", getAddressEncoder10()]
]),
(value) => ({ ...value, discriminator: TOKEN_BADGE_DISCRIMINATOR })
);
}
function getTokenBadgeDecoder() {
return getStructDecoder18([
["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)],
["whirlpoolsConfig", getAddressDecoder10()],
["tokenMint", getAddressDecoder10()]
]);
}
function getTokenBadgeCodec() {
return combineCodec21(getTokenBadgeEncoder(), getTokenBadgeDecoder());
}
function decodeTokenBadge(encodedAccount) {
return decodeAccount9(
encodedAccount,
getTokenBadgeDecoder()
);
}
async function fetchTokenBadge(rpc, address, config) {
const maybeAccount = await fetchMaybeTokenBadge(rpc, address, config);
assertAccountExists9(maybeAccount);
return maybeAccount;
}
async function fetchMaybeTokenBadge(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount9(rpc, address, config);
return decodeTokenBadge(maybeAccount);
}
async function fetchAllTokenBadge(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeTokenBadge(rpc, addresses, config);
assertAccountsExist9(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeTokenBadge(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts9(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeTokenBadge(maybeAccount));
}
function getTokenBadgeSize() {
return 72;
}
// src/generated/accounts/whirlpool.ts
import {
assertAccountExists as assertAccountExists10,
assertAccountsExist as assertAccountsExist10,
combineCodec as combineCodec22,
decodeAccount as decodeAccount10,
fetchEncodedAccount as fetchEncodedAccount10,
fetchEncodedAccounts as fetchEncodedAccounts10,
fixDecoderSize as fixDecoderSize12,
fixEncoderSize as fixEncoderSize12,
getAddressDecoder as getAddressDecoder11,
getAddressEncoder as getAddressEncoder11,
getArrayDecoder as getArrayDecoder7,
getArrayEncoder as getArrayEncoder7,
getBytesDecoder as getBytesDecoder12,
getBytesEncoder as getBytesEncoder12,
getI32Decoder as getI32Decoder5,
getI32Encoder as getI32Encoder5,
getStructDecoder as getStructDecoder19,
getStructEncoder as getStructEncoder19,
getU128Decoder as getU128Decoder7,
getU128Encoder as getU128Encoder7,
getU16Decoder as getU16Decoder4,
getU16Encoder as getU16Encoder4,
getU64Decoder as getU64Decoder6,
getU64Encoder as getU64Encoder6,
transformEncoder as transformEncoder10
} from "@solana/kit";
var WHIRLPOOL_DISCRIMINATOR = new Uint8Array([
63,
149,
209,
12,
225,
128,
99,
9
]);
function getWhirlpoolDiscriminatorBytes() {
return fixEncoderSize12(getBytesEncoder12(), 8).encode(WHIRLPOOL_DISCRIMINATOR);
}
function getWhirlpoolEncoder() {
return transformEncoder10(
getStructEncoder19([
["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)],
["whirlpoolsConfig", getAddressEncoder11()],
["whirlpoolBump", fixEncoderSize12(getBytesEncoder12(), 1)],
["tickSpacing", getU16Encoder4()],
["feeTierIndexSeed", fixEncoderSize12(getBytesEncoder12(), 2)],
["feeRate", getU16Encoder4()],
["protocolFeeRate", getU16Encoder4()],
["liquidity", getU128Encoder7()],
["sqrtPrice", getU128Encoder7()],
["tickCurrentIndex", getI32Encoder5()],
["protocolFeeOwedA", getU64Encoder6()],
["protocolFeeOwedB", getU64Encoder6()],
["tokenMintA", getAddressEncoder11()],
["tokenVaultA", getAddressEncoder11()],
["feeGrowthGlobalA", getU128Encoder7()],
["tokenMintB", getAddressEncoder11()],
["tokenVaultB", getAddressEncoder11()],
["feeGrowthGlobalB", getU128Encoder7()],
["rewardLastUpdatedTimestamp", getU64Encoder6()],
[
"rewardInfos",
getArrayEncoder7(getWhirlpoolRewardInfoEncoder(), { size: 3 })
]
]),
(value) => ({ ...value, discriminator: WHIRLPOOL_DISCRIMINATOR })
);
}
function getWhirlpoolDecoder() {
return getStructDecoder19([
["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
["whirlpoolsConfig", getAddressDecoder11()],
["whirlpoolBump", fixDecoderSize12(getBytesDecoder12(), 1)],
["tickSpacing", getU16Decoder4()],
["feeTierIndexSeed", fixDecoderSize12(getBytesDecoder12(), 2)],
["feeRate", getU16Decoder4()],
["protocolFeeRate", getU16Decoder4()],
["liquidity", getU128Decoder7()],
["sqrtPrice", getU128Decoder7()],
["tickCurrentIndex", getI32Decoder5()],
["protocolFeeOwedA", getU64Decoder6()],
["protocolFeeOwedB", getU64Decoder6()],
["tokenMintA", getAddressDecoder11()],
["tokenVaultA", getAddressDecoder11()],
["feeGrowthGlobalA", getU128Decoder7()],
["tokenMintB", getAddressDecoder11()],
["tokenVaultB", getAddressDecoder11()],
["feeGrowthGlobalB", getU128Decoder7()],
["rewardLastUpdatedTimestamp", getU64Decoder6()],
[
"rewardInfos",
getArrayDecoder7(getWhirlpoolRewardInfoDecoder(), { size: 3 })
]
]);
}
function getWhirlpoolCodec() {
return combineCodec22(getWhirlpoolEncoder(), getWhirlpoolDecoder());
}
function decodeWhirlpool(encodedAccount) {
return decodeAccount10(
encodedAccount,
getWhirlpoolDecoder()
);
}
async function fetchWhirlpool(rpc, address, config) {
const maybeAccount = await fetchMaybeWhirlpool(rpc, address, config);
assertAccountExists10(maybeAccount);
return maybeAccount;
}
async function fetchMaybeWhirlpool(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount10(rpc, address, config);
return decodeWhirlpool(maybeAccount);
}
async function fetchAllWhirlpool(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeWhirlpool(rpc, addresses, config);
assertAccountsExist10(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeWhirlpool(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts10(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeWhirlpool(maybeAccount));
}
function getWhirlpoolSize() {
return 653;
}
// src/generated/accounts/whirlpoolsConfig.ts
import {
assertAccountExists as assertAccountExists11,
assertAccountsExist as assertAccountsExist11,
combineCodec as combineCodec23,
decodeAccount as decodeAccount11,
fetchEncodedAccount as fetchEncodedAccount11,
fetchEncodedAccounts as fetchEncodedAccounts11,
fixDecoderSize as fixDecoderSize13,
fixEncoderSize as fixEncoderSize13,
getAddressDecoder as getAddressDecoder12,
getAddressEncoder as getAddressEncoder12,
getBytesDecoder as getBytesDecoder13,
getBytesEncoder as getBytesEncoder13,
getStructDecoder as getStructDecoder20,
getStructEncoder as getStructEncoder20,
getU16Decoder as getU16Decoder5,
getU16Encoder as getU16Encoder5,
transformEncoder as transformEncoder11
} from "@solana/kit";
var WHIRLPOOLS_CONFIG_DISCRIMINATOR = new Uint8Array([
157,
20,
49,
224,
217,
87,
193,
254
]);
function getWhirlpoolsConfigDiscriminatorBytes() {
return fixEncoderSize13(getBytesEncoder13(), 8).encode(
WHIRLPOOLS_CONFIG_DISCRIMINATOR
);
}
function getWhirlpoolsConfigEncoder() {
return transformEncoder11(
getStructEncoder20([
["discriminator", fixEncoderSize13(getBytesEncoder13(), 8)],
["feeAuthority", getAddressEncoder12()],
["collectProtocolFeesAuthority", getAddressEncoder12()],
["rewardEmissionsSuperAuthority", getAddressEncoder12()],
["defaultProtocolFeeRate", getU16Encoder5()]
]),
(value) => ({ ...value, discriminator: WHIRLPOOLS_CONFIG_DISCRIMINATOR })
);
}
function getWhirlpoolsConfigDecoder() {
return getStructDecoder20([
["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
["feeAuthority", getAddressDecoder12()],
["collectProtocolFeesAuthority", getAddressDecoder12()],
["rewardEmissionsSuperAuthority", getAddressDecoder12()],
["defaultProtocolFeeRate", getU16Decoder5()]
]);
}
function getWhirlpoolsConfigCodec() {
return combineCodec23(
getWhirlpoolsConfigEncoder(),
getWhirlpoolsConfigDecoder()
);
}
function decodeWhirlpoolsConfig(encodedAccount) {
return decodeAccount11(
encodedAccount,
getWhirlpoolsConfigDecoder()
);
}
async function fetchWhirlpoolsConfig(rpc, address, config) {
const maybeAccount = await fetchMaybeWhirlpoolsConfig(rpc, address, config);
assertAccountExists11(maybeAccount);
return maybeAccount;
}
async function fetchMaybeWhirlpoolsConfig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount11(rpc, address, config);
return decodeWhirlpoolsConfig(maybeAccount);
}
async function fetchAllWhirlpoolsConfig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeWhirlpoolsConfig(
rpc,
addresses,
config
);
assertAccountsExist11(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeWhirlpoolsConfig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts11(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeWhirlpoolsConfig(maybeAccount)
);
}
function getWhirlpoolsConfigSize() {
return 106;
}
// src/generated/accounts/whirlpoolsConfigExtension.ts
import {
assertAccountExists as assertAccountExists12,
assertAccountsExist as assertAccountsExist12,
combineCodec as combineCodec24,
decodeAccount as decodeAccount12,
fetchEncodedAccount as fetchEncodedAccount12,
fetchEncodedAccounts as fetchEncodedAccounts12,
fixDecoderSize as fixDecoderSize14,
fixEncoderSize as fixEncoderSize14,
getAddressDecoder as getAddressDecoder13,
getAddressEncoder as getAddressEncoder13,
getBytesDecoder as getBytesDecoder14,
getBytesEncoder as getBytesEncoder14,
getStructDecoder as getStructDecoder21,
getStructEncoder as getStructEncoder21,
transformEncoder as transformEncoder12
} from "@solana/kit";
var WHIRLPOOLS_CONFIG_EXTENSION_DISCRIMINATOR = new Uint8Array([
2,
99,
215,
163,
240,
26,
153,
58
]);
function getWhirlpoolsConfigExtensionDiscriminatorBytes() {
return fixEncoderSize14(getBytesEncoder14(), 8).encode(
WHIRLPOOLS_CONFIG_EXTENSION_DISCRIMINATOR
);
}
function getWhirlpoolsConfigExtensionEncoder() {
return transformEncoder12(
getStructEncoder21([
["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
["whirlpoolsConfig", getAddressEncoder13()],
["configExtensionAuthority", getAddressEncoder13()],
["tokenBadgeAuthority", getAddressEncoder13()]
]),
(value) => ({
...value,
discriminator: WHIRLPOOLS_CONFIG_EXTENSION_DISCRIMINATOR
})
);
}
function getWhirlpoolsConfigExtensionDecoder() {
return getStructDecoder21([
["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
["whirlpoolsConfig", getAddressDecoder13()],
["configExtensionAuthority", getAddressDecoder13()],
["tokenBadgeAuthority", getAddressDecoder13()]
]);
}
function getWhirlpoolsConfigExtensionCodec() {
return combineCodec24(
getWhirlpoolsConfigExtensionEncoder(),
getWhirlpoolsConfigExtensionDecoder()
);
}
function decodeWhirlpoolsConfigExtension(encodedAccount) {
return decodeAccount12(
encodedAccount,
getWhirlpoolsConfigExtensionDecoder()
);
}
async function fetchWhirlpoolsConfigExtension(rpc, address, config) {
const maybeAccount = await fetchMaybeWhirlpoolsConfigExtension(
rpc,
address,
config
);
assertAccountExists12(maybeAccount);
return maybeAccount;
}
async function fetchMaybeWhirlpoolsConfigExtension(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount12(rpc, address, config);
return decodeWhirlpoolsConfigExtension(maybeAccount);
}
async function fetchAllWhirlpoolsConfigExtension(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeWhirlpoolsConfigExtension(
rpc,
addresses,
config
);
assertAccountsExist12(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeWhirlpoolsConfigExtension(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts12(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeWhirlpoolsConfigExtension(maybeAccount)
);
}
function getWhirlpoolsConfigExtensionSize() {
return 104;
}
// src/generated/errors/whirlpool.ts
import {
isProgramError
} from "@solana/kit";
// src/gener