@pythnetwork/pyth-solana-receiver 0.12.0 → 0.14.0

package/README.md

@@ -175,50 +175,6 @@ Price updates are relatively large and can take multiple transactions to post on
 You can reduce the size of the transaction payload by using `addPostPartiallyVerifiedPriceUpdates` instead of `addPostPriceUpdates`.
 This method does sacrifice some security however -- please see the method documentation for more details.
 
-### Post a TWAP price update
-
-TWAP price updates are calculated using a pair of verifiable cumulative price updates per price feed (the "start" and "end" updates for the given time window), and then performing an averaging calculation on-chain to create the time-weighted average price.
-
-The flow of using, verifying, posting, and consuming these prices is the same as standard price updates. Get the binary update data from Hermes or Benchmarks, post and verify the VAAs via the Wormhole contract, and verify the updates against the VAAs via Pyth receiver contract. After this, you can consume the calculated TWAP posted to the TwapUpdate account. You can also optionally close these ephemeral accounts after the TWAP has been consumed to save on rent.
-
-```typescript
-// Fetch the binary TWAP data from hermes or benchmarks. See Preliminaries section above for more info.
-const binaryDataArray = ["UE5BV...khz609", "UE5BV...BAg8i6"];
-
-// Pass `closeUpdateAccounts: true` to automatically close the TWAP update accounts
-// after they're consumed
-const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({
-  closeUpdateAccounts: false,
-});
-
-// Post the updates and calculate the TWAP
-await transactionBuilder.addPostTwapUpdates(binaryDataArray);
-
-// You can now use the TWAP prices in subsequent instructions
-await transactionBuilder.addTwapConsumerInstructions(
-  async (
-    getTwapUpdateAccount: (priceFeedId: string) => PublicKey
-  ): Promise<InstructionWithEphemeralSigners[]> => {
-    // Generate instructions here that use the TWAP updates posted above.
-    // getTwapUpdateAccount(<price feed id>) will give you the account for each TWAP update.
-    return [];
-  }
-);
-
-// Send the instructions in the builder in 1 or more transactions.
-// The builder will pack the instructions into transactions automatically.
-sendTransactions(
-  await transactionBuilder.buildVersionedTransactions({
-    computeUnitPriceMicroLamports: 100000,
-    tightComputeBudget: true,
-  }),
-  pythSolanaReceiver.connection,
-  pythSolanaReceiver.wallet
-);
-```
-
-See `examples/post_twap_update.ts` for a runnable example of posting a TWAP price update.
-
 ### Get Instructions
 
 The `PythTransactionBuilder` class used in the examples above helps craft transactions that update prices and then use them in successive instructions.

package/dist/cjs/PythSolanaReceiver.cjs

