pangu-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the Pangu team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,217 @@
+# pangu-sdk
+
+The TypeScript client for Pangu, the rules program that sits on a stock token's
+first sale on Meteora's Dynamic Bonding Curve. It finds a sale's accounts, reads
+the sale and its buyers, builds Pangu's instructions, and turns a failed
+transaction into a sentence a buyer can read. It never signs and never sends.
+
+Safe to import on a server and in a browser: no top level work, no DOM.
+
+## Install
+
+```bash
+npm install pangu-sdk @solana/web3.js
+```
+
+## Read a sale
+
+```ts
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getSale, listBuyerRecords, saleStanding } from "pangu-sdk";
+
+const connection = new Connection(process.env.RPC_URL!);
+const mint = new PublicKey("...");
+
+const sale = await getSale(connection, mint);
+if (sale !== null) {
+  const standing = saleStanding(sale, await listBuyerRecords(connection, mint));
+  console.log(sale.cap, standing.buyers, standing.largestShare);
+}
+```
+
+## List every sale
+
+```ts
+import { saleDirectory } from "pangu-sdk";
+
+for (const entry of await saleDirectory(connection)) {
+  console.log(entry.symbol, entry.name, entry.running, entry.graduated, entry.offeringOver);
+}
+```
+
+No file of addresses needed: one scan finds every sale's rules, then the mints,
+the pools and the chain's clock are read in calls of 100, so fifty sales cost
+three calls. Names and symbols come from the metadata DBC writes on the mint;
+they are whatever the issuer typed, so the mint is what identifies a sale.
+`graduated` is null when the pool cannot be read as the one selling the mint. A
+rules account from a layout this package does not read is left out rather than
+thrown; pass `onSkipped` to hear about each one. `listSales` and
+`saleTokenInfo` are the two halves on their own.
+
+## Open a sale
+
+```ts
+import { createSaleInstruction, ACCESS_MODE } from "pangu-sdk";
+
+const instruction = createSaleInstruction({
+  issuer: wallet.publicKey,
+  pool,
+  mint,
+  cap: 100_000_000n,
+  accessMode: ACCESS_MODE.issuerList,
+  dbcConfig,
+  quoteMint,
+  endsAt: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
+});
+```
+
+`dbcConfig` is the launch template the pool was opened on and `quoteMint` is the
+paying token it names. Both are needed on every sale: the program stores the
+paying token and refuses one the issuer can freeze. `endsAt` is the end of the
+offering period in unix seconds, after which every rule lifts; leave it out for
+no end, and the rules hold until graduation. The cap must stay below the
+curve's supply, since a cap covering the whole sale is no cap at all.
+
+The builder refuses anything the program would refuse, before it builds. Pass a
+`band` to add the price ceiling against the real stock price:
+
+```ts
+band: {
+  bps: 1_000,
+  priceFeedId: "49f6b65c...5688",
+  maxPriceAgeSecs: 60,
+  maxConfBps: 100,
+}
+```
+
+The Pyth price account is derived for you from the feed id and the shard, which
+defaults to Pangu's own, so there is no address to get wrong.
+
+## Verify buyers
+
+A sale in credential mode sells only to wallets a verifier has attested on the
+Solana Attestation Service. These four are everything a verifier does; the app
+runs them at `/verify`.
+
+### Set up
+
+```ts
+const credential = credentialAddress(verifier, "Acme KYC");
+const schema = schemaAddress(credential, "pangu-buyer");
+tx.add(createCredentialInstruction({ payer: verifier, authority: verifier, name: "Acme KYC", signers: [verifier] }));
+tx.add(createSchemaInstruction({ payer: verifier, authority: verifier, credential, name: "pangu-buyer", description: "checked buyers" }));
+```
+
+### Issue
+
+```ts
+tx.add(createAttestationInstruction({ payer: verifier, authorizedSigner: verifier, credential, schema, wallet: buyer, expiry }));
+```
+
+`expiry` is unix seconds, or zero for never. The buyer's wallet is the nonce,
+which is the one address Pangu's hook looks at.
+
+### Check
+
+```ts
+const standing = await credentialStatus(connection, credential, schema, buyer); // "valid" | "expired" | "absent"
+const issued = await listAttestations(connection, credential, schema); // wallet, expiry, created, standing
+```
+
+### Revoke
+
+```ts
+tx.add(closeAttestationInstruction({ payer: verifier, authorizedSigner: verifier, credential, schema, wallet: buyer }));
+```
+
+Closing is the service's only revocation. The deposit returns to the payer and
+the wallet's next buy is refused with `CredentialInvalid`.
+
+## Run a sale on Meteora
+
+`pangu-sdk/dbc` is the second entry point. It pulls in Meteora's Dynamic Bonding
+Curve SDK, so a page that only reads a sale never downloads it. Every function
+returns an unsigned transaction and its size in bytes.
+
+```ts
+import {
+  launchTemplateTransaction,
+  openSaleTransaction,
+  buyTransaction,
+  preflightBuy,
+  claimFeesTransaction,
+  graduateTransaction,
+  saleProgress,
+} from "pangu-sdk/dbc";
+
+const { transaction, config } = await launchTemplateTransaction({
+  connection,
+  partner: wallet.publicKey,
+  quoteMint,
+  curve,
+});
+
+const sale = await openSaleTransaction({
+  connection,
+  creator: wallet.publicKey,
+  config: config.publicKey,
+  name: "Acme Shares",
+  symbol: "ACME",
+  uri,
+  sale: { capShareBps: 1_000, accessMode: 1, endsAt },
+});
+```
+
+The template forces the settings a Pangu sale depends on and throws if you try
+to set them otherwise: Token-2022, Pangu as the hook, graduation to DAMM v2,
+fees collected in the paying token only, and a token authority option that
+leaves nobody able to mint more. The pool and the sale's rules land in one
+transaction, so nobody else can set the rules for your mint.
+
+`preflightBuy` reads the chain and tells a buyer what would happen before they
+sign: no record, not approved, an approval that is missing, expired or signed by
+a key the verifier has dropped, over the cap with the room left, price above the
+ceiling, price too uncertain, or price stale. A stale price is also what a shut
+stock market looks like: Pyth stops publishing an equity outside its trading
+sessions, so the account stops moving and ages out.
+
+### Buy and sell
+
+```ts
+const buy = await buyTransaction({ connection, buyer, mint, amountIn, minimumAmountOut });
+const sell = await sellTransaction({ connection, seller, mint, amountIn, minimumQuoteOut });
+```
+
+The floor is the least the trade may return before the chain refuses it. Set
+it from the quote the person was shown, less the slippage you told them, so the
+floor is what they agreed to. Leave it out and the builder takes 1 percent under
+a fresh quote of its own (`slippageBps` changes the 1 percent), which can sit
+below what a page showed a few seconds earlier. With a floor set, the builder
+reads the market again and throws `PanguInputError` ("the market moved") when
+the trade already returns less, so no wallet is asked to sign a trade that
+would fail.
+
+## Keep the price fresh
+
+`pangu-sdk/price` is the third entry point, for a sale with a price band. It is
+Node and server only, so call it from a server route.
+
+```ts
+import { refreshPriceTransaction } from "pangu-sdk/price";
+
+const { transactions, priceAccount } = await refreshPriceTransaction({
+  connection,
+  payer: serverWallet.publicKey,
+  sale,
+});
+```
+
+It reads Pyth's Hermes service, which has needed an API key since 26 August
+2026. The key is taken from `PYTH_API_KEY` in the server's environment and is
+never a value the browser holds or the package prints. A refresh is two
+transactions, not one: the guardian-signed update goes into a holding account
+first and the price account is written from it second, and the pair does not fit
+in one transaction. Sign and send them in the order given, then send the buy.
+
+Reading the price back is `readPrice` in the core entry point. It decodes the
+price account itself, so it is safe in a browser and needs no Pyth package.

