@pythnetwork/pyth-solana-receiver 0.12.0 → 0.14.0

package/{lib → dist/cjs}/idl/wormhole_core_bridge_solana.d.ts

@@ -1604,4 +1604,3 @@ export type WormholeCoreBridgeSolana = {
     ];
 };
 export declare const IDL: WormholeCoreBridgeSolana;
-//# sourceMappingURL=wormhole_core_bridge_solana.d.ts.map

package/dist/cjs/index.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_RECEIVER_PROGRAM_ID () {
+        return _address.DEFAULT_RECEIVER_PROGRAM_ID;
+    },
+    get DEFAULT_WORMHOLE_PROGRAM_ID () {
+        return _address.DEFAULT_WORMHOLE_PROGRAM_ID;
+    },
+    get PythSolanaReceiver () {
+        return _PythSolanaReceiver.PythSolanaReceiver;
+    },
+    get PythTransactionBuilder () {
+        return _PythSolanaReceiver.PythTransactionBuilder;
+    },
+    get TransactionBuilder () {
+        return _solanautils.TransactionBuilder;
+    },
+    get getConfigPda () {
+        return _address.getConfigPda;
+    },
+    get getPriceFeedAccountForProgram () {
+        return _PythSolanaReceiver.getPriceFeedAccountForProgram;
+    },
+    get pythSolanaReceiverIdl () {
+        return _pyth_solana_receiver.IDL;
+    },
+    get wormholeCoreBridgeIdl () {
+        return _wormhole_core_bridge_solana.IDL;
+    }
+});
+const _PythSolanaReceiver = require("./PythSolanaReceiver.cjs");
+const _solanautils = require("@pythnetwork/solana-utils");
+const _address = require("./address.cjs");
+const _pyth_solana_receiver = require("./idl/pyth_solana_receiver.cjs");
+const _wormhole_core_bridge_solana = require("./idl/wormhole_core_bridge_solana.cjs");

package/dist/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export { PythSolanaReceiver, PythTransactionBuilder, getPriceFeedAccountForProgram, } from "./PythSolanaReceiver";
+export { TransactionBuilder, type InstructionWithEphemeralSigners, } from "@pythnetwork/solana-utils";
+export { getConfigPda, DEFAULT_RECEIVER_PROGRAM_ID, DEFAULT_WORMHOLE_PROGRAM_ID, } from "./address";
+export { IDL as pythSolanaReceiverIdl, type PythSolanaReceiver as PythSolanaReceiverProgram, } from "./idl/pyth_solana_receiver";
+export { IDL as wormholeCoreBridgeIdl, type WormholeCoreBridgeSolana as WormholeCoreBridgeProgram, } from "./idl/wormhole_core_bridge_solana";

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/vaa.cjs