@@ -0,0 +1,442 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable tsdoc/syntax */ // 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_TREASURY_ID () {
+        return DEFAULT_TREASURY_ID;
+    },
+    get PythSolanaReceiver () {
+        return PythSolanaReceiver;
+    },
+    get PythTransactionBuilder () {
+        return PythTransactionBuilder;
+    },
+    get getPriceFeedAccountForProgram () {
+        return getPriceFeedAccountForProgram;
+    }
+});
+const _buffer = require("buffer");
+const _anchor = require("@coral-xyz/anchor");
+const _priceservicesdk = require("@pythnetwork/price-service-sdk");
+const _solanautils = require("@pythnetwork/solana-utils");
+const _web3 = require("@solana/web3.js");
+const _address = require("./address.cjs");
+const _compute_budget = require("./compute_budget.cjs");
+const _pyth_push_oracle = require("./idl/pyth_push_oracle.cjs");
+const _pyth_solana_receiver = require("./idl/pyth_solana_receiver.cjs");
+const _wormhole_core_bridge_solana = require("./idl/wormhole_core_bridge_solana.cjs");
+const _vaa = require("./vaa.cjs");
+const DEFAULT_TREASURY_ID = 0;
+class PythTransactionBuilder extends _solanautils.TransactionBuilder {
+    pythSolanaReceiver;
+    closeInstructions;
+    priceFeedIdToPriceUpdateAccount;
+    closeUpdateAccounts;
+    constructor(pythSolanaReceiver, config, addressLookupTable){
+        super(pythSolanaReceiver.wallet.publicKey, pythSolanaReceiver.connection, addressLookupTable);
+        this.pythSolanaReceiver = pythSolanaReceiver;
+        this.closeInstructions = [];
+        this.priceFeedIdToPriceUpdateAccount = {};
+        this.closeUpdateAccounts = config.closeUpdateAccounts ?? true;
+    }
+    /**
+   * 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(...)
+   * ```
+   */ async addPostPriceUpdates(priceUpdateDataArray) {
+        const { postInstructions, priceFeedIdToPriceUpdateAccount, closeInstructions } = await this.pythSolanaReceiver.buildPostPriceUpdateInstructions(priceUpdateDataArray);
+        this.closeInstructions.push(...closeInstructions);
+        Object.assign(this.priceFeedIdToPriceUpdateAccount, priceFeedIdToPriceUpdateAccount);
+        this.addInstructions(postInstructions);
+    }
+    /**
+   * 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(...)
+   * ...
+   * ```
+   */ async addPostPartiallyVerifiedPriceUpdates(priceUpdateDataArray) {
+        const { postInstructions, priceFeedIdToPriceUpdateAccount, closeInstructions } = await this.pythSolanaReceiver.buildPostPriceUpdateAtomicInstructions(priceUpdateDataArray);
+        this.closeInstructions.push(...closeInstructions);
+        Object.assign(this.priceFeedIdToPriceUpdateAccount, priceFeedIdToPriceUpdateAccount);
+        this.addInstructions(postInstructions);
+    }
+    /**
+   * 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(...)
+   * ...
+   * ```
+   */ async addUpdatePriceFeed(priceUpdateDataArray, shardId) {
+        const { postInstructions, priceFeedIdToPriceUpdateAccount, closeInstructions } = await this.pythSolanaReceiver.buildUpdatePriceFeedInstructions(priceUpdateDataArray, shardId);
+        this.closeInstructions.push(...closeInstructions);
+        Object.assign(this.priceFeedIdToPriceUpdateAccount, priceFeedIdToPriceUpdateAccount);
+        this.addInstructions(postInstructions);
+    }
+    /**
+   * 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: [],
+   *       },
+   *     ];
+   *   }
+   * );
+   * ```
+   */ async addPriceConsumerInstructions(getInstructions) {
+        this.addInstructions(await getInstructions(this.getPriceUpdateAccount.bind(this)));
+    }
+    /** 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.
+   */ async addClosePreviousEncodedVaasInstructions(maxInstructions = 40) {
+        this.addInstructions(await this.pythSolanaReceiver.buildClosePreviousEncodedVaasInstructions(maxInstructions));
+    }
+    /**
+   * Returns all the added instructions batched into versioned transactions, plus for each transaction the ephemeral signers that need to sign it
+   */ async buildVersionedTransactions(args) {
+        if (this.closeUpdateAccounts) {
+            this.addInstructions(this.closeInstructions);
+        }
+        return super.buildVersionedTransactions(args);
+    }
+    /**
+   * Returns all the added instructions batched into transactions, plus for each transaction the ephemeral signers that need to sign it
+   */ buildLegacyTransactions(args) {
+        if (this.closeUpdateAccounts) {
+            this.addInstructions(this.closeInstructions);
+        }
+        return super.buildLegacyTransactions(args);
+    }
+    /**
+   * 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) {
+        const priceUpdateAccount = this.priceFeedIdToPriceUpdateAccount[priceFeedId];
+        if (!priceUpdateAccount) {
+            throw new Error(`No price update account found for the price feed ID ${priceFeedId}. Make sure to call addPostPriceUpdates or addPostPartiallyVerifiedPriceUpdates before calling this function.`);
+        }
+        return priceUpdateAccount;
+    }
+}
+class PythSolanaReceiver {
+    connection;
+    wallet;
+    provider;
+    receiver;
+    wormhole;
+    pushOracle;
+    treasuryId;
+    constructor({ connection, wallet, wormholeProgramId = _address.DEFAULT_WORMHOLE_PROGRAM_ID, receiverProgramId = _address.DEFAULT_RECEIVER_PROGRAM_ID, pushOracleProgramId = _address.DEFAULT_PUSH_ORACLE_PROGRAM_ID, treasuryId }){
+        if (treasuryId !== undefined && (treasuryId < 0 || treasuryId > 255)) {
+            throw new Error("treasuryId must be between 0 and 255");
+        }
+        this.connection = connection;
+        this.wallet = wallet;
+        this.provider = new _anchor.AnchorProvider(this.connection, this.wallet, {
+            commitment: connection.commitment
+        });
+        this.receiver = new _anchor.Program(_pyth_solana_receiver.IDL, receiverProgramId, this.provider);
+        this.wormhole = new _anchor.Program(_wormhole_core_bridge_solana.IDL, wormholeProgramId, this.provider);
+        this.pushOracle = new _anchor.Program(_pyth_push_oracle.IDL, pushOracleProgramId, this.provider);
+        this.treasuryId = treasuryId;
+    }
+    /**
+   * Get a new transaction builder to build transactions that interact with the Pyth Solana Receiver program and consume price updates
+   */ newTransactionBuilder(config, addressLookupAccount) {
+        return new PythTransactionBuilder(this, config, addressLookupAccount);
+    }
+    /**
+   * 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
+   */ async buildPostPriceUpdateAtomicInstructions(priceUpdateDataArray) {
+        const postInstructions = [];
+        const priceFeedIdToPriceUpdateAccount = {};
+        const closeInstructions = [];
+        const treasuryId = this.treasuryId ?? (0, _address.getRandomTreasuryId)();
+        for (const priceUpdateData of priceUpdateDataArray){
+            const accumulatorUpdateData = (0, _priceservicesdk.parseAccumulatorUpdateData)(_buffer.Buffer.from(priceUpdateData, "base64"));
+            const guardianSetIndex = (0, _vaa.getGuardianSetIndex)(accumulatorUpdateData.vaa);
+            const trimmedVaa = (0, _vaa.trimSignatures)(accumulatorUpdateData.vaa);
+            for (const update of accumulatorUpdateData.updates){
+                const priceUpdateKeypair = new _web3.Keypair();
+                postInstructions.push({
+                    instruction: await this.receiver.methods.postUpdateAtomic({
+                        vaa: trimmedVaa,
+                        merklePriceUpdate: update,
+                        treasuryId
+                    }).accounts({
+                        priceUpdateAccount: priceUpdateKeypair.publicKey,
+                        treasury: (0, _address.getTreasuryPda)(treasuryId, this.receiver.programId),
+                        config: (0, _address.getConfigPda)(this.receiver.programId),
+                        guardianSet: (0, _address.getGuardianSetPda)(guardianSetIndex, this.wormhole.programId)
+                    }).instruction(),
+                    signers: [
+                        priceUpdateKeypair
+                    ],
+                    computeUnits: _compute_budget.POST_UPDATE_ATOMIC_COMPUTE_BUDGET
+                });
+                priceFeedIdToPriceUpdateAccount["0x" + (0, _priceservicesdk.parsePriceFeedMessage)(update.message).feedId.toString("hex")] = priceUpdateKeypair.publicKey;
+                closeInstructions.push(await this.buildClosePriceUpdateInstruction(priceUpdateKeypair.publicKey));
+            }
+        }
+        return {
+            postInstructions,
+            priceFeedIdToPriceUpdateAccount,
+            closeInstructions
+        };
+    }
+    /**
+   * 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
+   */ async buildPostPriceUpdateInstructions(priceUpdateDataArray) {
+        const postInstructions = [];
+        const priceFeedIdToPriceUpdateAccount = {};
+        const closeInstructions = [];
+        const treasuryId = this.treasuryId ?? (0, _address.getRandomTreasuryId)();
+        for (const priceUpdateData of priceUpdateDataArray){
+            const accumulatorUpdateData = (0, _priceservicesdk.parseAccumulatorUpdateData)(_buffer.Buffer.from(priceUpdateData, "base64"));
+            const { postInstructions: postEncodedVaaInstructions, encodedVaaAddress: encodedVaa, closeInstructions: postEncodedVaacloseInstructions } = await this.buildPostEncodedVaaInstructions(accumulatorUpdateData.vaa);
+            postInstructions.push(...postEncodedVaaInstructions);
+            closeInstructions.push(...postEncodedVaacloseInstructions);
+            for (const update of accumulatorUpdateData.updates){
+                const priceUpdateKeypair = new _web3.Keypair();
+                postInstructions.push({
+                    instruction: await this.receiver.methods.postUpdate({
+                        merklePriceUpdate: update,
+                        treasuryId
+                    }).accounts({
+                        encodedVaa,
+                        priceUpdateAccount: priceUpdateKeypair.publicKey,
+                        treasury: (0, _address.getTreasuryPda)(treasuryId, this.receiver.programId),
+                        config: (0, _address.getConfigPda)(this.receiver.programId)
+                    }).instruction(),
+                    signers: [
+                        priceUpdateKeypair
+                    ],
+                    computeUnits: _compute_budget.POST_UPDATE_COMPUTE_BUDGET
+                });
+                priceFeedIdToPriceUpdateAccount["0x" + (0, _priceservicesdk.parsePriceFeedMessage)(update.message).feedId.toString("hex")] = priceUpdateKeypair.publicKey;
+                closeInstructions.push(await this.buildClosePriceUpdateInstruction(priceUpdateKeypair.publicKey));
+            }
+        }
+        return {
+            postInstructions,
+            priceFeedIdToPriceUpdateAccount,
+            closeInstructions
+        };
+    }
+    /**
+   * 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.
+   */ async buildUpdatePriceFeedInstructions(priceUpdateDataArray, shardId) {
+        const postInstructions = [];
+        const priceFeedIdToPriceUpdateAccount = {};
+        const closeInstructions = [];
+        const treasuryId = this.treasuryId ?? (0, _address.getRandomTreasuryId)();
+        for (const priceUpdateData of priceUpdateDataArray){
+            const accumulatorUpdateData = (0, _priceservicesdk.parseAccumulatorUpdateData)(_buffer.Buffer.from(priceUpdateData, "base64"));
+            const { postInstructions: postEncodedVaaInstructions, encodedVaaAddress: encodedVaa, closeInstructions: postEncodedVaacloseInstructions } = await this.buildPostEncodedVaaInstructions(accumulatorUpdateData.vaa);
+            postInstructions.push(...postEncodedVaaInstructions);
+            closeInstructions.push(...postEncodedVaacloseInstructions);
+            for (const update of accumulatorUpdateData.updates){
+                const feedId = (0, _priceservicesdk.parsePriceFeedMessage)(update.message).feedId;
+                postInstructions.push({
+                    instruction: await this.pushOracle.methods.updatePriceFeed({
+                        merklePriceUpdate: update,
+                        treasuryId
+                    }, shardId, [
+                        ...feedId
+                    ]).accounts({
+                        pythSolanaReceiver: this.receiver.programId,
+                        encodedVaa,
+                        priceFeedAccount: this.getPriceFeedAccountAddress(shardId, feedId),
+                        treasury: (0, _address.getTreasuryPda)(treasuryId, this.receiver.programId),
+                        config: (0, _address.getConfigPda)(this.receiver.programId)
+                    }).instruction(),
+                    signers: [],
+                    computeUnits: _compute_budget.UPDATE_PRICE_FEED_COMPUTE_BUDGET
+                });
+                priceFeedIdToPriceUpdateAccount["0x" + (0, _priceservicesdk.parsePriceFeedMessage)(update.message).feedId.toString("hex")] = this.getPriceFeedAccountAddress(shardId, feedId);
+            }
+        }
+        return {
+            postInstructions,
+            priceFeedIdToPriceUpdateAccount,
+            closeInstructions
+        };
+    }
+    /**
+   * 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
+   */ async buildPostEncodedVaaInstructions(vaa) {
+        return (0, _vaa.buildPostEncodedVaaInstructions)(this.wormhole, vaa);
+    }
+    /**
+   * Build an instruction to close an encoded VAA account, recovering the rent.
+   */ async buildCloseEncodedVaaInstruction(encodedVaa) {
+        return (0, _vaa.buildCloseEncodedVaaInstruction)(this.wormhole, encodedVaa);
+    }
+    /**
+   * Build aset of instructions to close all the existing encoded VAA accounts owned by this PythSolanaReceiver's wallet
+   */ async buildClosePreviousEncodedVaasInstructions(maxInstructions) {
+        const encodedVaas = await this.findOwnedEncodedVaaAccounts();
+        const instructions = [];
+        for (const encodedVaa of encodedVaas){
+            instructions.push(await this.buildCloseEncodedVaaInstruction(encodedVaa));
+        }
+        return instructions.slice(0, maxInstructions);
+    }
+    /**
+   * Build an instruction to close a price update account, recovering the rent.
+   */ async buildClosePriceUpdateInstruction(priceUpdateAccount) {
+        const instruction = await this.receiver.methods.reclaimRent().accounts({
+            priceUpdateAccount
+        }).instruction();
+        return {
+            instruction,
+            signers: []
+        };
+    }
+    /**
+   * Returns a set of versioned transactions that contain the provided instructions in the same order and with efficient batching
+   */ async batchIntoVersionedTransactions(instructions, priorityFeeConfig, addressLookupTable) {
+        return _solanautils.TransactionBuilder.batchIntoVersionedTransactions(this.wallet.publicKey, this.connection, instructions, priorityFeeConfig, addressLookupTable);
+    }
+    /**
+   * 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
+   */ async fetchPriceUpdateAccount(priceUpdateAccount) {
+        return this.receiver.account.priceUpdateV2.fetchNullable(priceUpdateAccount);
+    }
+    /**
+   * 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
+   */ async fetchPriceFeedAccount(shardId, priceFeedId) {
+        return this.receiver.account.priceUpdateV2.fetchNullable(this.getPriceFeedAccountAddress(shardId, priceFeedId));
+    }
+    /**
+   * 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, priceFeedId) {
+        return getPriceFeedAccountForProgram(shardId, priceFeedId, this.pushOracle.programId);
+    }
+    /**
+   * Find all the encoded VAA accounts owned by this PythSolanaReceiver's wallet
+   * @returns a list of the public keys of the encoded VAA accounts
+   */ async findOwnedEncodedVaaAccounts() {
+        return await (0, _vaa.findEncodedVaaAccountsByWriteAuthority)(this.receiver.provider.connection, this.wallet.publicKey, this.wormhole.programId);
+    }
+}
+function getPriceFeedAccountForProgram(shardId, priceFeedId, pushOracleProgramId) {
+    if (typeof priceFeedId == "string") {
+        priceFeedId = priceFeedId.startsWith("0x") ? _buffer.Buffer.from(priceFeedId.slice(2), "hex") : _buffer.Buffer.from(priceFeedId, "hex");
+    }
+    if (priceFeedId.length != 32) {
+        throw new Error("Feed ID should be 32 bytes long");
+    }
+    const shardBuffer = _buffer.Buffer.alloc(2);
+    shardBuffer.writeUint16LE(shardId, 0);
+    return _web3.PublicKey.findProgramAddressSync([
+        shardBuffer,
+        priceFeedId
+    ], pushOracleProgramId ?? _address.DEFAULT_PUSH_ORACLE_PROGRAM_ID)[0];
+}

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

