{"version":3,"sources":["jsdelivr-header.js","/npm/@solana-program/compute-budget@0.10.0/src/generated/programs/computeBudget.ts","/npm/@solana-program/compute-budget@0.10.0/src/generated/instructions/requestHeapFrame.ts","/npm/@solana-program/compute-budget@0.10.0/src/generated/instructions/requestUnits.ts","/npm/@solana-program/compute-budget@0.10.0/src/generated/instructions/setComputeUnitLimit.ts","/npm/@solana-program/compute-budget@0.10.0/src/generated/instructions/setComputeUnitPrice.ts","/npm/@solana-program/compute-budget@0.10.0/src/generated/instructions/setLoadedAccountsDataSizeLimit.ts","/npm/@solana-program/compute-budget@0.10.0/src/constants.ts","/npm/@solana-program/compute-budget@0.10.0/src/internal.ts","/npm/@solana-program/compute-budget@0.10.0/src/setComputeLimit.ts","/npm/@solana-program/compute-budget@0.10.0/src/estimateAndSetComputeLimit.ts","/npm/@solana-program/compute-budget@0.10.0/src/estimateComputeLimitInternal.ts","/npm/@solana-program/compute-budget@0.10.0/src/estimateComputeLimit.ts","/npm/@solana-program/compute-budget@0.10.0/src/setComputePrice.ts"],"names":[],"mappings":"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","file":"/npm/@solana-program/compute-budget@0.10.0/dist/src/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@solana-program/compute-budget@0.10.0/dist/src/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n containsBytes,\n getU8Encoder,\n type Address,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport {\n type ParsedRequestHeapFrameInstruction,\n type ParsedRequestUnitsInstruction,\n type ParsedSetComputeUnitLimitInstruction,\n type ParsedSetComputeUnitPriceInstruction,\n type ParsedSetLoadedAccountsDataSizeLimitInstruction,\n} from '../instructions';\n\nexport const COMPUTE_BUDGET_PROGRAM_ADDRESS =\n 'ComputeBudget111111111111111111111111111111' as Address<'ComputeBudget111111111111111111111111111111'>;\n\nexport enum ComputeBudgetInstruction {\n RequestUnits,\n RequestHeapFrame,\n SetComputeUnitLimit,\n SetComputeUnitPrice,\n SetLoadedAccountsDataSizeLimit,\n}\n\nexport function identifyComputeBudgetInstruction(\n instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array\n): ComputeBudgetInstruction {\n const data = 'data' in instruction ? instruction.data : instruction;\n if (containsBytes(data, getU8Encoder().encode(0), 0)) {\n return ComputeBudgetInstruction.RequestUnits;\n }\n if (containsBytes(data, getU8Encoder().encode(1), 0)) {\n return ComputeBudgetInstruction.RequestHeapFrame;\n }\n if (containsBytes(data, getU8Encoder().encode(2), 0)) {\n return ComputeBudgetInstruction.SetComputeUnitLimit;\n }\n if (containsBytes(data, getU8Encoder().encode(3), 0)) {\n return ComputeBudgetInstruction.SetComputeUnitPrice;\n }\n if (containsBytes(data, getU8Encoder().encode(4), 0)) {\n return ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit;\n }\n throw new Error(\n 'The provided instruction could not be identified as a computeBudget instruction.'\n );\n}\n\nexport type ParsedComputeBudgetInstruction<\n TProgram extends string = 'ComputeBudget111111111111111111111111111111',\n> =\n | ({\n instructionType: ComputeBudgetInstruction.RequestUnits;\n } & ParsedRequestUnitsInstruction)\n | ({\n instructionType: ComputeBudgetInstruction.RequestHeapFrame;\n } & ParsedRequestHeapFrameInstruction)\n | ({\n instructionType: ComputeBudgetInstruction.SetComputeUnitLimit;\n } & ParsedSetComputeUnitLimitInstruction)\n | ({\n instructionType: ComputeBudgetInstruction.SetComputeUnitPrice;\n } & ParsedSetComputeUnitPriceInstruction)\n | ({\n instructionType: ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit;\n } & ParsedSetLoadedAccountsDataSizeLimitInstruction);\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n combineCodec,\n getStructDecoder,\n getStructEncoder,\n getU32Decoder,\n getU32Encoder,\n getU8Decoder,\n getU8Encoder,\n transformEncoder,\n type AccountMeta,\n type Address,\n type FixedSizeCodec,\n type FixedSizeDecoder,\n type FixedSizeEncoder,\n type Instruction,\n type InstructionWithAccounts,\n type InstructionWithData,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';\n\nexport const REQUEST_HEAP_FRAME_DISCRIMINATOR = 1;\n\nexport function getRequestHeapFrameDiscriminatorBytes() {\n return getU8Encoder().encode(REQUEST_HEAP_FRAME_DISCRIMINATOR);\n}\n\nexport type RequestHeapFrameInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n TRemainingAccounts extends readonly AccountMeta[] = [],\n> = Instruction &\n InstructionWithData &\n InstructionWithAccounts;\n\nexport type RequestHeapFrameInstructionData = {\n discriminator: number;\n /**\n * Requested transaction-wide program heap size in bytes.\n * Must be multiple of 1024. Applies to each program, including CPIs.\n */\n bytes: number;\n};\n\nexport type RequestHeapFrameInstructionDataArgs = {\n /**\n * Requested transaction-wide program heap size in bytes.\n * Must be multiple of 1024. Applies to each program, including CPIs.\n */\n bytes: number;\n};\n\nexport function getRequestHeapFrameInstructionDataEncoder(): FixedSizeEncoder {\n return transformEncoder(\n getStructEncoder([\n ['discriminator', getU8Encoder()],\n ['bytes', getU32Encoder()],\n ]),\n (value) => ({ ...value, discriminator: REQUEST_HEAP_FRAME_DISCRIMINATOR })\n );\n}\n\nexport function getRequestHeapFrameInstructionDataDecoder(): FixedSizeDecoder {\n return getStructDecoder([\n ['discriminator', getU8Decoder()],\n ['bytes', getU32Decoder()],\n ]);\n}\n\nexport function getRequestHeapFrameInstructionDataCodec(): FixedSizeCodec<\n RequestHeapFrameInstructionDataArgs,\n RequestHeapFrameInstructionData\n> {\n return combineCodec(\n getRequestHeapFrameInstructionDataEncoder(),\n getRequestHeapFrameInstructionDataDecoder()\n );\n}\n\nexport type RequestHeapFrameInput = {\n bytes: RequestHeapFrameInstructionDataArgs['bytes'];\n};\n\nexport function getRequestHeapFrameInstruction<\n TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n>(\n input: RequestHeapFrameInput,\n config?: { programAddress?: TProgramAddress }\n): RequestHeapFrameInstruction {\n // Program address.\n const programAddress =\n config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;\n\n // Original args.\n const args = { ...input };\n\n return Object.freeze({\n data: getRequestHeapFrameInstructionDataEncoder().encode(\n args as RequestHeapFrameInstructionDataArgs\n ),\n programAddress,\n } as RequestHeapFrameInstruction);\n}\n\nexport type ParsedRequestHeapFrameInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n> = {\n programAddress: Address;\n data: RequestHeapFrameInstructionData;\n};\n\nexport function parseRequestHeapFrameInstruction(\n instruction: Instruction & InstructionWithData\n): ParsedRequestHeapFrameInstruction {\n return {\n programAddress: instruction.programAddress,\n data: getRequestHeapFrameInstructionDataDecoder().decode(instruction.data),\n };\n}\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n combineCodec,\n getStructDecoder,\n getStructEncoder,\n getU32Decoder,\n getU32Encoder,\n getU8Decoder,\n getU8Encoder,\n transformEncoder,\n type AccountMeta,\n type Address,\n type FixedSizeCodec,\n type FixedSizeDecoder,\n type FixedSizeEncoder,\n type Instruction,\n type InstructionWithAccounts,\n type InstructionWithData,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';\n\nexport const REQUEST_UNITS_DISCRIMINATOR = 0;\n\nexport function getRequestUnitsDiscriminatorBytes() {\n return getU8Encoder().encode(REQUEST_UNITS_DISCRIMINATOR);\n}\n\nexport type RequestUnitsInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n TRemainingAccounts extends readonly AccountMeta[] = [],\n> = Instruction &\n InstructionWithData &\n InstructionWithAccounts;\n\nexport type RequestUnitsInstructionData = {\n discriminator: number;\n /** Units to request for transaction-wide compute. */\n units: number;\n /** Prioritization fee lamports. */\n additionalFee: number;\n};\n\nexport type RequestUnitsInstructionDataArgs = {\n /** Units to request for transaction-wide compute. */\n units: number;\n /** Prioritization fee lamports. */\n additionalFee: number;\n};\n\nexport function getRequestUnitsInstructionDataEncoder(): FixedSizeEncoder {\n return transformEncoder(\n getStructEncoder([\n ['discriminator', getU8Encoder()],\n ['units', getU32Encoder()],\n ['additionalFee', getU32Encoder()],\n ]),\n (value) => ({ ...value, discriminator: REQUEST_UNITS_DISCRIMINATOR })\n );\n}\n\nexport function getRequestUnitsInstructionDataDecoder(): FixedSizeDecoder {\n return getStructDecoder([\n ['discriminator', getU8Decoder()],\n ['units', getU32Decoder()],\n ['additionalFee', getU32Decoder()],\n ]);\n}\n\nexport function getRequestUnitsInstructionDataCodec(): FixedSizeCodec<\n RequestUnitsInstructionDataArgs,\n RequestUnitsInstructionData\n> {\n return combineCodec(\n getRequestUnitsInstructionDataEncoder(),\n getRequestUnitsInstructionDataDecoder()\n );\n}\n\nexport type RequestUnitsInput = {\n units: RequestUnitsInstructionDataArgs['units'];\n additionalFee: RequestUnitsInstructionDataArgs['additionalFee'];\n};\n\nexport function getRequestUnitsInstruction<\n TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n>(\n input: RequestUnitsInput,\n config?: { programAddress?: TProgramAddress }\n): RequestUnitsInstruction {\n // Program address.\n const programAddress =\n config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;\n\n // Original args.\n const args = { ...input };\n\n return Object.freeze({\n data: getRequestUnitsInstructionDataEncoder().encode(\n args as RequestUnitsInstructionDataArgs\n ),\n programAddress,\n } as RequestUnitsInstruction);\n}\n\nexport type ParsedRequestUnitsInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n> = { programAddress: Address; data: RequestUnitsInstructionData };\n\nexport function parseRequestUnitsInstruction(\n instruction: Instruction & InstructionWithData\n): ParsedRequestUnitsInstruction {\n return {\n programAddress: instruction.programAddress,\n data: getRequestUnitsInstructionDataDecoder().decode(instruction.data),\n };\n}\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n combineCodec,\n getStructDecoder,\n getStructEncoder,\n getU32Decoder,\n getU32Encoder,\n getU8Decoder,\n getU8Encoder,\n transformEncoder,\n type AccountMeta,\n type Address,\n type FixedSizeCodec,\n type FixedSizeDecoder,\n type FixedSizeEncoder,\n type Instruction,\n type InstructionWithAccounts,\n type InstructionWithData,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';\n\nexport const SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;\n\nexport function getSetComputeUnitLimitDiscriminatorBytes() {\n return getU8Encoder().encode(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR);\n}\n\nexport type SetComputeUnitLimitInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n TRemainingAccounts extends readonly AccountMeta[] = [],\n> = Instruction &\n InstructionWithData &\n InstructionWithAccounts;\n\nexport type SetComputeUnitLimitInstructionData = {\n discriminator: number;\n /** Transaction-wide compute unit limit. */\n units: number;\n};\n\nexport type SetComputeUnitLimitInstructionDataArgs = {\n /** Transaction-wide compute unit limit. */\n units: number;\n};\n\nexport function getSetComputeUnitLimitInstructionDataEncoder(): FixedSizeEncoder {\n return transformEncoder(\n getStructEncoder([\n ['discriminator', getU8Encoder()],\n ['units', getU32Encoder()],\n ]),\n (value) => ({\n ...value,\n discriminator: SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR,\n })\n );\n}\n\nexport function getSetComputeUnitLimitInstructionDataDecoder(): FixedSizeDecoder {\n return getStructDecoder([\n ['discriminator', getU8Decoder()],\n ['units', getU32Decoder()],\n ]);\n}\n\nexport function getSetComputeUnitLimitInstructionDataCodec(): FixedSizeCodec<\n SetComputeUnitLimitInstructionDataArgs,\n SetComputeUnitLimitInstructionData\n> {\n return combineCodec(\n getSetComputeUnitLimitInstructionDataEncoder(),\n getSetComputeUnitLimitInstructionDataDecoder()\n );\n}\n\nexport type SetComputeUnitLimitInput = {\n units: SetComputeUnitLimitInstructionDataArgs['units'];\n};\n\nexport function getSetComputeUnitLimitInstruction<\n TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n>(\n input: SetComputeUnitLimitInput,\n config?: { programAddress?: TProgramAddress }\n): SetComputeUnitLimitInstruction {\n // Program address.\n const programAddress =\n config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;\n\n // Original args.\n const args = { ...input };\n\n return Object.freeze({\n data: getSetComputeUnitLimitInstructionDataEncoder().encode(\n args as SetComputeUnitLimitInstructionDataArgs\n ),\n programAddress,\n } as SetComputeUnitLimitInstruction);\n}\n\nexport type ParsedSetComputeUnitLimitInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n> = {\n programAddress: Address;\n data: SetComputeUnitLimitInstructionData;\n};\n\nexport function parseSetComputeUnitLimitInstruction(\n instruction: Instruction & InstructionWithData\n): ParsedSetComputeUnitLimitInstruction {\n return {\n programAddress: instruction.programAddress,\n data: getSetComputeUnitLimitInstructionDataDecoder().decode(\n instruction.data\n ),\n };\n}\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n combineCodec,\n getStructDecoder,\n getStructEncoder,\n getU64Decoder,\n getU64Encoder,\n getU8Decoder,\n getU8Encoder,\n transformEncoder,\n type AccountMeta,\n type Address,\n type FixedSizeCodec,\n type FixedSizeDecoder,\n type FixedSizeEncoder,\n type Instruction,\n type InstructionWithAccounts,\n type InstructionWithData,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';\n\nexport const SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;\n\nexport function getSetComputeUnitPriceDiscriminatorBytes() {\n return getU8Encoder().encode(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR);\n}\n\nexport type SetComputeUnitPriceInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n TRemainingAccounts extends readonly AccountMeta[] = [],\n> = Instruction &\n InstructionWithData &\n InstructionWithAccounts;\n\nexport type SetComputeUnitPriceInstructionData = {\n discriminator: number;\n /** Transaction compute unit price used for prioritization fees. */\n microLamports: bigint;\n};\n\nexport type SetComputeUnitPriceInstructionDataArgs = {\n /** Transaction compute unit price used for prioritization fees. */\n microLamports: number | bigint;\n};\n\nexport function getSetComputeUnitPriceInstructionDataEncoder(): FixedSizeEncoder {\n return transformEncoder(\n getStructEncoder([\n ['discriminator', getU8Encoder()],\n ['microLamports', getU64Encoder()],\n ]),\n (value) => ({\n ...value,\n discriminator: SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR,\n })\n );\n}\n\nexport function getSetComputeUnitPriceInstructionDataDecoder(): FixedSizeDecoder {\n return getStructDecoder([\n ['discriminator', getU8Decoder()],\n ['microLamports', getU64Decoder()],\n ]);\n}\n\nexport function getSetComputeUnitPriceInstructionDataCodec(): FixedSizeCodec<\n SetComputeUnitPriceInstructionDataArgs,\n SetComputeUnitPriceInstructionData\n> {\n return combineCodec(\n getSetComputeUnitPriceInstructionDataEncoder(),\n getSetComputeUnitPriceInstructionDataDecoder()\n );\n}\n\nexport type SetComputeUnitPriceInput = {\n microLamports: SetComputeUnitPriceInstructionDataArgs['microLamports'];\n};\n\nexport function getSetComputeUnitPriceInstruction<\n TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n>(\n input: SetComputeUnitPriceInput,\n config?: { programAddress?: TProgramAddress }\n): SetComputeUnitPriceInstruction {\n // Program address.\n const programAddress =\n config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;\n\n // Original args.\n const args = { ...input };\n\n return Object.freeze({\n data: getSetComputeUnitPriceInstructionDataEncoder().encode(\n args as SetComputeUnitPriceInstructionDataArgs\n ),\n programAddress,\n } as SetComputeUnitPriceInstruction);\n}\n\nexport type ParsedSetComputeUnitPriceInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n> = {\n programAddress: Address;\n data: SetComputeUnitPriceInstructionData;\n};\n\nexport function parseSetComputeUnitPriceInstruction(\n instruction: Instruction & InstructionWithData\n): ParsedSetComputeUnitPriceInstruction {\n return {\n programAddress: instruction.programAddress,\n data: getSetComputeUnitPriceInstructionDataDecoder().decode(\n instruction.data\n ),\n };\n}\n","/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport {\n combineCodec,\n getStructDecoder,\n getStructEncoder,\n getU32Decoder,\n getU32Encoder,\n getU8Decoder,\n getU8Encoder,\n transformEncoder,\n type AccountMeta,\n type Address,\n type FixedSizeCodec,\n type FixedSizeDecoder,\n type FixedSizeEncoder,\n type Instruction,\n type InstructionWithAccounts,\n type InstructionWithData,\n type ReadonlyUint8Array,\n} from '@solana/kit';\nimport { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';\n\nexport const SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR = 4;\n\nexport function getSetLoadedAccountsDataSizeLimitDiscriminatorBytes() {\n return getU8Encoder().encode(\n SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR\n );\n}\n\nexport type SetLoadedAccountsDataSizeLimitInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n TRemainingAccounts extends readonly AccountMeta[] = [],\n> = Instruction &\n InstructionWithData &\n InstructionWithAccounts;\n\nexport type SetLoadedAccountsDataSizeLimitInstructionData = {\n discriminator: number;\n accountDataSizeLimit: number;\n};\n\nexport type SetLoadedAccountsDataSizeLimitInstructionDataArgs = {\n accountDataSizeLimit: number;\n};\n\nexport function getSetLoadedAccountsDataSizeLimitInstructionDataEncoder(): FixedSizeEncoder {\n return transformEncoder(\n getStructEncoder([\n ['discriminator', getU8Encoder()],\n ['accountDataSizeLimit', getU32Encoder()],\n ]),\n (value) => ({\n ...value,\n discriminator: SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR,\n })\n );\n}\n\nexport function getSetLoadedAccountsDataSizeLimitInstructionDataDecoder(): FixedSizeDecoder {\n return getStructDecoder([\n ['discriminator', getU8Decoder()],\n ['accountDataSizeLimit', getU32Decoder()],\n ]);\n}\n\nexport function getSetLoadedAccountsDataSizeLimitInstructionDataCodec(): FixedSizeCodec<\n SetLoadedAccountsDataSizeLimitInstructionDataArgs,\n SetLoadedAccountsDataSizeLimitInstructionData\n> {\n return combineCodec(\n getSetLoadedAccountsDataSizeLimitInstructionDataEncoder(),\n getSetLoadedAccountsDataSizeLimitInstructionDataDecoder()\n );\n}\n\nexport type SetLoadedAccountsDataSizeLimitInput = {\n accountDataSizeLimit: SetLoadedAccountsDataSizeLimitInstructionDataArgs['accountDataSizeLimit'];\n};\n\nexport function getSetLoadedAccountsDataSizeLimitInstruction<\n TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n>(\n input: SetLoadedAccountsDataSizeLimitInput,\n config?: { programAddress?: TProgramAddress }\n): SetLoadedAccountsDataSizeLimitInstruction {\n // Program address.\n const programAddress =\n config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;\n\n // Original args.\n const args = { ...input };\n\n return Object.freeze({\n data: getSetLoadedAccountsDataSizeLimitInstructionDataEncoder().encode(\n args as SetLoadedAccountsDataSizeLimitInstructionDataArgs\n ),\n programAddress,\n } as SetLoadedAccountsDataSizeLimitInstruction);\n}\n\nexport type ParsedSetLoadedAccountsDataSizeLimitInstruction<\n TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,\n> = {\n programAddress: Address;\n data: SetLoadedAccountsDataSizeLimitInstructionData;\n};\n\nexport function parseSetLoadedAccountsDataSizeLimitInstruction<\n TProgram extends string,\n>(\n instruction: Instruction & InstructionWithData\n): ParsedSetLoadedAccountsDataSizeLimitInstruction {\n return {\n programAddress: instruction.programAddress,\n data: getSetLoadedAccountsDataSizeLimitInstructionDataDecoder().decode(\n instruction.data\n ),\n };\n}\n","/**\n * A provisory compute unit limit is used to indicate that the transaction\n * should be estimated for compute units before being sent to the network.\n *\n * Setting it to zero ensures the transaction fails unless it is properly estimated.\n */\nexport const PROVISORY_COMPUTE_UNIT_LIMIT = 0;\n\n/**\n * The maximum compute unit limit that can be set for a transaction.\n */\nexport const MAX_COMPUTE_UNIT_LIMIT = 1_400_000;\n","import {\n BaseTransactionMessage,\n getU32Decoder,\n getU64Decoder,\n Instruction,\n MicroLamports,\n ReadonlyUint8Array,\n} from '@solana/kit';\nimport {\n COMPUTE_BUDGET_PROGRAM_ADDRESS,\n ComputeBudgetInstruction,\n identifyComputeBudgetInstruction,\n SetComputeUnitLimitInstruction,\n SetComputeUnitPriceInstruction,\n} from './generated';\n\n/**\n * Finds the index of the first `SetComputeUnitLimit` instruction in a transaction message\n * and its set limit, if any.\n */\nexport function getSetComputeUnitLimitInstructionIndexAndUnits(\n transactionMessage: BaseTransactionMessage\n): { index: number; units: number } | null {\n const index = getSetComputeUnitLimitInstructionIndex(transactionMessage);\n if (index < 0) {\n return null;\n }\n\n const units = getU32Decoder().decode(\n transactionMessage.instructions[index].data as ReadonlyUint8Array,\n 1\n );\n\n return { index, units };\n}\n\n/**\n * Finds the index of the first `SetComputeUnitLimit` instruction in a transaction message, if any.\n */\nexport function getSetComputeUnitLimitInstructionIndex(\n transactionMessage: BaseTransactionMessage\n) {\n return transactionMessage.instructions.findIndex(\n isSetComputeUnitLimitInstruction\n );\n}\n\n/**\n * Checks if the given instruction is a `SetComputeUnitLimit` instruction.\n */\nexport function isSetComputeUnitLimitInstruction(\n instruction: Instruction\n): instruction is SetComputeUnitLimitInstruction {\n return (\n instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS &&\n identifyComputeBudgetInstruction(instruction.data as Uint8Array) ===\n ComputeBudgetInstruction.SetComputeUnitLimit\n );\n}\n\n/**\n * Finds the index of the first `SetComputeUnitPrice` instruction in a transaction message\n * and its set micro-lamports, if any.\n */\nexport function getSetComputeUnitPriceInstructionIndexAndMicroLamports(\n transactionMessage: BaseTransactionMessage\n): { index: number; microLamports: MicroLamports } | null {\n const index = getSetComputeUnitPriceInstructionIndex(transactionMessage);\n if (index < 0) {\n return null;\n }\n\n const microLamports = getU64Decoder().decode(\n transactionMessage.instructions[index].data as ReadonlyUint8Array,\n 1\n ) as MicroLamports;\n\n return { index, microLamports };\n}\n\n/**\n * Finds the index of the first `SetComputeUnitPrice` instruction in a transaction message, if any.\n */\nexport function getSetComputeUnitPriceInstructionIndex(\n transactionMessage: BaseTransactionMessage\n) {\n return transactionMessage.instructions.findIndex(\n isSetComputeUnitPriceInstruction\n );\n}\n\n/**\n * Checks if the given instruction is a `SetComputeUnitPrice` instruction.\n */\nexport function isSetComputeUnitPriceInstruction(\n instruction: Instruction\n): instruction is SetComputeUnitPriceInstruction {\n return (\n instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS &&\n identifyComputeBudgetInstruction(instruction.data as Uint8Array) ===\n ComputeBudgetInstruction.SetComputeUnitPrice\n );\n}\n","import {\n appendTransactionMessageInstruction,\n BaseTransactionMessage,\n} from '@solana/kit';\nimport { PROVISORY_COMPUTE_UNIT_LIMIT } from './constants';\nimport { getSetComputeUnitLimitInstruction } from './generated';\nimport { getSetComputeUnitLimitInstructionIndexAndUnits } from './internal';\n\n/**\n * Appends a `SetComputeUnitLimit` instruction with a provisory\n * compute unit limit to a given transaction message\n * if and only if it does not already have one.\n *\n * @example\n * ```ts\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 0 }),\n * fillProvisorySetComputeUnitLimitInstruction,\n * // ...\n * );\n * ```\n */\nexport function fillProvisorySetComputeUnitLimitInstruction<\n TTransactionMessage extends BaseTransactionMessage,\n>(transactionMessage: TTransactionMessage) {\n return updateOrAppendSetComputeUnitLimitInstruction(\n (previousUnits) =>\n previousUnits === null ? PROVISORY_COMPUTE_UNIT_LIMIT : previousUnits,\n transactionMessage\n );\n}\n\n/**\n * Updates the first `SetComputeUnitLimit` instruction in a transaction message\n * with the given units, or appends a new instruction if none exists.\n * A function of the current value can be provided instead of a static value.\n *\n * @param units - The new compute unit limit, or a function that takes the previous\n * compute unit limit and returns the new limit.\n * @param transactionMessage - The transaction message to update.\n *\n * @example\n * ```ts\n * const updatedTransactionMessage = updateOrAppendSetComputeUnitLimitInstruction(\n * // E.g. Keep the current limit if it is set, otherwise set it to the maximum.\n * (currentUnits) => currentUnits === null ? MAX_COMPUTE_UNIT_LIMIT : currentUnits,\n * transactionMessage,\n * );\n * ```\n */\nexport function updateOrAppendSetComputeUnitLimitInstruction<\n TTransactionMessage extends BaseTransactionMessage,\n>(\n units: number | ((previousUnits: number | null) => number),\n transactionMessage: TTransactionMessage\n): TTransactionMessage {\n const getUnits = (previousUnits: number | null): number =>\n typeof units === 'function' ? units(previousUnits) : units;\n const instructionDetails =\n getSetComputeUnitLimitInstructionIndexAndUnits(transactionMessage);\n\n if (!instructionDetails) {\n return appendTransactionMessageInstruction(\n getSetComputeUnitLimitInstruction({ units: getUnits(null) }),\n transactionMessage\n ) as unknown as TTransactionMessage;\n }\n\n const { index, units: previousUnits } = instructionDetails;\n const newUnits = getUnits(previousUnits);\n if (newUnits === previousUnits) {\n return transactionMessage;\n }\n\n const newInstruction = getSetComputeUnitLimitInstruction({ units: newUnits });\n const newInstructions = [...transactionMessage.instructions];\n newInstructions.splice(index, 1, newInstruction);\n return Object.freeze({\n ...transactionMessage,\n instructions: newInstructions,\n });\n}\n","import {\n BaseTransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nimport {\n MAX_COMPUTE_UNIT_LIMIT,\n PROVISORY_COMPUTE_UNIT_LIMIT,\n} from './constants';\nimport {\n EstimateComputeUnitLimitFactoryFunction,\n EstimateComputeUnitLimitFactoryFunctionConfig,\n} from './estimateComputeLimitInternal';\nimport { getSetComputeUnitLimitInstructionIndexAndUnits } from './internal';\nimport { updateOrAppendSetComputeUnitLimitInstruction } from './setComputeLimit';\n\ntype EstimateAndUpdateProvisoryComputeUnitLimitFactoryFunction = <\n TTransactionMessage extends BaseTransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n transactionMessage: TTransactionMessage,\n config?: EstimateComputeUnitLimitFactoryFunctionConfig\n) => Promise;\n\n/**\n * Given a transaction message, if it does not have an explicit compute unit limit,\n * estimates the compute unit limit and updates the transaction message with\n * the estimated limit. Otherwise, returns the transaction message unchanged.\n *\n * It requires a function that estimates the compute unit limit.\n *\n * @example\n * ```ts\n * const estimateAndUpdateCUs = estimateAndUpdateProvisoryComputeUnitLimitFactory(\n * estimateComputeUnitLimitFactory({ rpc })\n * );\n *\n * const transactionMessageWithCUs = await estimateAndUpdateCUs(transactionMessage);\n * ```\n *\n * @see {@link estimateAndUpdateProvisoryComputeUnitLimitFactory}\n */\nexport function estimateAndUpdateProvisoryComputeUnitLimitFactory(\n estimateComputeUnitLimit: EstimateComputeUnitLimitFactoryFunction\n): EstimateAndUpdateProvisoryComputeUnitLimitFactoryFunction {\n return async function fn(transactionMessage, config) {\n const instructionDetails =\n getSetComputeUnitLimitInstructionIndexAndUnits(transactionMessage);\n\n // If the transaction message already has a compute unit limit instruction\n // which is set to a specific value — i.e. not 0 or the maximum limit —\n // we don't need to estimate the compute unit limit.\n if (\n instructionDetails &&\n instructionDetails.units !== PROVISORY_COMPUTE_UNIT_LIMIT &&\n instructionDetails.units !== MAX_COMPUTE_UNIT_LIMIT\n ) {\n return transactionMessage;\n }\n\n return updateOrAppendSetComputeUnitLimitInstruction(\n await estimateComputeUnitLimit(transactionMessage, config),\n transactionMessage\n );\n };\n}\n","import {\n BaseTransactionMessage,\n Commitment,\n compileTransaction,\n getBase64EncodedWireTransaction,\n isSolanaError,\n isTransactionMessageWithDurableNonceLifetime,\n pipe,\n Rpc,\n SimulateTransactionApi,\n Slot,\n SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT,\n SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT,\n SolanaError,\n Transaction,\n TransactionMessageWithFeePayer,\n} from '@solana/kit';\nimport { updateOrAppendSetComputeUnitLimitInstruction } from './setComputeLimit';\nimport { MAX_COMPUTE_UNIT_LIMIT } from './constants';\n\nexport type EstimateComputeUnitLimitFactoryConfig = Readonly<{\n /** An object that supports the {@link SimulateTransactionApi} of the Solana RPC API */\n rpc: Rpc;\n}>;\n\nexport type EstimateComputeUnitLimitFactoryFunction = (\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer,\n config?: EstimateComputeUnitLimitFactoryFunctionConfig\n) => Promise;\n\nexport type EstimateComputeUnitLimitFactoryFunctionConfig = {\n abortSignal?: AbortSignal;\n /**\n * Compute the estimate as of the highest slot that has reached this level of commitment.\n *\n * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use. For\n * example, when using an API created by a `createSolanaRpc*()` helper, the default commitment\n * is `\"confirmed\"` unless configured otherwise. Unmitigated by an API layer on the client, the\n * default commitment applied by the server is `\"finalized\"`.\n */\n commitment?: Commitment;\n /**\n * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to\n * this slot\n */\n minContextSlot?: Slot;\n};\n\ntype EstimateComputeUnitLimitConfig =\n EstimateComputeUnitLimitFactoryFunctionConfig &\n Readonly<{\n rpc: Rpc;\n transactionMessage: BaseTransactionMessage &\n TransactionMessageWithFeePayer;\n }>;\n\n/**\n * Simulates a transaction message on the network and returns the number of compute units it\n * consumed during simulation.\n *\n * The estimate this function returns can be used to set a compute unit limit on the transaction.\n * Correctly budgeting a compute unit limit for your transaction message can increase the probability\n * that your transaction will be accepted for processing.\n *\n * If you don't declare a compute unit limit on your transaction, validators will assume an upper\n * limit of 200K compute units (CU) per instruction. Since validators have an incentive to pack as\n * many transactions into each block as possible, they may choose to include transactions that they\n * know will fit into the remaining compute budget for the current block over transactions that\n * might not. For this reason, you should set a compute unit limit on each of your transaction\n * messages, whenever possible.\n *\n * ## Example\n *\n * ```ts\n * import { getSetComputeLimitInstruction } from '@solana-program/compute-budget';\n * import { createSolanaRpc, getComputeUnitEstimateForTransactionMessageFactory, pipe } from '@solana/kit';\n *\n * // Create an estimator function.\n * const rpc = createSolanaRpc('http://127.0.0.1:8899');\n * const getComputeUnitEstimateForTransactionMessage =\n * getComputeUnitEstimateForTransactionMessageFactory({ rpc });\n *\n * // Create your transaction message.\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 'legacy' }),\n * /* ... *\\/\n * );\n *\n * // Request an estimate of the actual compute units this message will consume.\n * const computeUnitsEstimate =\n * await getComputeUnitEstimateForTransactionMessage(transactionMessage);\n *\n * // Set the transaction message's compute unit budget.\n * const transactionMessageWithComputeUnitLimit = prependTransactionMessageInstruction(\n * getSetComputeLimitInstruction({ units: computeUnitsEstimate }),\n * transactionMessage,\n * );\n * ```\n *\n * > [!WARNING]\n * > The compute unit estimate is just that – an estimate. The compute unit consumption of the\n * > actual transaction might be higher or lower than what was observed in simulation. Unless you\n * > are confident that your particular transaction message will consume the same or fewer compute\n * > units as was estimated, you might like to augment the estimate by either a fixed number of CUs\n * > or a multiplier.\n *\n * > [!NOTE]\n * > If you are preparing an _unsigned_ transaction, destined to be signed and submitted to the\n * > network by a wallet, you might like to leave it up to the wallet to determine the compute unit\n * > limit. Consider that the wallet might have a more global view of how many compute units certain\n * > types of transactions consume, and might be able to make better estimates of an appropriate\n * > compute unit budget.\n */\nexport async function estimateComputeUnitLimit({\n transactionMessage,\n ...configs\n}: EstimateComputeUnitLimitConfig): Promise {\n const replaceRecentBlockhash =\n !isTransactionMessageWithDurableNonceLifetime(transactionMessage);\n const transaction = pipe(\n transactionMessage,\n (m) =>\n updateOrAppendSetComputeUnitLimitInstruction(MAX_COMPUTE_UNIT_LIMIT, m),\n compileTransaction\n );\n\n return await simulateTransactionAndGetConsumedUnits({\n transaction,\n replaceRecentBlockhash,\n ...configs,\n });\n}\n\ntype SimulateTransactionAndGetConsumedUnitsConfig = Omit<\n EstimateComputeUnitLimitConfig,\n 'transactionMessage'\n> &\n Readonly<{ replaceRecentBlockhash?: boolean; transaction: Transaction }>;\n\nasync function simulateTransactionAndGetConsumedUnits({\n abortSignal,\n rpc,\n transaction,\n ...simulateConfig\n}: SimulateTransactionAndGetConsumedUnitsConfig): Promise {\n const wireTransactionBytes = getBase64EncodedWireTransaction(transaction);\n\n try {\n const {\n value: { err: transactionError, unitsConsumed },\n } = await rpc\n .simulateTransaction(wireTransactionBytes, {\n ...simulateConfig,\n encoding: 'base64',\n sigVerify: false,\n })\n .send({ abortSignal });\n if (unitsConsumed == null) {\n // This should never be hit, because all RPCs should support `unitsConsumed` by now.\n throw new SolanaError(\n SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT\n );\n }\n // FIXME(https://github.com/anza-xyz/agave/issues/1295): The simulation response returns\n // compute units as a u64, but the `SetComputeLimit` instruction only accepts a u32. Until\n // this changes, downcast it.\n const downcastUnitsConsumed =\n unitsConsumed > 4_294_967_295n ? 4_294_967_295 : Number(unitsConsumed);\n if (transactionError) {\n throw new SolanaError(\n SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT,\n {\n cause: transactionError,\n unitsConsumed: downcastUnitsConsumed,\n }\n );\n }\n return downcastUnitsConsumed;\n } catch (e) {\n if (\n isSolanaError(\n e,\n SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT\n )\n )\n throw e;\n throw new SolanaError(\n SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT,\n { cause: e }\n );\n }\n}\n","import {\n estimateComputeUnitLimit,\n EstimateComputeUnitLimitFactoryConfig,\n EstimateComputeUnitLimitFactoryFunction,\n} from './estimateComputeLimitInternal';\n\n/**\n * Use this utility to estimate the actual compute unit cost of a given transaction message.\n *\n * Correctly budgeting a compute unit limit for your transaction message can increase the\n * probability that your transaction will be accepted for processing. If you don't declare a compute\n * unit limit on your transaction, validators will assume an upper limit of 200K compute units (CU)\n * per instruction.\n *\n * Since validators have an incentive to pack as many transactions into each block as possible, they\n * may choose to include transactions that they know will fit into the remaining compute budget for\n * the current block over transactions that might not. For this reason, you should set a compute\n * unit limit on each of your transaction messages, whenever possible.\n *\n * > [!WARNING]\n * > The compute unit estimate is just that -- an estimate. The compute unit consumption of the\n * > actual transaction might be higher or lower than what was observed in simulation. Unless you\n * > are confident that your particular transaction message will consume the same or fewer compute\n * > units as was estimated, you might like to augment the estimate by either a fixed number of CUs\n * > or a multiplier.\n *\n * > [!NOTE]\n * > If you are preparing an _unsigned_ transaction, destined to be signed and submitted to the\n * > network by a wallet, you might like to leave it up to the wallet to determine the compute unit\n * > limit. Consider that the wallet might have a more global view of how many compute units certain\n * > types of transactions consume, and might be able to make better estimates of an appropriate\n * > compute unit budget.\n *\n * > [!INFO]\n * > In the event that a transaction message does not already have a `SetComputeUnitLimit`\n * > instruction, this function will add one before simulation. This ensures that the compute unit\n * > consumption of the `SetComputeUnitLimit` instruction itself is included in the estimate.\n *\n * @param config\n *\n * @example\n * ```ts\n * import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';\n * import { createSolanaRpc, estimateComputeUnitLimitFactory, pipe } from '@solana/kit';\n *\n * // Create an estimator function.\n * const rpc = createSolanaRpc('http://127.0.0.1:8899');\n * const estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });\n *\n * // Create your transaction message.\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 'legacy' }),\n * /* ... *\\/\n * );\n *\n * // Request an estimate of the actual compute units this message will consume. This is done by\n * // simulating the transaction and grabbing the estimated compute units from the result.\n * const estimatedUnits = await estimateComputeUnitLimit(transactionMessage);\n *\n * // Set the transaction message's compute unit budget.\n * const transactionMessageWithComputeUnitLimit = prependTransactionMessageInstruction(\n * getSetComputeUnitLimitInstruction({ units: estimatedUnits }),\n * transactionMessage,\n * );\n * ```\n */\nexport function estimateComputeUnitLimitFactory({\n rpc,\n}: EstimateComputeUnitLimitFactoryConfig): EstimateComputeUnitLimitFactoryFunction {\n return async function estimateComputeUnitLimitFactoryFunction(\n transactionMessage,\n config\n ) {\n return await estimateComputeUnitLimit({\n ...config,\n rpc,\n transactionMessage,\n });\n };\n}\n","import {\n appendTransactionMessageInstruction,\n BaseTransactionMessage,\n MicroLamports,\n} from '@solana/kit';\nimport { getSetComputeUnitPriceInstruction } from './generated';\nimport { getSetComputeUnitPriceInstructionIndexAndMicroLamports } from './internal';\n\n/**\n * Sets the compute unit price of a transaction message in micro-Lamports.\n *\n * @example\n * ```ts\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 0 }),\n * (m) => setTransactionMessageComputeUnitPrice(10_000, m),\n * // ...\n * );\n * ```\n */\nexport function setTransactionMessageComputeUnitPrice<\n TTransactionMessage extends BaseTransactionMessage,\n>(microLamports: number | bigint, transactionMessage: TTransactionMessage) {\n return appendTransactionMessageInstruction(\n getSetComputeUnitPriceInstruction({ microLamports }),\n transactionMessage\n );\n}\n\n/**\n * Updates the first `SetComputeUnitPrice` instruction in a transaction message\n * with the given micro-Lamports, or appends a new instruction if none exists.\n * A function of the current value can be provided instead of a static value.\n *\n * @param microLamports - The new compute unit price, or a function that\n * takes the previous price and returns the new one.\n * @param transactionMessage - The transaction message to update.\n *\n * @example\n * ```ts\n * const updatedTransactionMessage = updateOrAppendSetComputeUnitPriceInstruction(\n * // E.g. double the current price or set it to 10_000 if it isn't set.\n * (currentPrice) => currentPrice === null ? 10_000 : currentPrice * 2,\n * transactionMessage,\n * );\n * ```\n */\nexport function updateOrAppendSetComputeUnitPriceInstruction<\n TTransactionMessage extends BaseTransactionMessage,\n>(\n microLamports:\n | MicroLamports\n | ((previousMicroLamports: MicroLamports | null) => MicroLamports),\n transactionMessage: TTransactionMessage\n): TTransactionMessage {\n const getMicroLamports = (\n previousMicroLamports: MicroLamports | null\n ): MicroLamports =>\n typeof microLamports === 'function'\n ? microLamports(previousMicroLamports)\n : microLamports;\n const instructionDetails =\n getSetComputeUnitPriceInstructionIndexAndMicroLamports(transactionMessage);\n\n if (!instructionDetails) {\n return appendTransactionMessageInstruction(\n getSetComputeUnitPriceInstruction({\n microLamports: getMicroLamports(null),\n }),\n transactionMessage\n ) as unknown as TTransactionMessage;\n }\n\n const { index, microLamports: previousMicroLamports } = instructionDetails;\n const newMicroLamports = getMicroLamports(previousMicroLamports);\n if (newMicroLamports === previousMicroLamports) {\n return transactionMessage;\n }\n\n const newInstruction = getSetComputeUnitPriceInstruction({\n microLamports: newMicroLamports,\n });\n const newInstructions = [...transactionMessage.instructions];\n newInstructions.splice(index, 1, newInstruction);\n return Object.freeze({\n ...transactionMessage,\n instructions: newInstructions,\n });\n}\n"]}