@@ -0,0 +1,192 @@
+// eslint-disable-next-line unicorn/prefer-node-protocol
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_REDUCED_GUARDIAN_SET_SIZE () {
+        return DEFAULT_REDUCED_GUARDIAN_SET_SIZE;
+    },
+    get VAA_SIGNATURE_SIZE () {
+        return VAA_SIGNATURE_SIZE;
+    },
+    get VAA_SPLIT_INDEX () {
+        return VAA_SPLIT_INDEX;
+    },
+    get VAA_START () {
+        return VAA_START;
+    },
+    get buildCloseEncodedVaaInstruction () {
+        return buildCloseEncodedVaaInstruction;
+    },
+    get buildEncodedVaaCreateInstruction () {
+        return buildEncodedVaaCreateInstruction;
+    },
+    get buildPostEncodedVaaInstructions () {
+        return buildPostEncodedVaaInstructions;
+    },
+    get findEncodedVaaAccountsByWriteAuthority () {
+        return findEncodedVaaAccountsByWriteAuthority;
+    },
+    get getGuardianSetIndex () {
+        return getGuardianSetIndex;
+    },
+    get trimSignatures () {
+        return trimSignatures;
+    }
+});
+const _buffer = require("buffer");
+const _bytes = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const _sha256 = require("@noble/hashes/sha256");
+const _web3 = require("@solana/web3.js");
+const _address = require("./address.cjs");
+const _compute_budget = require("./compute_budget.cjs");
+function getGuardianSetIndex(vaa) {
+    return vaa.readUInt32BE(1);
+}
+const DEFAULT_REDUCED_GUARDIAN_SET_SIZE = 5;
+const VAA_SIGNATURE_SIZE = 66;
+const VAA_START = 46;
+const VAA_SPLIT_INDEX = 721;
+function trimSignatures(vaa, n = DEFAULT_REDUCED_GUARDIAN_SET_SIZE) {
+    const currentNumSignatures = vaa[5];
+    if (currentNumSignatures === undefined) {
+        throw new Error("vaa[5] is undefined");
+    }
+    if (n > currentNumSignatures) {
+        throw new Error("Resulting VAA can't have more signatures than the original VAA");
+    }
+    const trimmedVaa = _buffer.Buffer.concat([
+        vaa.subarray(0, 6 + n * VAA_SIGNATURE_SIZE),
+        vaa.subarray(6 + currentNumSignatures * VAA_SIGNATURE_SIZE)
+    ]);
+    trimmedVaa[5] = n;
+    return trimmedVaa;
+}
+// Core function to generate VAA instruction groups
+async function generateVaaInstructionGroups(wormhole, vaa) {
+    const encodedVaaKeypair = new _web3.Keypair();
+    // Create and init instructions
+    const initInstructions = [
+        await buildEncodedVaaCreateInstruction(wormhole, vaa, encodedVaaKeypair),
+        {
+            instruction: await wormhole.methods.initEncodedVaa().accounts({
+                encodedVaa: encodedVaaKeypair.publicKey
+            }).instruction(),
+            signers: [],
+            computeUnits: _compute_budget.INIT_ENCODED_VAA_COMPUTE_BUDGET
+        }
+    ];
+    // First write instruction
+    const writeFirstPartInstructions = [
+        {
+            instruction: await wormhole.methods.writeEncodedVaa({
+                index: 0,
+                data: vaa.subarray(0, VAA_SPLIT_INDEX)
+            }).accounts({
+                draftVaa: encodedVaaKeypair.publicKey
+            }).instruction(),
+            signers: [],
+            computeUnits: _compute_budget.WRITE_ENCODED_VAA_COMPUTE_BUDGET
+        }
+    ];
+    // Second write and verify instructions
+    const writeSecondPartAndVerifyInstructions = [];
+    // The second write instruction is only needed if there are more bytes past the split index in the VAA
+    if (vaa.length > VAA_SPLIT_INDEX) {
+        writeSecondPartAndVerifyInstructions.push({
+            instruction: await wormhole.methods.writeEncodedVaa({
+                index: VAA_SPLIT_INDEX,
+                data: vaa.subarray(VAA_SPLIT_INDEX)
+            }).accounts({
+                draftVaa: encodedVaaKeypair.publicKey
+            }).instruction(),
+            signers: [],
+            computeUnits: _compute_budget.WRITE_ENCODED_VAA_COMPUTE_BUDGET
+        });
+    }
+    writeSecondPartAndVerifyInstructions.push({
+        instruction: await wormhole.methods.verifyEncodedVaaV1().accounts({
+            guardianSet: (0, _address.getGuardianSetPda)(getGuardianSetIndex(vaa), wormhole.programId),
+            draftVaa: encodedVaaKeypair.publicKey
+        }).instruction(),
+        signers: [],
+        computeUnits: _compute_budget.VERIFY_ENCODED_VAA_COMPUTE_BUDGET
+    });
+    // Close instructions
+    const closeInstructions = [
+        {
+            instruction: await wormhole.methods.closeEncodedVaa().accounts({
+                encodedVaa: encodedVaaKeypair.publicKey
+            }).instruction(),
+            signers: [],
+            computeUnits: _compute_budget.CLOSE_ENCODED_VAA_COMPUTE_BUDGET
+        }
+    ];
+    return {
+        initInstructions,
+        writeFirstPartInstructions,
+        writeSecondPartAndVerifyInstructions,
+        closeInstructions,
+        encodedVaaAddress: encodedVaaKeypair.publicKey
+    };
+}
+async function buildPostEncodedVaaInstructions(wormhole, vaa) {
+    const groups = await generateVaaInstructionGroups(wormhole, vaa);
+    // Pack instructions for optimal 2-transaction pattern:
+    // TX1: init + first write
+    // TX2: second write + verify
+    return {
+        encodedVaaAddress: groups.encodedVaaAddress,
+        postInstructions: [
+            ...groups.initInstructions,
+            ...groups.writeFirstPartInstructions,
+            ...groups.writeSecondPartAndVerifyInstructions
+        ],
+        closeInstructions: groups.closeInstructions
+    };
+}
+async function buildCloseEncodedVaaInstruction(wormhole, encodedVaa) {
+    const instruction = await wormhole.methods.closeEncodedVaa().accounts({
+        encodedVaa
+    }).instruction();
+    return {
+        instruction,
+        signers: [],
+        computeUnits: _compute_budget.CLOSE_ENCODED_VAA_COMPUTE_BUDGET
+    };
+}
+async function buildEncodedVaaCreateInstruction(wormhole, vaa, encodedVaaKeypair) {
+    const encodedVaaSize = vaa.length + VAA_START;
+    return {
+        instruction: await wormhole.account.encodedVaa.createInstruction(encodedVaaKeypair, encodedVaaSize),
+        signers: [
+            encodedVaaKeypair
+        ]
+    };
+}
+async function findEncodedVaaAccountsByWriteAuthority(connection, writeAuthority, wormholeProgramId) {
+    const result = await connection.getProgramAccounts(wormholeProgramId, {
+        filters: [
+            {
+                memcmp: {
+                    offset: 0,
+                    bytes: _bytes.bs58.encode(_buffer.Buffer.from((0, _sha256.sha256)("account:EncodedVaa").slice(0, 8)))
+                }
+            },
+            {
+                memcmp: {
+                    offset: 8 + 1,
+                    bytes: _bytes.bs58.encode(writeAuthority.toBuffer())
+                }
+            }
+        ]
+    });
+    return result.map((account)=>new _web3.PublicKey(account.pubkey));
+}