package/dist/accounts-BuD-oCcr.d.mts

@@ -0,0 +1,206 @@
+import { PublicKey, Connection } from '@solana/web3.js';
+
+/** A Pyth feed id, either 32 raw bytes or the same bytes written as hex. */
+type FeedId = string | Uint8Array | number[];
+/**
+ * The one place a feed id is turned into bytes.
+ *
+ * Everything that derives an address or encodes an instruction goes through
+ * this, so a hex string and a byte array can never be compared after two
+ * different readings. A leading "0x" is accepted because that is how the feed
+ * scripts print ids. Anything that is not exactly 32 bytes is refused.
+ */
+declare function feedIdBytes(id: FeedId): Uint8Array;
+/** The same id as lowercase hex with no prefix, which is how the feed scripts print it. */
+declare function feedIdHex(id: FeedId): string;
+/** The rules account of one sale. Seeds "sale" and the mint. */
+declare function saleRulesAddress(mint: PublicKey): PublicKey;
+/** One wallet's record in one sale. Seeds "buyer", the mint and the wallet. */
+declare function buyerRecordAddress(mint: PublicKey, wallet: PublicKey): PublicKey;
+/** The transfer hook's published account list. Seeds fixed by the SPL interface. */
+declare function extraAccountListAddress(mint: PublicKey): PublicKey;
+/**
+ * The one address an attestation for this credential, schema and wallet can have.
+ * Derived under the attestation service, not under Pangu.
+ */
+declare function attestationAddress(credential: PublicKey, schema: PublicKey, wallet: PublicKey): PublicKey;
+/** The pool's base token vault. Derived under DBC, which is what owns it. */
+declare function dbcBaseVaultAddress(mint: PublicKey, pool: PublicKey): PublicKey;
+/**
+ * The one price feed account a Pyth shard and feed id can produce.
+ *
+ * The seeds are the shard id as two little endian bytes and then the 32 byte
+ * feed id, under Pyth's price feed program. The payer is not a seed, so the
+ * address is fixed before anybody has refreshed it and nobody can create a
+ * rival account for the same shard and feed. This is the same derivation
+ * `price_feed_address` runs in programs/pangu/src/price.rs, and the same one
+ * `getPriceFeedAccountForProgram` runs in `@pythnetwork/pyth-solana-receiver`.
+ *
+ * The shard defaults to Pangu's own, which is the shard Pangu's refresher
+ * writes. Throws PanguInputError for a shard outside the two bytes it is
+ * written into, or a feed id that is not 32 bytes.
+ */
+declare function priceFeedAddress(feedId: FeedId, shard?: number): PublicKey;
+
+/**
+ * Thrown before anything is built when an input could never pass on chain.
+ *
+ * Every message names the rule and the value, because the caller is usually a
+ * form in the app and the text goes straight to the person filling it in.
+ */
+declare class PanguInputError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Thrown when a SaleRules account was not written by the layout this package
+ * reads: the wrong length, or a layout version it does not know.
+ *
+ * Both are the same failure seen from two sides. Anchor's decoder reads every
+ * field at a fixed offset and does not care what wrote the bytes, so an account
+ * from another build comes back as a sale with a nonsense cap or a nonsense
+ * band rather than as an error. It is a PanguInputError, so a caller that
+ * already handles those keeps working.
+ */
+declare class PanguLayoutError extends PanguInputError {
+    constructor(message: string);
+}
+/** One sale's rules, as the chain holds them. Written once, never updated. */
+interface Sale {
+    mint: PublicKey;
+    pool: PublicKey;
+    baseVault: PublicKey;
+    issuer: PublicKey;
+    /** Raw token units, so a six decimal token's cap of 100 reads as 100000000n. */
+    cap: bigint;
+    accessMode: number;
+    credential: PublicKey;
+    schema: PublicKey;
+    /** Band only: the Pyth price feed account the hook reads. */
+    priceAccount: PublicKey;
+    bandBps: number;
+    /** Lowercase hex, no prefix, the way the feed scripts print an id. */
+    priceFeedId: string;
+    /** The Pyth shard the price account was derived under. */
+    priceShard: number;
+    /** How old the published price may be on a buy, in seconds. */
+    maxPriceAgeSecs: number;
+    /** The widest confidence interval this sale buys against, in basis points. */
+    maxConfBps: number;
+    /**
+     * Decimals of the sale token. The program only stores these on a sale with a
+     * price band, so the chain holds zero for every other sale. `getSale` fills
+     * that in from the mint itself; `decodeSale`, which only has the bytes in
+     * front of it, hands back the zero the account really holds.
+     */
+    baseDecimals: number;
+    /** Decimals of the paying token, stored only on a sale with a price band. */
+    quoteDecimals: number;
+    buyers: number;
+    totalNetBought: bigint;
+    bump: number;
+    /** Which layout wrote this account: 1 or 2. */
+    layoutVersion: number;
+    /**
+     * The token buyers pay in, stored by layout 2 onwards. Null on a version 1
+     * sale, which never recorded it; its launch template still names it.
+     */
+    quoteMint: PublicKey | null;
+    /**
+     * Unix seconds at which the offering period ends and every rule lifts. Null
+     * when the sale has no end, which includes every version 1 sale.
+     */
+    endsAt: number | null;
+    /** Spare bytes the program keeps so the account can grow later. */
+    reserved: Uint8Array;
+    /** True when this sale has a price band, matching SaleRules::has_band. */
+    hasBand: boolean;
+}
+/** One wallet's standing in one sale. */
+interface BuyerRecord {
+    mint: PublicKey;
+    wallet: PublicKey;
+    approved: boolean;
+    /** Tokens received from the pool minus tokens sold back, in raw units. */
+    netBought: bigint;
+    bump: number;
+}
+/**
+ * Reads a SaleRules account's bytes.
+ *
+ * The discriminator says these are a SaleRules, then the length and the layout
+ * version say which build wrote them. Versions 1 and 2 are read; on version 1
+ * the paying token and the end of the offering come back as null, because
+ * those bytes were spare zeros then. Anything else throws a `PanguLayoutError`,
+ * because an account from another build sits at the same address behind the
+ * same discriminator: Anchor reads it without complaint and hands back fields
+ * taken from the wrong offsets.
+ *
+ * Throws `PanguInputError` when the bytes are not a SaleRules at all.
+ */
+declare function decodeSale(data: Uint8Array): Sale;
+/** Reads a BuyerRecord account's bytes. Throws when they are not a BuyerRecord. */
+declare function decodeBuyerRecord(data: Uint8Array): BuyerRecord;
+/**
+ * The rules of the sale for this mint, or null when no sale was ever opened.
+ *
+ * An account sitting at the rules address that Pangu does not own is refused
+ * rather than decoded, because at that point the reader cannot tell what the
+ * bytes mean.
+ *
+ * A sale with no price band stores no decimals, because the hook never needs
+ * them, so one more read fills `baseDecimals` from the mint. That keeps every
+ * caller turning raw units into an amount a person reads off one field instead
+ * of each one remembering the exception. A mint that cannot be read leaves the
+ * zero in place.
+ */
+declare function getSale(connection: Connection, mint: PublicKey): Promise<Sale | null>;
+/** One wallet's record in this sale, or null when the wallet has none yet. */
+declare function getBuyerRecord(connection: Connection, mint: PublicKey, wallet: PublicKey): Promise<BuyerRecord | null>;
+/**
+ * Every buyer record of one sale.
+ *
+ * The filter is the record discriminator followed by the sale's mint, which is
+ * the record's first field, so the node only returns this sale's records. The
+ * caller pays for one scan, and an RPC that refuses getProgramAccounts will
+ * throw rather than return a short list.
+ */
+declare function listBuyerRecords(connection: Connection, mint: PublicKey): Promise<BuyerRecord[]>;
+/** What `listSales` can be told, beyond the connection. */
+interface ListSalesOptions {
+    /**
+     * Called once for every rules account left out of the list, with its address
+     * and the reason in words. Count the calls to know how many were skipped.
+     */
+    onSkipped?: (address: PublicKey, reason: string) => void;
+}
+/**
+ * Every sale the Pangu program holds rules for, in no particular order.
+ *
+ * One scan, filtered by the node on the SaleRules discriminator and on the size
+ * this build writes, so buyer records and the larger accounts an earlier build
+ * left behind never come back. An account of the right size that this package
+ * cannot read, a layout version it does not know, or one that does not sit at
+ * the rules address of the mint it names, is skipped and reported through
+ * `onSkipped` rather than thrown, so one stray account cannot hide every other
+ * sale. Each sale comes back exactly as `decodeSale` reads it, so a sale with no
+ * price band still shows zero decimals here; `getSale` or `saleDirectory` fill
+ * them from the mint.
+ *
+ * Throws when the node refuses the scan, because a short list would look like
+ * a complete one.
+ */
+declare function listSales(connection: Connection, options?: ListSalesOptions): Promise<Sale[]>;
+/**
+ * Whether the sale is still running, read off the token itself.
+ *
+ * The rules live on while the mint names Pangu as its transfer hook. DBC clears
+ * that name in the trade that completes the curve, and from then on the token
+ * moves freely and any buyer can close their record. This is not a gate on
+ * closing: a record holding nothing closes while the sale is still running. A
+ * mint that does not exist, is not a Token-2022 mint, or names another hook is
+ * not a running Pangu sale.
+ */
+declare function isSaleRunning(connection: Connection, mint: PublicKey): Promise<boolean>;
+
+export { type BuyerRecord as B, type FeedId as F, type ListSalesOptions as L, PanguInputError as P, type Sale as S, PanguLayoutError as a, attestationAddress as b, buyerRecordAddress as c, dbcBaseVaultAddress as d, decodeBuyerRecord as e, decodeSale as f, extraAccountListAddress as g, feedIdBytes as h, feedIdHex as i, getBuyerRecord as j, getSale as k, isSaleRunning as l, listBuyerRecords as m, listSales as n, priceFeedAddress as p, saleRulesAddress as s };

