pangu-sdk 0.1.0

package/dist/price.d.ts

@@ -0,0 +1,86 @@
+import { VersionedTransaction, Signer, PublicKey, Connection } from '@solana/web3.js';
+import { F as FeedId, S as Sale } from './accounts-BuD-oCcr.js';
+
+/**
+ * Keeping a banded sale's price fresh.
+ *
+ * Node and server only. It reaches Pyth's Hermes service over the network with
+ * an API key, and it pulls in `@pythnetwork/pyth-solana-receiver`, so the web
+ * app calls it from a server route and never from the browser. The key would be
+ * in every browser bundle otherwise, and every Hermes read has needed one since
+ * 26 August 2026
+ * (https://docs.pyth.network/price-feeds/core/upgrade/preparing). Reading a price back is
+ * `readPrice` in the core entry point, which is browser safe.
+ */
+
+/** The environment variable the Hermes key is read from. Server side only. */
+declare const API_KEY_VARIABLE = "PYTH_API_KEY";
+/** The feed a refresh writes: taken off a sale, or given by hand. */
+interface FeedChoice {
+    priceFeedId: FeedId;
+    /** Defaults to Pangu's own shard, the one its refresher writes. */
+    shard?: number;
+}
+interface RefreshPriceInput {
+    connection: Connection;
+    /** Who pays the fee. Anyone can: the payer is not part of the address. */
+    payer: PublicKey;
+    /** A sale read from the chain, or the feed by hand. */
+    sale?: Sale;
+    feed?: FeedChoice;
+    /**
+     * The Hermes API key. Defaults to `PYTH_API_KEY` in the environment, which is
+     * where it should live: it is never a value a browser or a caller passes in.
+     */
+    apiKey?: string;
+    /** Another Hermes host, for a self-hosted one. */
+    hermesUrl?: string;
+}
+/** One transaction of a refresh, unsigned, with the keys it needs besides the payer. */
+interface RefreshTransaction {
+    transaction: VersionedTransaction;
+    /** Ephemeral accounts the guardian-signed update is verified through. */
+    signers: Signer[];
+}
+interface RefreshPrice {
+    /**
+     * Unsigned, in order. The payer signs each one and sends them in this order:
+     * the update is posted into an encoded VAA account first and the price feed
+     * account is written from it second, and the pair does not fit in one
+     * transaction.
+     */
+    transactions: RefreshTransaction[];
+    /** The one account this feed and shard write to, for reading back afterwards. */
+    priceAccount: PublicKey;
+    shard: number;
+    /** Lowercase hex, no prefix. */
+    feedId: string;
+    /** Every transaction's bytes added up, against a limit of 1232 each. */
+    bytes: number;
+}
+/**
+ * Builds the transactions that write a fresh stock price into the one account
+ * this sale reads.
+ *
+ * Anybody can send them and the payer is not one of the account's seeds, so the
+ * address never moves and a sale can name it before anyone has ever refreshed
+ * it. It takes two transactions, not one: the guardian-signed update has to be
+ * posted into an encoded VAA account before the price feed account can be
+ * written from it, and the pair does not fit in 1232 bytes. So a refresh cannot
+ * ride along with a buy; send it first and the buy straight after, inside the
+ * age the sale allows.
+ *
+ * The encoded VAA account is closed by the last transaction, which is the
+ * difference between a refresh costing about 35 thousand lamports and about
+ * 2.4 million (docs/measurements/price-band-pyth.md). The price feed account
+ * itself is a program address, it is not one of the accounts closed, and it
+ * stays where it is.
+ *
+ * Node and server only. Signs and sends nothing.
+ *
+ * Throws PanguInputError when neither a sale nor a feed is given, when the sale
+ * has no band, when there is no API key, or when Hermes refuses.
+ */
+declare function refreshPriceTransaction(input: RefreshPriceInput): Promise<RefreshPrice>;
+
+export { API_KEY_VARIABLE, type FeedChoice, type RefreshPrice, type RefreshPriceInput, type RefreshTransaction, refreshPriceTransaction };