package/{lib → dist/cjs}/vaa.d.ts

@@ -1,8 +1,7 @@
-import { Connection, Keypair, PublicKey } from "@solana/web3.js";
-import { WormholeCoreBridgeSolana } from "./idl/wormhole_core_bridge_solana";
 import { Program } from "@coral-xyz/anchor";
-import { InstructionWithEphemeralSigners } from "@pythnetwork/solana-utils";
-import { AccumulatorUpdateData } from "@pythnetwork/price-service-sdk";
+import type { InstructionWithEphemeralSigners } from "@pythnetwork/solana-utils";
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import type { WormholeCoreBridgeSolana } from "./idl/wormhole_core_bridge_solana";
 /**
  * Get the index of the guardian set that signed a VAA
  */
@@ -49,7 +48,7 @@ export declare function trimSignatures(vaa: Buffer, n?: number): Buffer;
  *
  * @param wormhole - The Wormhole program instance
  * @param vaa - The VAA buffer to post
- * @returns {Object} Result containing:
+ * @returns Result containing:
  *   - encodedVaaAddress: Public key of the encoded VAA account
  *   - postInstructions: Instructions to post and verify the VAA
  *   - closeInstructions: Instructions to close the encoded VAA account and recover rent
@@ -59,30 +58,6 @@ export declare function buildPostEncodedVaaInstructions(wormhole: Program<Wormho
     postInstructions: InstructionWithEphemeralSigners[];
     closeInstructions: InstructionWithEphemeralSigners[];
 }>;