@@ -1,13 +1,13 @@
-import { AnchorProvider, IdlAccounts, Program } from "@coral-xyz/anchor";
-import { AddressLookupTableAccount, Connection, Signer, Transaction, VersionedTransaction } from "@solana/web3.js";
-import { PythSolanaReceiver as PythSolanaReceiverProgram } from "./idl/pyth_solana_receiver";
-import { WormholeCoreBridgeSolana } from "./idl/wormhole_core_bridge_solana";
-import { PublicKey } from "@solana/web3.js";
-import { Wallet } from "@coral-xyz/anchor";
-import { TransactionBuilder, InstructionWithEphemeralSigners, PriorityFeeConfig } from "@pythnetwork/solana-utils";
-import { PythPushOracle } from "./idl/pyth_push_oracle";
+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"];
-export type TwapUpdateAccount = IdlAccounts<PythSolanaReceiverProgram>["twapUpdate"];
 /**
  * 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
@@ -54,7 +54,6 @@ export declare class PythTransactionBuilder extends TransactionBuilder {
     readonly pythSolanaReceiver: PythSolanaReceiver;
     readonly closeInstructions: InstructionWithEphemeralSigners[];
     readonly priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
-    readonly priceFeedIdToTwapUpdateAccount: Record<string, PublicKey>;
     readonly closeUpdateAccounts: boolean;
     constructor(pythSolanaReceiver: PythSolanaReceiver, config: PythTransactionBuilderConfig, addressLookupTable?: AddressLookupTableAccount);
     /**
@@ -103,27 +102,6 @@ export declare class PythTransactionBuilder extends TransactionBuilder {
      * ```
      */
     addPostPartiallyVerifiedPriceUpdates(priceUpdateDataArray: string[]): Promise<void>;