package/dist/accounts-BuD-oCcr.d.ts

@@ -0,0 +1,206 @@
+import { PublicKey, Connection } from '@solana/web3.js';
+
+/** A Pyth feed id, either 32 raw bytes or the same bytes written as hex. */
+type FeedId = string | Uint8Array | number[];
+/**
+ * The one place a feed id is turned into bytes.
+ *
+ * Everything that derives an address or encodes an instruction goes through
+ * this, so a hex string and a byte array can never be compared after two
+ * different readings. A leading "0x" is accepted because that is how the feed
+ * scripts print ids. Anything that is not exactly 32 bytes is refused.
+ */
+declare function feedIdBytes(id: FeedId): Uint8Array;
+/** The same id as lowercase hex with no prefix, which is how the feed scripts print it. */
+declare function feedIdHex(id: FeedId): string;
+/** The rules account of one sale. Seeds "sale" and the mint. */
+declare function saleRulesAddress(mint: PublicKey): PublicKey;
+/** One wallet's record in one sale. Seeds "buyer", the mint and the wallet. */
+declare function buyerRecordAddress(mint: PublicKey, wallet: PublicKey): PublicKey;
+/** The transfer hook's published account list. Seeds fixed by the SPL interface. */
+declare function extraAccountListAddress(mint: PublicKey): PublicKey;
+/**
+ * The one address an attestation for this credential, schema and wallet can have.
+ * Derived under the attestation service, not under Pangu.
+ */
+declare function attestationAddress(credential: PublicKey, schema: PublicKey, wallet: PublicKey): PublicKey;
+/** The pool's base token vault. Derived under DBC, which is what owns it. */
+declare function dbcBaseVaultAddress(mint: PublicKey, pool: PublicKey): PublicKey;
+/**
+ * The one price feed account a Pyth shard and feed id can produce.
+ *
+ * The seeds are the shard id as two little endian bytes and then the 32 byte
+ * feed id, under Pyth's price feed program. The payer is not a seed, so the
+ * address is fixed before anybody has refreshed it and nobody can create a
+ * rival account for the same shard and feed. This is the same derivation
+ * `price_feed_address` runs in programs/pangu/src/price.rs, and the same one
+ * `getPriceFeedAccountForProgram` runs in `@pythnetwork/pyth-solana-receiver`.
+ *
+ * The shard defaults to Pangu's own, which is the shard Pangu's refresher
+ * writes. Throws PanguInputError for a shard outside the two bytes it is
+ * written into, or a feed id that is not 32 bytes.
+ */
+declare function priceFeedAddress(feedId: FeedId, shard?: number): PublicKey;
+
+/**
+ * Thrown before anything is built when an input could never pass on chain.
+ *
+ * Every message names the rule and the value, because the caller is usually a
+ * form in the app and the text goes straight to the person filling it in.
+ */
+declare class PanguInputError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Thrown when a SaleRules account was not written by the layout this package
+ * reads: the wrong length, or a layout version it does not know.
+ *
+ * Both are the same failure seen from two sides. Anchor's decoder reads every
+ * field at a fixed offset and does not care what wrote the bytes, so an account
+ * from another build comes back as a sale with a nonsense cap or a nonsense
+ * band rather than as an error. It is a PanguInputError, so a caller that
+ * already handles those keeps working.
+ */
+declare class PanguLayoutError extends PanguInputError {
+    constructor(message: string);
+}
+/** One sale's rules, as the chain holds them. Written once, never updated. */
+interface Sale {
+    mint: PublicKey;
+    pool: PublicKey;
+    baseVault: PublicKey;
+    issuer: PublicKey;
+    /** Raw token units, so a six decimal token's cap of 100 reads as 100000000n. */
+    cap: bigint;
+    accessMode: number;
+    credential: PublicKey;
+    schema: PublicKey;
+    /** Band only: the Pyth price feed account the hook reads. */
+    priceAccount: PublicKey;
+    bandBps: number;
+    /** Lowercase hex, no prefix, the way the feed scripts print an id. */
+    priceFeedId: string;
+    /** The Pyth shard the price account was derived under. */
+    priceShard: number;
+    /** How old the published price may be on a buy, in seconds. */
+    maxPriceAgeSecs: number;
+    /** The widest confidence interval this sale buys against, in basis points. */
+    maxConfBps: number;
+    /**
+     * Decimals of the sale token. The program only stores these on a sale with a
+     * price band, so the chain holds zero for every other sale. `getSale` fills
+     * that in from the mint itself; `decodeSale`, which only has the bytes in
+     * front of it, hands back the zero the account really holds.
+     */
+    baseDecimals: number;
+    /** Decimals of the paying token, stored only on a sale with a price band. */
+    quoteDecimals: number;
+    buyers: number;
+    totalNetBought: bigint;
+    bump: number;
+    /** Which layout wrote this account: 1 or 2. */
+    layoutVersion: number;
+    /**
+     * The token buyers pay in, stored by layout 2 onwards. Null on a version 1
+     * sale, which never recorded it; its launch template still names it.
+     */
+    quoteMint: PublicKey | null;
+    /**
+     * Unix seconds at which the offering period ends and every rule lifts. Null
+     * when the sale has no end, which includes every version 1 sale.
+     */
+    endsAt: number | null;
+    /** Spare bytes the program keeps so the account can grow later. */
+    reserved: Uint8Array;
+    /** True when this sale has a price band, matching SaleRules::has_band. */
+    hasBand: boolean;
+}
+/** One wallet's standing in one sale. */
+interface BuyerRecord {
+    mint: PublicKey;
+    wallet: PublicKey;
+    approved: boolean;
+    /** Tokens received from the pool minus tokens sold back, in raw units. */
+    netBought: bigint;
+    bump: number;
+}
+/**
+ * Reads a SaleRules account's bytes.
+ *
+ * The discriminator says these are a SaleRules, then the length and the layout
+ * version say which build wrote them. Versions 1 and 2 are read; on version 1
+ * the paying token and the end of the offering come back as null, because
+ * those bytes were spare zeros then. Anything else throws a `PanguLayoutError`,
+ * because an account from another build sits at the same address behind the
+ * same discriminator: Anchor reads it without complaint and hands back fields
+ * taken from the wrong offsets.
+ *
+ * Throws `PanguInputError` when the bytes are not a SaleRules at all.
+ */
+declare function decodeSale(data: Uint8Array): Sale;
+/** Reads a BuyerRecord account's bytes. Throws when they are not a BuyerRecord. */
+declare function decodeBuyerRecord(data: Uint8Array): BuyerRecord;
+/**
+ * The rules of the sale for this mint, or null when no sale was ever opened.
+ *
+ * An account sitting at the rules address that Pangu does not own is refused
+ * rather than decoded, because at that point the reader cannot tell what the
+ * bytes mean.
+ *
+ * A sale with no price band stores no decimals, because the hook never needs
+ * them, so one more read fills `baseDecimals` from the mint. That keeps every
+ * caller turning raw units into an amount a person reads off one field instead
+ * of each one remembering the exception. A mint that cannot be read leaves the
+ * zero in place.
+ */
+declare function getSale(connection: Connection, mint: PublicKey): Promise<Sale | null>;
+/** One wallet's record in this sale, or null when the wallet has none yet. */
+declare function getBuyerRecord(connection: Connection, mint: PublicKey, wallet: PublicKey): Promise<BuyerRecord | null>;
+/**
+ * Every buyer record of one sale.
+ *
+ * The filter is the record discriminator followed by the sale's mint, which is
+ * the record's first field, so the node only returns this sale's records. The
+ * caller pays for one scan, and an RPC that refuses getProgramAccounts will
+ * throw rather than return a short list.
+ */
+declare function listBuyerRecords(connection: Connection, mint: PublicKey): Promise<BuyerRecord[]>;
+/** What `listSales` can be told, beyond the connection. */
+interface ListSalesOptions {
+    /**
+     * Called once for every rules account left out of the list, with its address
+     * and the reason in words. Count the calls to know how many were skipped.
+     */
+    onSkipped?: (address: PublicKey, reason: string) => void;
+}
+/**
+ * Every sale the Pangu program holds rules for, in no particular order.
+ *
+ * One scan, filtered by the node on the SaleRules discriminator and on the size
+ * this build writes, so buyer records and the larger accounts an earlier build
+ * left behind never come back. An account of the right size that this package
+ * cannot read, a layout version it does not know, or one that does not sit at
+ * the rules address of the mint it names, is skipped and reported through
+ * `onSkipped` rather than thrown, so one stray account cannot hide every other
+ * sale. Each sale comes back exactly as `decodeSale` reads it, so a sale with no
+ * price band still shows zero decimals here; `getSale` or `saleDirectory` fill
+ * them from the mint.
+ *
+ * Throws when the node refuses the scan, because a short list would look like
+ * a complete one.
+ */
+declare function listSales(connection: Connection, options?: ListSalesOptions): Promise<Sale[]>;
+/**
+ * Whether the sale is still running, read off the token itself.
+ *
+ * The rules live on while the mint names Pangu as its transfer hook. DBC clears
+ * that name in the trade that completes the curve, and from then on the token
+ * moves freely and any buyer can close their record. This is not a gate on
+ * closing: a record holding nothing closes while the sale is still running. A
+ * mint that does not exist, is not a Token-2022 mint, or names another hook is
+ * not a running Pangu sale.
+ */
+declare function isSaleRunning(connection: Connection, mint: PublicKey): Promise<boolean>;
+
+export { type BuyerRecord as B, type FeedId as F, type ListSalesOptions as L, PanguInputError as P, type Sale as S, PanguLayoutError as a, attestationAddress as b, buyerRecordAddress as c, dbcBaseVaultAddress as d, decodeBuyerRecord as e, decodeSale as f, extraAccountListAddress as g, feedIdBytes as h, feedIdHex as i, getBuyerRecord as j, getSale as k, isSaleRunning as l, listBuyerRecords as m, listSales as n, priceFeedAddress as p, saleRulesAddress as s };