-/**
- * Build instructions to post two VAAs for TWAP (Time-Weighted Average Price) calculations,
- * optimized for 3 transactions. This is specifically designed for posting start and end
- * accumulator update VAAs efficiently.
- * The instructions are packed into 3 transactions:
- * - TX1: Initialize and write first part of start VAA
- * - TX2: Initialize and write first part of end VAA
- * - TX3: Write second part and verify both VAAs
- *
- * @param wormhole - The Wormhole program instance
- * @param startUpdateData - Accumulator update data containing the start VAA
- * @param endUpdateData - Accumulator update data containing the end VAA
- * @returns {Object} Result containing:
- *   - startEncodedVaaAddress: Public key of the start VAA account
- *   - endEncodedVaaAddress: Public key of the end VAA account
- *   - postInstructions: Instructions to post and verify both VAAs
- *   - closeInstructions: Instructions to close both encoded VAA accounts
- */
-export declare function buildPostEncodedVaasForTwapInstructions(wormhole: Program<WormholeCoreBridgeSolana>, startUpdateData: AccumulatorUpdateData, endUpdateData: AccumulatorUpdateData): Promise<{
-    startEncodedVaaAddress: PublicKey;
-    endEncodedVaaAddress: PublicKey;
-    postInstructions: InstructionWithEphemeralSigners[];
-    closeInstructions: InstructionWithEphemeralSigners[];
-}>;
 /**
  * Build an instruction to close an encoded VAA account, recovering the rent.
  */