-    /**
-     * Add instructions to post TWAP updates to the builder.
-     * Use this function to post fully verified TWAP updates from the present or from the past for your program to consume.
-     *
-     * @param twapUpdateDataArray the output of the `@pythnetwork/hermes-client`'s `getLatestTwaps`. 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 twapUpdateData = await hermesClient.getLatestTwaps([
-     *    SOL_PRICE_FEED_ID,
-     *    ETH_PRICE_FEED_ID,
-     * ]);
-     *
-     * const transactionBuilder = pythSolanaReceiver.newTransactionBuilder({});
-     * await transactionBuilder.addPostTwapUpdates(priceUpdateData);
-     * console.log("The SOL/USD price update will get posted to:", transactionBuilder.getTwapUpdateAccount(SOL_PRICE_FEED_ID).toBase58())
-     * await transactionBuilder.addTwapConsumerInstructions(...)
-     * ```
-     */
-    addPostTwapUpdates(twapUpdateDataArray: 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.
@@ -177,37 +155,6 @@ export declare class PythTransactionBuilder extends TransactionBuilder {
      * ```
      */
     addPriceConsumerInstructions(getInstructions: (getPriceUpdateAccount: (priceFeedId: string) => PublicKey) => Promise<InstructionWithEphemeralSigners[]>): Promise<void>;
-    /**
-     * Add instructions that consume TWAP updates to the builder.
-     *
-     * @param getInstructions a function that given a mapping of price feed IDs to TWAP update accounts, generates a series of instructions. TWAP 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 TWAP 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.addPostTwapUpdates(twapUpdateData);
-     * await transactionBuilder.addTwapConsumerInstructions(
-     *   async (
-     *     getTwapUpdateAccount: ( priceFeedId: string) => PublicKey
-     *   ): Promise<InstructionWithEphemeralSigners[]> => {
-     *     return [
-     *       {
-     *         instruction: await myFirstPythApp.methods
-     *           .consume()
-     *           .accounts({
-     *              solTwapUpdate: getTwapUpdateAccount(SOL_PRICE_FEED_ID),
-     *              ethTwapUpdate: getTwapUpdateAccount(ETH_PRICE_FEED_ID),
-     *           })
-     *           .instruction(),
-     *         signers: [],
-     *       },
-     *     ];
-     *   }
-     * );
-     * ```
-     */
-    addTwapConsumerInstructions(getInstructions: (getTwapUpdateAccount: (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.
@@ -232,11 +179,6 @@ export declare class PythTransactionBuilder extends TransactionBuilder {
      * 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;
-    /**
-     * This method is used to retrieve the address of the TWAP update account where the TWAP update for a given price feed ID will be posted.
-     * If multiple 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.
-     * */
-    getTwapUpdateAccount(priceFeedId: string): PublicKey;
 }
 /**
  * A class to interact with the Pyth Solana Receiver program.
@@ -252,7 +194,7 @@ export declare class PythSolanaReceiver {
     readonly receiver: Program<PythSolanaReceiverProgram>;
     readonly wormhole: Program<WormholeCoreBridgeSolana>;
     readonly pushOracle: Program<PythPushOracle>;
-    readonly treasuryId?: number;
+    readonly treasuryId?: number | undefined;
     constructor({ connection, wallet, wormholeProgramId, receiverProgramId, pushOracleProgramId, treasuryId, }: {
         connection: Connection;
         wallet: Wallet;
@@ -294,19 +236,6 @@ export declare class PythSolanaReceiver {
         priceFeedIdToPriceUpdateAccount: Record<string, PublicKey>;
         closeInstructions: InstructionWithEphemeralSigners[];
     }>;
-    /**
-     * Build a series of helper instructions that post TWAP updates to the Pyth Solana Receiver program and another series to close the encoded vaa accounts and the TWAP update accounts.
-     *
-     * @param twapUpdateDataArray the output of the `@pythnetwork/price-service-client`'s `PriceServiceConnection.getLatestTwaps`. This is an array of verifiable price updates.
-     * @returns `postInstructions`: the instructions to post the TWAP updates, these should be called before consuming the price updates
-     * @returns `priceFeedIdToTwapUpdateAccount`: 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 TWAP update.
-     * @returns `closeInstructions`: the instructions to close the TWAP update accounts, these should be called after consuming the TWAP updates
-     */
-    buildPostTwapUpdateInstructions(twapUpdateDataArray: string[]): Promise<{
-        postInstructions: InstructionWithEphemeralSigners[];
-        priceFeedIdToTwapUpdateAccount: 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.
      *
@@ -346,10 +275,6 @@ export declare class PythSolanaReceiver {
      * Build an instruction to close a price update account, recovering the rent.
      */
     buildClosePriceUpdateInstruction(priceUpdateAccount: PublicKey): Promise<InstructionWithEphemeralSigners>;
-    /**
-     * Build an instruction to close a TWAP update account, recovering the rent.
-     */
-    buildCloseTwapUpdateInstruction(twapUpdateAccount: PublicKey): Promise<InstructionWithEphemeralSigners>;
     /**
      * Returns a set of versioned transactions that contain the provided instructions in the same order and with efficient batching
      */
@@ -391,4 +316,3 @@ export declare class PythSolanaReceiver {
  * @returns The address of the price feed account
  */
 export declare function getPriceFeedAccountForProgram(shardId: number, priceFeedId: Buffer | string, pushOracleProgramId?: PublicKey): PublicKey;
-//# sourceMappingURL=PythSolanaReceiver.d.ts.map