@@ -98,4 +73,3 @@ export declare function buildEncodedVaaCreateInstruction(wormhole: Program<Wormh
  * @returns a list of the public keys of the encoded VAA accounts
  */
 export declare function findEncodedVaaAccountsByWriteAuthority(connection: Connection, writeAuthority: PublicKey, wormholeProgramId: PublicKey): Promise<PublicKey[]>;
-//# sourceMappingURL=vaa.d.ts.map

package/dist/esm/PythSolanaReceiver.d.ts

@@ -0,0 +1,318 @@
+import type { IdlAccounts } from "@coral-xyz/anchor";
+import { AnchorProvider, Program, Wallet } from "@coral-xyz/anchor";
+import type { InstructionWithEphemeralSigners, PriorityFeeConfig } from "@pythnetwork/solana-utils";
+import { TransactionBuilder } from "@pythnetwork/solana-utils";
+import type { Signer } from "@solana/web3.js";
+import { AddressLookupTableAccount, Connection, Transaction, VersionedTransaction, PublicKey } from "@solana/web3.js";
+import type { PythPushOracle } from "./idl/pyth_push_oracle";
+import type { PythSolanaReceiver as PythSolanaReceiverProgram } from "./idl/pyth_solana_receiver";
+import type { WormholeCoreBridgeSolana } from "./idl/wormhole_core_bridge_solana";
+export type PriceUpdateAccount = IdlAccounts<PythSolanaReceiverProgram>["priceUpdateV2"];
+/**
+ * Configuration for the PythTransactionBuilder
+ * @property closeUpdateAccounts (default: true) if true, the builder will add instructions to close the price update accounts and the encoded vaa accounts to recover the rent
+ */
+export type PythTransactionBuilderConfig = {
+    closeUpdateAccounts?: boolean;
+};
+/**
+ * A stable treasury ID. This ID's corresponding treasury address
+ * can be cached in an account lookup table in order to reduce the overall txn size.
+ */
+export declare const DEFAULT_TREASURY_ID = 0;
+/**
+ * A builder class to build transactions that:
+ * - Post price updates (fully or partially verified) or update price feed accounts
+ * - Consume price updates in a consumer program
+ * - (Optionally) Close price update and encoded vaa accounts to recover the rent (`closeUpdateAccounts` in `PythTransactionBuilderConfig`)
+ *
+ * This class provides methods for working with both price update accounts and price feed accounts.
+ * Price update accounts are ephemeral accounts containing a single price update, whereas price feed accounts are long-lived
+ * accounts that always hold price data for a specific feed id. Price feed accounts can be updated to advance the current price.
+ * Applications should choose which type of account to work with based on their needs. In general, applications that
+ * want the price at a specific time (e.g., to settle a trade) should use price update accounts, while applications that want
+ * any recent price should use price feed accounts.
+ *
+ * @example
+ * ```typescript
+ *
+ * // Get the price feed ids from https://pyth.network/developers/price-feed-ids#pyth-evm-stable
+ *  const priceUpdateData = await priceServiceConnection.getLatestVaas([
+ *    SOL_PRICE_FEED_ID,
+ *    ETH_PRICE_FEED_ID,
+ *  ]);
+ *
+ * const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({});
+ * await transactionBuilder.addPostPriceUpdates(priceUpdateData);
+ * console.log("The SOL/USD price update will get posted to:", transactionBuilder.getPriceUpdateAccount(SOL_PRICE_FEED_ID).toBase58())
+ * await transactionBuilder.addPriceConsumerInstructions(...)
+ *
+ * await pythSolanaReceiver.provider.sendAll(await transactionBuilder.buildVersionedTransactions({computeUnitPriceMicroLamports:100000, tightComputeBudget: true}))
+ * ```
+ */
+export declare class PythTransactionBuilder extends TransactionBuilder {
+    readonly pythSolanaReceiver: PythSolanaReceiver;
+    readonly closeInstructions: InstructionWithEphemeralSigners[];
+    readonly priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
+    readonly closeUpdateAccounts: boolean;
+    constructor(pythSolanaReceiver: PythSolanaReceiver, config: PythTransactionBuilderConfig, addressLookupTable?: AddressLookupTableAccount);
+    /**
+     * Add instructions to post price updates to the builder.
+     * Use this function to post fully verified price updates from the present or from the past for your program to consume.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     *
+     * @example
+     * ```typescript
+     * // Get the price feed ids from https://pyth.network/developers/price-feed-ids#pyth-evm-stable
+     * const priceUpdateData = await priceServiceConnection.getLatestVaas([
+     *    SOL_PRICE_FEED_ID,
+     *    ETH_PRICE_FEED_ID,
+     * ]);
+     *
+     * const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({});
+     * await transactionBuilder.addPostPriceUpdates(priceUpdateData);
+     * console.log("The SOL/USD price update will get posted to:", transactionBuilder.getPriceUpdateAccount(SOL_PRICE_FEED_ID).toBase58())
+     * await transactionBuilder.addPriceConsumerInstructions(...)
+     * ```
+     */
+    addPostPriceUpdates(priceUpdateDataArray: string[]): Promise<void>;
+    /**
+     * Add instructions to post partially verified price updates to the builder.
+     * Use this function to post partially verified price updates from the present or from the past for your program to consume.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     *
+     * Partially verified price updates are price updates where not all the guardian signatures have been verified. By default this methods checks `DEFAULT_REDUCED_GUARDIAN_SET_SIZE` signatures when posting the VAA.
+     * If you are a on-chain program developer, make sure you understand the risks of consuming partially verified price updates here: {@link https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/solana/pyth_solana_receiver_sdk/src/price_update.rs}.
+     *
+     * @example
+     * ```typescript
+     * // Get the price feed ids from https://pyth.network/developers/price-feed-ids#pyth-evm-stable
+     * const priceUpdateData = await priceServiceConnection.getLatestVaas([
+     *    SOL_PRICE_FEED_ID,
+     *    ETH_PRICE_FEED_ID,
+     * ]);
+     *
+     * const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({});
+     * await transactionBuilder.addPostPartiallyVerifiedPriceUpdates(priceUpdateData);
+     * console.log("The SOL/USD price update will get posted to:", transactionBuilder.getPriceUpdateAccount(SOL_PRICE_FEED_ID).toBase58())
+     * await transactionBuilder.addPriceConsumerInstructions(...)
+     * ...
+     * ```
+     */
+    addPostPartiallyVerifiedPriceUpdates(priceUpdateDataArray: string[]): Promise<void>;
+    /**
+     * Add instructions to update price feed accounts to the builder.
+     * Price feed accounts are fixed accounts per price feed id that can only be updated with a more recent price.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     * @param shardId the shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+     *
+     * @example
+     * ```typescript
+     * // Get the price feed ids from https://pyth.network/developers/price-feed-ids#pyth-evm-stable
+     * const priceUpdateData = await priceServiceConnection.getLatestVaas([
+     *    SOL_PRICE_FEED_ID,
+     *    ETH_PRICE_FEED_ID,
+     * ]);
+     *
+     * const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({});
+     * await transactionBuilder.addUpdatePriceFeed(priceUpdateData);
+     * await transactionBuilder.addPriceConsumerInstructions(...)
+     * ...
+     * ```
+     */
+    addUpdatePriceFeed(priceUpdateDataArray: string[], shardId: number): Promise<void>;
+    /**
+     * Add instructions that consume price updates to the builder.
+     *
+     * @param getInstructions a function that given a mapping of price feed IDs to price update accounts, generates a series of instructions. Price updates get posted to ephemeral accounts and this function allows the user to indicate which accounts in their instruction need to be "replaced" with each price update account.
+     * If multiple price updates for the same price feed ID are posted with the same builder, the account corresponding to the last update to get posted will be used.
+     *
+     * @example
+     * ```typescript
+     * ...
+     * await transactionBuilder.addPostPriceUpdates(priceUpdateData);
+     * await transactionBuilder.addPriceConsumerInstructions(
+     *   async (
+     *     getPriceUpdateAccount: ( priceFeedId: string) => PublicKey
+     *   ): Promise<InstructionWithEphemeralSigners[]> => {
+     *     return [
+     *       {
+     *         instruction: await myFirstPythApp.methods
+     *           .consume()
+     *           .accounts({
+     *              solPriceUpdate: getPriceUpdateAccount(SOL_PRICE_FEED_ID),
+     *              ethPriceUpdate: getPriceUpdateAccount(ETH_PRICE_FEED_ID),
+     *           })
+     *           .instruction(),
+     *         signers: [],
+     *       },
+     *     ];
+     *   }
+     * );
+     * ```
+     */
+    addPriceConsumerInstructions(getInstructions: (getPriceUpdateAccount: (priceFeedId: string) => PublicKey) => Promise<InstructionWithEphemeralSigners[]>): Promise<void>;
+    /** Add instructions to close encoded VAA accounts from previous actions.
+     * If you have previously used the PythTransactionBuilder with closeUpdateAccounts set to false or if you posted encoded VAAs but the transaction to close them did not land on-chain, your wallet might own many encoded VAA accounts.
+     * The rent cost for these accounts is 0.008 SOL per encoded VAA account. You can recover this rent calling this function when building a set of transactions.
+     */
+    addClosePreviousEncodedVaasInstructions(maxInstructions?: number): Promise<void>;
+    /**
+     * Returns all the added instructions batched into versioned transactions, plus for each transaction the ephemeral signers that need to sign it
+     */
+    buildVersionedTransactions(args: PriorityFeeConfig): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    /**
+     * Returns all the added instructions batched into transactions, plus for each transaction the ephemeral signers that need to sign it
+     */
+    buildLegacyTransactions(args: PriorityFeeConfig): {
+        tx: Transaction;
+        signers: Signer[];
+    }[];
+    /**
+     * This method is used to retrieve the address of the price update account where the price update for a given price feed ID will be posted.
+     * If multiple price updates for the same price feed ID will be posted with the same builder, the address of the account corresponding to the last update to get posted will be returned.
+     * */
+    getPriceUpdateAccount(priceFeedId: string): PublicKey;
+}
+/**
+ * A class to interact with the Pyth Solana Receiver program.
+ *
+ * This class provides helpful methods to build instructions to interact with the Pyth Solana Receiver program:
+ * - Post price updates (fully or partially verified)
+ * - Close price update and encoded vaa accounts to recover rent
+ */
+export declare class PythSolanaReceiver {
+    readonly connection: Connection;
+    readonly wallet: Wallet;
+    readonly provider: AnchorProvider;
+    readonly receiver: Program<PythSolanaReceiverProgram>;
+    readonly wormhole: Program<WormholeCoreBridgeSolana>;
+    readonly pushOracle: Program<PythPushOracle>;
+    readonly treasuryId?: number | undefined;
+    constructor({ connection, wallet, wormholeProgramId, receiverProgramId, pushOracleProgramId, treasuryId, }: {
+        connection: Connection;
+        wallet: Wallet;
+        wormholeProgramId?: PublicKey;
+        receiverProgramId?: PublicKey;
+        pushOracleProgramId?: PublicKey;
+        treasuryId?: number;
+    });
+    /**
+     * Get a new transaction builder to build transactions that interact with the Pyth Solana Receiver program and consume price updates
+     */
+    newTransactionBuilder(config: PythTransactionBuilderConfig, addressLookupAccount?: AddressLookupTableAccount): PythTransactionBuilder;
+    /**
+     * Build a series of helper instructions that post price updates to the Pyth Solana Receiver program and another series to close the price update accounts.
+     *
+     * This function uses partially verified price updates. Partially verified price updates are price updates where not all the guardian signatures have been verified. By default this methods checks `DEFAULT_REDUCED_GUARDIAN_SET_SIZE` signatures when posting the VAA.
+     * If you are a on-chain program developer, make sure you understand the risks of consuming partially verified price updates here: {@link https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/solana/pyth_solana_receiver_sdk/src/price_update.rs}.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     * @returns `postInstructions`: the instructions to post the price updates, these should be called before consuming the price updates
+     * @returns `priceFeedIdToPriceUpdateAccount`: this is a map of price feed IDs to Solana address. Given a price feed ID, you can use this map to find the account where `postInstructions` will post the price update.
+     * @returns `closeInstructions`: the instructions to close the price update accounts, these should be called after consuming the price updates
+     */
+    buildPostPriceUpdateAtomicInstructions(priceUpdateDataArray: string[]): Promise<{
+        postInstructions: InstructionWithEphemeralSigners[];
+        priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
+        closeInstructions: InstructionWithEphemeralSigners[];
+    }>;
+    /**
+     * Build a series of helper instructions that post price updates to the Pyth Solana Receiver program and another series to close the encoded vaa accounts and the price update accounts.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     * @returns `postInstructions`: the instructions to post the price updates, these should be called before consuming the price updates
+     * @returns `priceFeedIdToPriceUpdateAccount`: this is a map of price feed IDs to Solana address. Given a price feed ID, you can use this map to find the account where `postInstructions` will post the price update.
+     * @returns `closeInstructions`: the instructions to close the price update accounts, these should be called after consuming the price updates
+     */
+    buildPostPriceUpdateInstructions(priceUpdateDataArray: string[]): Promise<{
+        postInstructions: InstructionWithEphemeralSigners[];
+        priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
+        closeInstructions: InstructionWithEphemeralSigners[];
+    }>;
+    /**
+     * Build a series of helper instructions that update one or many price feed accounts and another series to close the encoded vaa accounts used to update the price feed accounts.
+     *
+     * @param priceUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestVaas`. This is an array of verifiable price updates.
+     * @param shardId the shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+     * @returns `postInstructions`: the instructions to update the price feed accounts. If the price feed accounts don't contain a recent update, these should be called before consuming the price updates.
+     * @returns `priceFeedIdToPriceUpdateAccount`: this is a map of price feed IDs to Solana address. Given a price feed ID, you can use this map to find the account where `postInstructions` will post the price update. Note that since price feed accounts are PDAs, the address of the account can also be found with `getPriceFeedAccountAddress`.
+     * @returns `closeInstructions`: the instructions to close the encoded VAA accounts that were used to update the price feed accounts.
+     */
+    buildUpdatePriceFeedInstructions(priceUpdateDataArray: string[], shardId: number): Promise<{
+        postInstructions: InstructionWithEphemeralSigners[];
+        priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
+        closeInstructions: InstructionWithEphemeralSigners[];
+    }>;
+    /**
+     * Build a series of helper instructions that post a VAA in an encoded VAA account. This function is bespoke for posting Pyth VAAs and might not work for other usecases.
+     *
+     * @param vaa a Wormhole VAA
+     * @returns `encodedVaaAddress`: the address of the encoded VAA account where the VAA will be posted
+     * @returns `postInstructions`: the instructions to post the VAA
+     * @returns `closeInstructions`: the instructions to close the encoded VAA account
+     */
+    buildPostEncodedVaaInstructions(vaa: Buffer): Promise<{
+        encodedVaaAddress: PublicKey;
+        postInstructions: InstructionWithEphemeralSigners[];
+        closeInstructions: InstructionWithEphemeralSigners[];
+    }>;
+    /**
+     * Build an instruction to close an encoded VAA account, recovering the rent.
+     */
+    buildCloseEncodedVaaInstruction(encodedVaa: PublicKey): Promise<InstructionWithEphemeralSigners>;
+    /**
+     * Build aset of instructions to close all the existing encoded VAA accounts owned by this PythSolanaReceiver's wallet
+     */
+    buildClosePreviousEncodedVaasInstructions(maxInstructions: number): Promise<InstructionWithEphemeralSigners[]>;
+    /**
+     * Build an instruction to close a price update account, recovering the rent.
+     */
+    buildClosePriceUpdateInstruction(priceUpdateAccount: PublicKey): Promise<InstructionWithEphemeralSigners>;
+    /**
+     * Returns a set of versioned transactions that contain the provided instructions in the same order and with efficient batching
+     */
+    batchIntoVersionedTransactions(instructions: InstructionWithEphemeralSigners[], priorityFeeConfig: PriorityFeeConfig, addressLookupTable?: AddressLookupTableAccount): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    /**
+     * Fetch the contents of a price update account
+     * @param priceUpdateAccount The address of the price update account
+     * @returns The contents of the deserialized price update account or `null` if the account doesn't exist
+     */
+    fetchPriceUpdateAccount(priceUpdateAccount: PublicKey): Promise<PriceUpdateAccount | null>;
+    /**
+     * Fetch the contents of a price feed account
+     * @param shardId The shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+     * @param priceFeedId The price feed ID, as either a 32-byte buffer or hexadecimal string with or without a leading "0x" prefix.
+     * @returns The contents of the deserialized price feed account or `null` if the account doesn't exist
+     */
+    fetchPriceFeedAccount(shardId: number, priceFeedId: Buffer | string): Promise<PriceUpdateAccount | null>;
+    /**
+     * Derive the address of a price feed account
+     * @param shardId The shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+     * @param priceFeedId The price feed ID, as either a 32-byte buffer or hexadecimal string with or without a leading "0x" prefix.
+     * @returns The address of the price feed account
+     */
+    getPriceFeedAccountAddress(shardId: number, priceFeedId: Buffer | string): PublicKey;
+    /**
+     * Find all the encoded VAA accounts owned by this PythSolanaReceiver's wallet
+     * @returns a list of the public keys of the encoded VAA accounts
+     */
+    findOwnedEncodedVaaAccounts(): Promise<PublicKey[]>;
+}
+/**
+ * Derive the address of a price feed account
+ * @param shardId The shard ID of the set of price feed accounts. This shard ID allows for multiple price feed accounts for the same price feed id to exist.
+ * @param priceFeedId The price feed ID, as either a 32-byte buffer or hexadecimal string with or without a leading "0x" prefix.
+ * @param pushOracleProgramId The program ID of the Pyth Push Oracle program. If not provided, the default deployment will be used.
+ * @returns The address of the price feed account
+ */
+export declare function getPriceFeedAccountForProgram(shardId: number, priceFeedId: Buffer | string, pushOracleProgramId?: PublicKey): PublicKey;