pangu-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2803 @@
+// src/constants.ts
+import { PublicKey } from "@solana/web3.js";
+import { TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";
+
+// src/idl/pangu.json
+var pangu_default = {
+  address: "4Nd46mDiaTSkqXPAXKqT4jkahcz1TxVSdoirbBCAr5qG",
+  metadata: {
+    name: "pangu",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Rules for a fair first sale of a stock token on Meteora DBC"
+  },
+  docs: [
+    "Pangu holds the rules of a stock token's first sale on Meteora's Dynamic Bonding",
+    "Curve: a cap per wallet, an optional issuer-approved buyer list, an optional",
+    "ceiling against the real stock's live price, and no wallet-to-wallet movement",
+    "until the sale is over. DBC finds the price, Pangu decides who may receive",
+    "tokens and how many."
+  ],
+  instructions: [
+    {
+      name: "approve_buyer",
+      discriminator: [
+        193,
+        6,
+        144,
+        245,
+        24,
+        184,
+        227,
+        19
+      ],
+      accounts: [
+        {
+          name: "issuer",
+          writable: true,
+          signer: true,
+          relations: [
+            "rules"
+          ]
+        },
+        {
+          name: "mint",
+          relations: [
+            "rules"
+          ]
+        },
+        {
+          name: "rules",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  98,
+                  117,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "arg",
+                path: "wallet"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "wallet",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "close_buyer_record",
+      discriminator: [
+        27,
+        105,
+        238,
+        144,
+        158,
+        212,
+        40,
+        114
+      ],
+      accounts: [
+        {
+          name: "wallet",
+          writable: true,
+          signer: true,
+          relations: [
+            "record"
+          ]
+        },
+        {
+          name: "mint",
+          relations: [
+            "record"
+          ]
+        },
+        {
+          name: "record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  98,
+                  117,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "account",
+                path: "wallet"
+              }
+            ]
+          }
+        },
+        {
+          name: "rules",
+          docs: [
+            "offering period is over, and only when the bytes are a SaleRules in a",
+            "layout this build reads. Anything else, including rules written by an",
+            'older build, reads as "not over" and leaves the two older ways in exactly',
+            "as they were, so this account can never stop a close that worked before."
+          ],
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_sale",
+      discriminator: [
+        137,
+        197,
+        124,
+        245,
+        254,
+        35,
+        17,
+        12
+      ],
+      accounts: [
+        {
+          name: "issuer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool",
+          docs: [
+            "owning program, the length and the discriminator before any field is used."
+          ]
+        },
+        {
+          name: "mint",
+          docs: [
+            "owning program is checked there before the bytes are read."
+          ]
+        },
+        {
+          name: "credential",
+          docs: [
+            "key named in `credential`, owned by the attestation service, and to carry",
+            "the credential discriminator. Refused outright in the other modes."
+          ],
+          optional: true
+        },
+        {
+          name: "schema",
+          docs: [
+            "key named in `schema`, owned by the attestation service, to belong to",
+            "`credential`, and not to be paused. Refused outright in the other modes."
+          ],
+          optional: true
+        },
+        {
+          name: "dbc_config",
+          docs: [
+            "template this pool names, owned by DBC and of the right kind. Its fee mode",
+            "and the supply its curve sells decide whether the sale may open at all, and",
+            "it names the paying token."
+          ]
+        },
+        {
+          name: "quote_mint",
+          docs: [
+            "Required in every mode. Must be the paying token the template names. It is",
+            "stored in the rules, its freeze authority is checked, and on a banded sale",
+            "its decimals are stored so the hook can turn a curve price into dollars",
+            "without being handed a mint at buy time."
+          ]
+        },
+        {
+          name: "rules",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "extra_account_meta_list",
+          docs: [
+            "seeds the transfer-hook interface requires, and `init` makes it single-use."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  101,
+                  120,
+                  116,
+                  114,
+                  97,
+                  45,
+                  97,
+                  99,
+                  99,
+                  111,
+                  117,
+                  110,
+                  116,
+                  45,
+                  109,
+                  101,
+                  116,
+                  97,
+                  115
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "cap",
+          type: "u64"
+        },
+        {
+          name: "access_mode",
+          type: "u8"
+        },
+        {
+          name: "credential",
+          type: "pubkey"
+        },
+        {
+          name: "schema",
+          type: "pubkey"
+        },
+        {
+          name: "band",
+          type: {
+            defined: {
+              name: "PriceBand"
+            }
+          }
+        },
+        {
+          name: "ends_at",
+          type: "i64"
+        }
+      ]
+    },
+    {
+      name: "execute",
+      discriminator: [
+        105,
+        37,
+        101,
+        197,
+        75,
+        251,
+        102,
+        26
+      ],
+      accounts: [
+        {
+          name: "source_token",
+          docs: [
+            "owning program is checked. Nothing is read from it before that."
+          ]
+        },
+        {
+          name: "mint",
+          docs: [
+            "the rules account is proven to be the one derived from it."
+          ],
+          relations: [
+            "rules"
+          ]
+        },
+        {
+          name: "destination_token",
+          docs: [
+            "owning program is checked."
+          ]
+        },
+        {
+          name: "authority",
+          docs: [
+            "because a signature proves nothing about who is allowed to receive tokens."
+          ]
+        },
+        {
+          name: "extra_account_meta_list",
+          docs: [
+            "Token-2022 resolves the extra accounts from it before the call. Pangu itself",
+            "reads nothing out of it, so it is carried, not trusted."
+          ]
+        },
+        {
+          name: "rules",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "destination_record",
+          docs: [
+            "program, discriminator, mint and wallet are all checked by hand below."
+          ],
+          writable: true
+        },
+        {
+          name: "source_record",
+          docs: [
+            "program, discriminator, mint and wallet are all checked by hand below."
+          ],
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "open_buyer_record",
+      discriminator: [
+        216,
+        212,
+        35,
+        190,
+        138,
+        99,
+        66,
+        197
+      ],
+      accounts: [
+        {
+          name: "wallet",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "mint"
+        },
+        {
+          name: "rules",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  98,
+                  117,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "account",
+                path: "wallet"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "revoke_buyer",
+      discriminator: [
+        78,
+        97,
+        108,
+        126,
+        172,
+        157,
+        228,
+        134
+      ],
+      accounts: [
+        {
+          name: "issuer",
+          signer: true,
+          relations: [
+            "rules"
+          ]
+        },
+        {
+          name: "mint",
+          relations: [
+            "rules",
+            "record"
+          ]
+        },
+        {
+          name: "rules",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  97,
+                  108,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  98,
+                  117,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "arg",
+                path: "wallet"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "wallet",
+          type: "pubkey"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "BuyerRecord",
+      discriminator: [
+        107,
+        122,
+        54,
+        31,
+        4,
+        54,
+        209,
+        38
+      ]
+    },
+    {
+      name: "SaleRules",
+      discriminator: [
+        39,
+        103,
+        95,
+        70,
+        15,
+        23,
+        201,
+        128
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "Bought",
+      discriminator: [
+        193,
+        56,
+        215,
+        24,
+        156,
+        76,
+        42,
+        104
+      ]
+    },
+    {
+      name: "BuyerApproved",
+      discriminator: [
+        146,
+        41,
+        51,
+        7,
+        192,
+        96,
+        249,
+        196
+      ]
+    },
+    {
+      name: "BuyerRecordClosed",
+      discriminator: [
+        175,
+        245,
+        14,
+        122,
+        129,
+        113,
+        23,
+        155
+      ]
+    },
+    {
+      name: "BuyerRecordOpened",
+      discriminator: [
+        249,
+        239,
+        77,
+        35,
+        176,
+        81,
+        45,
+        85
+      ]
+    },
+    {
+      name: "BuyerRevoked",
+      discriminator: [
+        116,
+        129,
+        248,
+        92,
+        255,
+        222,
+        13,
+        59
+      ]
+    },
+    {
+      name: "SaleCreated",
+      discriminator: [
+        164,
+        187,
+        32,
+        35,
+        143,
+        167,
+        235,
+        132
+      ]
+    },
+    {
+      name: "SoldBack",
+      discriminator: [
+        153,
+        215,
+        200,
+        12,
+        194,
+        138,
+        190,
+        253
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "NotTransferring",
+      msg: "Token-2022 is not mid-transfer on both token accounts"
+    },
+    {
+      code: 6001,
+      name: "ReceivingAccountOwnerCanChange",
+      msg: "the receiving token account's owner can still be changed"
+    },
+    {
+      code: 6002,
+      name: "WrongMint",
+      msg: "the account does not belong to this sale's mint"
+    },
+    {
+      code: 6003,
+      name: "WrongBuyerRecord",
+      msg: "the buyer record is not the one for this wallet"
+    },
+    {
+      code: 6004,
+      name: "BuyerRecordMissing",
+      msg: "this wallet has no buyer record yet"
+    },
+    {
+      code: 6005,
+      name: "NotApproved",
+      msg: "this wallet is not on the issuer's approved list"
+    },
+    {
+      code: 6006,
+      name: "CredentialInvalid",
+      msg: "the attestation is not valid for this wallet, credential and schema"
+    },
+    {
+      code: 6007,
+      name: "CredentialExpired",
+      msg: "the attestation has expired"
+    },
+    {
+      code: 6008,
+      name: "CredentialSignerNotAuthorized",
+      msg: "the key that signed the attestation is no longer an authorized signer"
+    },
+    {
+      code: 6009,
+      name: "OverCap",
+      msg: "this buy would take the wallet over the per-wallet cap"
+    },
+    {
+      code: 6010,
+      name: "WalletToWalletDuringSale",
+      msg: "the token cannot move between wallets while the sale is running"
+    },
+    {
+      code: 6011,
+      name: "PriceStale",
+      msg: "the reference price is too old, missing or not a positive number"
+    },
+    {
+      code: 6012,
+      name: "PriceOutsideBand",
+      msg: "the price is outside the allowed band"
+    },
+    {
+      code: 6013,
+      name: "WrongPriceAccount",
+      msg: "the price account is not the one named in the rules, or does not hold a usable price"
+    },
+    {
+      code: 6014,
+      name: "PriceNotFullyVerified",
+      msg: "the price update has not been signed by two thirds of the guardians"
+    },
+    {
+      code: 6015,
+      name: "PriceTooUncertain",
+      msg: "the price carries a wider confidence interval than this sale accepts"
+    },
+    {
+      code: 6016,
+      name: "NotPoolCreator",
+      msg: "the signer did not create this pool"
+    },
+    {
+      code: 6017,
+      name: "NotAHookPool",
+      msg: "the account is not a DBC transfer-hook pool"
+    },
+    {
+      code: 6018,
+      name: "HookProgramMismatch",
+      msg: "the mint's transfer hook does not name this program"
+    },
+    {
+      code: 6019,
+      name: "MintAuthorityStillSet",
+      msg: "someone can still mint this token, which would go straight past the cap"
+    },
+    {
+      code: 6020,
+      name: "WrongLaunchTemplate",
+      msg: "the launch template is not the one this pool was opened on"
+    },
+    {
+      code: 6021,
+      name: "FeesNotInQuoteToken",
+      msg: "the launch template collects fees in the sale token instead of the paying token"
+    },
+    {
+      code: 6022,
+      name: "ZeroCap",
+      msg: "the cap must be above zero"
+    },
+    {
+      code: 6023,
+      name: "InvalidAccessMode",
+      msg: "that access mode is not available"
+    },
+    {
+      code: 6024,
+      name: "InvalidBand",
+      msg: "the price band settings are incomplete, out of range, or set on a sale that has no band"
+    },
+    {
+      code: 6025,
+      name: "SaleStillRunning",
+      msg: "the sale is still running, the mint still names this program as its hook"
+    },
+    {
+      code: 6026,
+      name: "NotIssuer",
+      msg: "only the issuer can do this"
+    },
+    {
+      code: 6027,
+      name: "MathOverflow",
+      msg: "the counter would overflow"
+    },
+    {
+      code: 6028,
+      name: "WrongLayoutVersion",
+      msg: "these sale rules were written by another layout of the program"
+    },
+    {
+      code: 6029,
+      name: "BandNeedsDollarQuote",
+      msg: "a price band needs buyers to pay in a dollar token on this network's list"
+    },
+    {
+      code: 6030,
+      name: "IssuerControlsPayingToken",
+      msg: "the issuer can freeze the paying token, which would let them stop sellers being paid"
+    },
+    {
+      code: 6031,
+      name: "CapCoversWholeSale",
+      msg: "the cap is at or above everything the curve sells, so it limits nobody"
+    },
+    {
+      code: 6032,
+      name: "EndInThePast",
+      msg: "the offering period would end at a time that has already passed"
+    }
+  ],
+  types: [
+    {
+      name: "Bought",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "net_bought",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "BuyerApproved",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "BuyerRecord",
+      docs: [
+        "One wallet's standing in one sale. Keyed on the wallet that owns the token",
+        "account, never on the token account, so extra token accounts share one cap."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          },
+          {
+            name: "approved",
+            type: "bool"
+          },
+          {
+            name: "net_bought",
+            docs: [
+              "Tokens received from the pool minus tokens sold back to it."
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "BuyerRecordClosed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "BuyerRecordOpened",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "BuyerRevoked",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "PriceBand",
+      docs: [
+        "The price band settings, passed to `create_sale` as one value.",
+        "",
+        "They travel together because they are only meaningful together: the price",
+        "account's address is derived from the shard id and the feed id, so changing",
+        "either one changes which account the hook must read."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "band_bps",
+            docs: [
+              "How far above the live stock price a buy may leave the curve price, in",
+              "basis points. Zero switches the whole band off."
+            ],
+            type: "u16"
+          },
+          {
+            name: "price_account",
+            docs: [
+              "The Pyth price feed account. Must be the address the shard id and the feed",
+              "id below produce under Pyth's price feed program."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "price_feed_id",
+            docs: [
+              "The Pyth feed carrying the stock price in dollars."
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "price_shard",
+            docs: [
+              "Which of Pyth's shards this sale reads. A shard is just a second copy of",
+              "the same feed at a second address, so a sale can depend on a price its own",
+              "refresher keeps fresh rather than on Pyth's sponsored one."
+            ],
+            type: "u16"
+          },
+          {
+            name: "max_price_age_secs",
+            docs: [
+              "How old the published price may be on a buy, in seconds."
+            ],
+            type: "u32"
+          },
+          {
+            name: "max_conf_bps",
+            docs: [
+              "The widest confidence interval this sale will buy against, in basis points",
+              "of the price itself."
+            ],
+            type: "u16"
+          }
+        ]
+      }
+    },
+    {
+      name: "SaleCreated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "issuer",
+            type: "pubkey"
+          },
+          {
+            name: "base_vault",
+            type: "pubkey"
+          },
+          {
+            name: "cap",
+            type: "u64"
+          },
+          {
+            name: "access_mode",
+            type: "u8"
+          },
+          {
+            name: "band_bps",
+            type: "u16"
+          },
+          {
+            name: "quote_mint",
+            type: "pubkey"
+          },
+          {
+            name: "ends_at",
+            docs: [
+              "Unix seconds when the offering period ends and every rule lifts. Zero",
+              "means the rules hold until graduation."
+            ],
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "SaleRules",
+      docs: [
+        "The rules of one sale. Written once at creation and never changed: there is no",
+        "update instruction, which is what makes the cap a promise instead of a setting."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "base_vault",
+            docs: [
+              "The pool's base token vault, read out of the pool account at creation. The",
+              "hook tells a buy from a sell by comparing against this one address."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "issuer",
+            docs: [
+              "The pool creator. The only key that can approve or revoke buyers."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "cap",
+            docs: [
+              "Most tokens one wallet may hold net of sells, in raw units."
+            ],
+            type: "u64"
+          },
+          {
+            name: "access_mode",
+            type: "u8"
+          },
+          {
+            name: "credential",
+            docs: [
+              "Mode 2 only: the attestation credential whose approvals count. Zero",
+              "otherwise. Sits at byte 145 of the account, and the hook's extra accounts",
+              "are derived by reading it there, so it can never move."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "schema",
+            docs: [
+              "Mode 2 only: the attestation schema that counts. Zero otherwise. Sits at",
+              "byte 177 of the account, read the same way."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "price_account",
+            docs: [
+              "Band only: the Pyth price feed account, at byte 209. Zero otherwise."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "price_feed_id",
+            docs: [
+              "Band only: the Pyth feed the price account must carry, at byte 241."
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "price_shard",
+            docs: [
+              "Band only: the Pyth shard the price account was derived under."
+            ],
+            type: "u16"
+          },
+          {
+            name: "band_bps",
+            docs: [
+              "Zero means no band."
+            ],
+            type: "u16"
+          },
+          {
+            name: "max_price_age_secs",
+            type: "u32"
+          },
+          {
+            name: "max_conf_bps",
+            type: "u16"
+          },
+          {
+            name: "base_decimals",
+            docs: [
+              "Read off the two mints at creation, so the curve price can be turned into",
+              "dollars per whole token without trusting anything passed at buy time."
+            ],
+            type: "u8"
+          },
+          {
+            name: "quote_decimals",
+            type: "u8"
+          },
+          {
+            name: "buyers",
+            docs: [
+              "Wallets whose record is above zero right now."
+            ],
+            type: "u32"
+          },
+          {
+            name: "total_net_bought",
+            docs: [
+              "Sum of every record, so the app can show the largest holder's share."
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          },
+          {
+            name: "layout_version",
+            docs: [
+              "Which layout wrote this account, at byte 298. It takes the first of what",
+              "used to be the spare bytes, so the account is the same size and every",
+              "field in front of it sits exactly where it always did. A sale opened",
+              "before this byte existed reads as version 0, which is how a reader tells",
+              "the two apart instead of reading one layout's bytes as the other's."
+            ],
+            type: "u8"
+          },
+          {
+            name: "quote_mint",
+            docs: [
+              "The token buyers pay in, read from the launch template at creation, at",
+              "byte 299. Layout 2 onwards; a version 1 account holds zeros here."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "ends_at",
+            docs: [
+              "Unix seconds at which the offering period ends, at byte 331. From then on",
+              "every rule lifts and the token moves freely, so a curve that never fills",
+              "cannot hold the token in place for good. Zero means no end: the rules hold",
+              "until graduation. Fixed at creation like every other rule."
+            ],
+            type: "i64"
+          },
+          {
+            name: "reserved",
+            type: {
+              array: [
+                "u8",
+                23
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "SoldBack",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "wallet",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "net_bought",
+            type: "u64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/constants.ts
+var PANGU_IDL = pangu_default;
+var PANGU_PROGRAM_ID = new PublicKey(PANGU_IDL.address);
+var DBC_PROGRAM_ID = new PublicKey(
+  "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN"
+);
+var SAS_PROGRAM_ID = new PublicKey(
+  "22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG"
+);
+var PYTH_PRICE_FEED_PROGRAM_ID = new PublicKey(
+  "pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT"
+);
+var PYTH_RECEIVER_PROGRAM_ID = new PublicKey(
+  "rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ"
+);
+var PANGU_SHARD_ID = 7700;
+var SALE_RULES_LAYOUT_VERSIONS = /* @__PURE__ */ new Set([1, 2]);
+var ACCESS_MODE = {
+  open: 0,
+  issuerList: 1,
+  verifierCredential: 2
+};
+var SEEDS = {
+  sale: "sale",
+  buyer: "buyer",
+  extraAccountMetas: "extra-account-metas",
+  attestation: "attestation",
+  credential: "credential",
+  schema: "schema",
+  dbcTokenVault: "token_vault"
+};
+var LIMITS = {
+  /** price.rs MAX_BAND_BPS: half again over the live stock price. */
+  maxBandBps: 5e3,
+  minBandBps: 1,
+  /** price.rs MAX_PRICE_AGE_SECS, and create_sale.rs check_band takes 1..=3600. */
+  maxPriceAgeSecs: 3600,
+  minPriceAgeSecs: 1,
+  /** price.rs MAX_CONF_BPS: ten percent, and check_band takes 1..=1000. */
+  maxConfBps: 1e3,
+  minConfBps: 1,
+  /** price.rs MAX_DECIMALS. */
+  maxDecimals: 18,
+  /** Every Pyth feed id is 32 bytes. */
+  feedIdLength: 32,
+  /** A Pyth shard id is a u16, which is what the address seed holds. */
+  maxShard: 65535,
+  /** u64 raw token units, the widest cap the program can hold. */
+  maxCap: (1n << 64n) - 1n
+};
+var DOLLAR_MINT_ADDRESSES = {
+  mainnet: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"],
+  devnet: [
+    "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+    "2TYsrKmXKrqxLRULNBGFrGjTnxebo1H2azRb7bzQPem5"
+  ]
+};
+function dollarMints(network) {
+  if (!Object.prototype.hasOwnProperty.call(DOLLAR_MINT_ADDRESSES, network)) {
+    throw new Error(`no dollar list for network "${String(network)}": use "devnet" or "mainnet"`);
+  }
+  return DOLLAR_MINT_ADDRESSES[network].map((address) => new PublicKey(address));
+}
+
+// src/inputs.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+var PanguInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PanguInputError";
+  }
+};
+function requirePublicKey(value, field) {
+  if (!(value instanceof PublicKey2)) {
+    throw new PanguInputError(`${field} must be a PublicKey`);
+  }
+  return value;
+}
+function requireRealPublicKey(value, field) {
+  const key = requirePublicKey(value, field);
+  if (key.equals(PublicKey2.default)) {
+    throw new PanguInputError(`${field} must not be the all zero address`);
+  }
+  return key;
+}
+function requireAbsent(value, field, reason) {
+  if (value !== void 0 && value !== null) {
+    throw new PanguInputError(`${field} ${reason}`);
+  }
+}
+function requireWholeNumber(value, field, low, high) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new PanguInputError(`${field} must be a whole number`);
+  }
+  if (value < low || value > high) {
+    throw new PanguInputError(`${field} must be between ${low} and ${high}, got ${value}`);
+  }
+  return value;
+}
+function requireBigint(value, field) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return BigInt(value);
+  }
+  throw new PanguInputError(`${field} must be a bigint`);
+}
+
+// src/addresses.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+var HEX = /^[0-9a-fA-F]+$/;
+function seed(text) {
+  return new TextEncoder().encode(text);
+}
+function feedIdBytes(id) {
+  let bytes;
+  if (typeof id === "string") {
+    const text = id.startsWith("0x") || id.startsWith("0X") ? id.slice(2) : id;
+    if (text.length !== LIMITS.feedIdLength * 2 || !HEX.test(text)) {
+      throw new PanguInputError(
+        `a feed id must be ${LIMITS.feedIdLength * 2} hex characters, got "${id}"`
+      );
+    }
+    bytes = new Uint8Array(LIMITS.feedIdLength);
+    for (let i = 0; i < LIMITS.feedIdLength; i += 1) {
+      bytes[i] = Number.parseInt(text.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  if (Array.isArray(id)) {
+    if (id.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+      throw new PanguInputError("a feed id array must hold whole bytes");
+    }
+    bytes = Uint8Array.from(id);
+  } else if (id instanceof Uint8Array) {
+    bytes = id;
+  } else {
+    throw new PanguInputError("a feed id must be hex or 32 bytes");
+  }
+  if (bytes.length !== LIMITS.feedIdLength) {
+    throw new PanguInputError(
+      `a feed id must be ${LIMITS.feedIdLength} bytes, got ${bytes.length}`
+    );
+  }
+  return bytes;
+}
+function feedIdHex(id) {
+  return Array.from(feedIdBytes(id)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function saleRulesAddress(mint) {
+  return PublicKey3.findProgramAddressSync(
+    [seed(SEEDS.sale), requirePublicKey(mint, "mint").toBuffer()],
+    PANGU_PROGRAM_ID
+  )[0];
+}
+function buyerRecordAddress(mint, wallet) {
+  return PublicKey3.findProgramAddressSync(
+    [
+      seed(SEEDS.buyer),
+      requirePublicKey(mint, "mint").toBuffer(),
+      requirePublicKey(wallet, "wallet").toBuffer()
+    ],
+    PANGU_PROGRAM_ID
+  )[0];
+}
+function extraAccountListAddress(mint) {
+  return PublicKey3.findProgramAddressSync(
+    [seed(SEEDS.extraAccountMetas), requirePublicKey(mint, "mint").toBuffer()],
+    PANGU_PROGRAM_ID
+  )[0];
+}
+function attestationAddress(credential, schema, wallet) {
+  return PublicKey3.findProgramAddressSync(
+    [
+      seed(SEEDS.attestation),
+      requirePublicKey(credential, "credential").toBuffer(),
+      requirePublicKey(schema, "schema").toBuffer(),
+      requirePublicKey(wallet, "wallet").toBuffer()
+    ],
+    SAS_PROGRAM_ID
+  )[0];
+}
+function dbcBaseVaultAddress(mint, pool) {
+  return PublicKey3.findProgramAddressSync(
+    [
+      seed(SEEDS.dbcTokenVault),
+      requirePublicKey(mint, "mint").toBuffer(),
+      requirePublicKey(pool, "pool").toBuffer()
+    ],
+    DBC_PROGRAM_ID
+  )[0];
+}
+function priceFeedAddress(feedId, shard = PANGU_SHARD_ID) {
+  const id = feedIdBytes(feedId);
+  const shardId = requireWholeNumber(shard, "shard", 0, LIMITS.maxShard);
+  const seedBytes = new Uint8Array(2);
+  seedBytes[0] = shardId & 255;
+  seedBytes[1] = shardId >> 8 & 255;
+  return PublicKey3.findProgramAddressSync(
+    [seedBytes, id],
+    PYTH_PRICE_FEED_PROGRAM_ID
+  )[0];
+}
+
+// src/accounts.ts
+import { Buffer } from "buffer";
+import { getTransferHook, unpackMint } from "@solana/spl-token";
+
+// src/coder.ts
+import { BorshCoder } from "@anchor-lang/core";
+var cached = null;
+function panguCoder() {
+  if (cached === null) {
+    cached = new BorshCoder(PANGU_IDL);
+  }
+  return cached;
+}
+
+// src/accounts.ts
+var SALE_RULES = "SaleRules";
+var BUYER_RECORD = "BuyerRecord";
+var PanguLayoutError = class extends PanguInputError {
+  constructor(message) {
+    super(message);
+    this.name = "PanguLayoutError";
+  }
+};
+function asBuffer(data) {
+  return Buffer.isBuffer(data) ? data : Buffer.from(data);
+}
+function big(value) {
+  return BigInt(value.toString());
+}
+function decodeAccount(name, data) {
+  try {
+    return panguCoder().accounts.decode(name, asBuffer(data));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new PanguInputError(`these bytes are not a Pangu ${name}: ${reason}`);
+  }
+}
+function decodeSale(data) {
+  const raw = decodeAccount(SALE_RULES, data);
+  const size = panguCoder().accounts.size(SALE_RULES);
+  if (data.length !== size) {
+    throw new PanguLayoutError(
+      `a SaleRules account is ${size} bytes and these are ${data.length}, so they were written by another build of the program`
+    );
+  }
+  if (!SALE_RULES_LAYOUT_VERSIONS.has(raw.layout_version)) {
+    throw new PanguLayoutError(
+      `these are layout version ${raw.layout_version} and this package reads versions ${[...SALE_RULES_LAYOUT_VERSIONS].join(" and ")}, so they were written by another build of the program`
+    );
+  }
+  const newFields = raw.layout_version >= 2;
+  const endsAt = newFields ? Number(big(raw.ends_at)) : 0;
+  return {
+    mint: raw.mint,
+    pool: raw.pool,
+    baseVault: raw.base_vault,
+    issuer: raw.issuer,
+    cap: big(raw.cap),
+    accessMode: raw.access_mode,
+    credential: raw.credential,
+    schema: raw.schema,
+    priceAccount: raw.price_account,
+    bandBps: raw.band_bps,
+    priceFeedId: feedIdHex(raw.price_feed_id),
+    priceShard: raw.price_shard,
+    maxPriceAgeSecs: raw.max_price_age_secs,
+    maxConfBps: raw.max_conf_bps,
+    baseDecimals: raw.base_decimals,
+    quoteDecimals: raw.quote_decimals,
+    buyers: raw.buyers,
+    totalNetBought: big(raw.total_net_bought),
+    bump: raw.bump,
+    layoutVersion: raw.layout_version,
+    quoteMint: newFields ? raw.quote_mint : null,
+    endsAt: endsAt === 0 ? null : endsAt,
+    reserved: Uint8Array.from(raw.reserved),
+    hasBand: raw.band_bps > 0
+  };
+}
+function decodeBuyerRecord(data) {
+  const raw = decodeAccount(BUYER_RECORD, data);
+  return {
+    mint: raw.mint,
+    wallet: raw.wallet,
+    approved: raw.approved,
+    netBought: big(raw.net_bought),
+    bump: raw.bump
+  };
+}
+function ownedByPangu(owner, address) {
+  if (!owner.equals(PANGU_PROGRAM_ID)) {
+    throw new PanguInputError(
+      `${address.toBase58()} is owned by ${owner.toBase58()}, not by Pangu`
+    );
+  }
+}
+async function getSale(connection, mint) {
+  const address = saleRulesAddress(mint);
+  const info = await connection.getAccountInfo(address);
+  if (info === null) {
+    return null;
+  }
+  ownedByPangu(info.owner, address);
+  const sale = decodeSale(info.data);
+  if (sale.baseDecimals === 0) {
+    const decimals = await mintDecimals(connection, sale.mint);
+    if (decimals !== null) {
+      return { ...sale, baseDecimals: decimals };
+    }
+  }
+  return sale;
+}
+async function mintDecimals(connection, mint) {
+  const info = await connection.getAccountInfo(mint);
+  if (info === null || !info.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+    return null;
+  }
+  try {
+    return unpackMint(mint, info, TOKEN_2022_PROGRAM_ID).decimals;
+  } catch {
+    return null;
+  }
+}
+async function getBuyerRecord(connection, mint, wallet) {
+  const address = buyerRecordAddress(mint, wallet);
+  const info = await connection.getAccountInfo(address);
+  if (info === null) {
+    return null;
+  }
+  ownedByPangu(info.owner, address);
+  return decodeBuyerRecord(info.data);
+}
+async function listBuyerRecords(connection, mint) {
+  const coder = panguCoder().accounts;
+  const accounts = await connection.getProgramAccounts(PANGU_PROGRAM_ID, {
+    filters: [
+      { dataSize: coder.size(BUYER_RECORD) },
+      { memcmp: coder.memcmp(BUYER_RECORD, requirePublicKey(mint, "mint").toBuffer()) }
+    ]
+  });
+  return accounts.map((entry) => decodeBuyerRecord(entry.account.data));
+}
+async function listSales(connection, options = {}) {
+  const coder = panguCoder().accounts;
+  const accounts = await connection.getProgramAccounts(PANGU_PROGRAM_ID, {
+    filters: [{ dataSize: coder.size(SALE_RULES) }, { memcmp: coder.memcmp(SALE_RULES) }]
+  });
+  const sales = [];
+  for (const entry of accounts) {
+    let sale;
+    try {
+      sale = decodeSale(entry.account.data);
+    } catch (error) {
+      if (!(error instanceof PanguInputError)) {
+        throw error;
+      }
+      options.onSkipped?.(entry.pubkey, error.message);
+      continue;
+    }
+    if (!saleRulesAddress(sale.mint).equals(entry.pubkey)) {
+      options.onSkipped?.(
+        entry.pubkey,
+        `these rules name ${sale.mint.toBase58()}, whose rules live at another address`
+      );
+      continue;
+    }
+    sales.push(sale);
+  }
+  return sales;
+}
+async function isSaleRunning(connection, mint) {
+  const info = await connection.getAccountInfo(requirePublicKey(mint, "mint"));
+  return mintRunsPangu(mint, info);
+}
+function mintRunsPangu(mint, info) {
+  if (info === null || !info.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+    return false;
+  }
+  const state = unpackMint(mint, info, TOKEN_2022_PROGRAM_ID);
+  const hook = getTransferHook(state);
+  if (hook === null) {
+    return false;
+  }
+  return hook.programId.equals(PANGU_PROGRAM_ID);
+}
+
+// src/band.ts
+var DOLLAR_SCALE = 10n ** 18n;
+function pow10(exponent) {
+  return 10n ** BigInt(exponent);
+}
+var MIN_EXPONENT = -18;
+var MAX_EXPONENT = 0;
+function stockPriceDollars(price, exponent) {
+  const raw = requireBigint(price, "price");
+  if (raw <= 0n) {
+    throw new PanguInputError("a price of zero or less is not a price");
+  }
+  const power = requireWholeNumber(exponent, "exponent", MIN_EXPONENT, MAX_EXPONENT);
+  const shift = 18 + power;
+  return shift >= 0 ? raw * pow10(shift) : raw / pow10(-shift);
+}
+function confidenceBps(price, conf) {
+  const raw = requireBigint(price, "price");
+  const doubt = requireBigint(conf, "conf");
+  if (raw <= 0n) {
+    throw new PanguInputError("a price of zero or less has no confidence ratio");
+  }
+  if (doubt < 0n) {
+    throw new PanguInputError("a confidence interval cannot be negative");
+  }
+  return (doubt * 10000n + raw - 1n) / raw;
+}
+function curvePriceDollars(sqrtPrice, baseDecimals, quoteDecimals) {
+  const root = requireBigint(sqrtPrice, "sqrtPrice");
+  if (root < 0n) {
+    throw new PanguInputError("sqrtPrice cannot be negative");
+  }
+  const base = requireWholeNumber(baseDecimals, "baseDecimals", 0, LIMITS.maxDecimals);
+  const quote = requireWholeNumber(
+    quoteDecimals,
+    "quoteDecimals",
+    0,
+    LIMITS.maxDecimals
+  );
+  const numerator = root * root * pow10(18 + base);
+  const denominator = (1n << 128n) * pow10(quote);
+  const whole = numerator / denominator;
+  return numerator % denominator === 0n ? whole : whole + 1n;
+}
+function priceCeiling(sale, stockPrice) {
+  const bandBps = requireWholeNumber(
+    sale?.bandBps,
+    "sale.bandBps",
+    1,
+    LIMITS.maxBandBps
+  );
+  const price = requireBigint(stockPrice, "stockPrice");
+  if (price <= 0n) {
+    throw new PanguInputError(
+      "a stock price of zero or less is never a ceiling, the program refuses it"
+    );
+  }
+  return price * BigInt(1e4 + bandBps) / 10000n;
+}
+function dollars(scaled) {
+  return Number(scaled) / Number(DOLLAR_SCALE);
+}
+
+// src/feed.ts
+import {
+  SYSVAR_CLOCK_PUBKEY,
+  PublicKey as Web3PublicKey
+} from "@solana/web3.js";
+
+// src/errors.ts
+var idlErrors = PANGU_IDL.errors ?? [];
+var PANGU_ERRORS = Object.freeze(
+  idlErrors.map((error) => ({
+    code: error.code,
+    name: error.name,
+    message: error.msg ?? error.name
+  }))
+);
+var byCode = new Map(PANGU_ERRORS.map((error) => [error.code, error]));
+var byName = new Map(PANGU_ERRORS.map((error) => [error.name, error]));
+var PANGU = PANGU_PROGRAM_ID.toBase58();
+var INVOKE = /^Program (\S+) invoke \[\d+\]$/;
+var SUCCESS = /^Program (\S+) success$/;
+var FAILED = /^Program (\S+) failed: (.*)$/;
+var ERROR_NAME = /Error Code: ([A-Za-z0-9_]+)/;
+var ERROR_NUMBER = /Error Number: (\d+)/;
+var CUSTOM = /custom program error: (0x[0-9a-fA-F]+|\d+)/;
+function toCode(text) {
+  return text.startsWith("0x") || text.startsWith("0X") ? Number.parseInt(text.slice(2), 16) : Number.parseInt(text, 10);
+}
+function refusalIn(line) {
+  const named = ERROR_NAME.exec(line);
+  const byThatName = named === null ? void 0 : byName.get(named[1] ?? "");
+  if (byThatName !== void 0) {
+    return byThatName;
+  }
+  const numbered = ERROR_NUMBER.exec(line);
+  const byThatNumber = numbered === null ? void 0 : byCode.get(toCode(numbered[1] ?? ""));
+  if (byThatNumber !== void 0) {
+    return byThatNumber;
+  }
+  const custom = CUSTOM.exec(line);
+  return custom === null ? void 0 : byCode.get(toCode(custom[1] ?? ""));
+}
+function panguErrorFromLogs(logs) {
+  if (!Array.isArray(logs)) {
+    return null;
+  }
+  const stack = [];
+  let namedProgram = false;
+  let failedProgram = null;
+  let failedReason = "";
+  let panguSaid;
+  for (const entry of logs) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const line = entry.trim();
+    const invoke = INVOKE.exec(line);
+    if (invoke !== null) {
+      namedProgram = true;
+      stack.push(invoke[1] ?? "");
+      continue;
+    }
+    const succeeded = SUCCESS.exec(line);
+    if (succeeded !== null) {
+      namedProgram = true;
+      stack.pop();
+      if (succeeded[1] === PANGU) {
+        panguSaid = void 0;
+      }
+      continue;
+    }
+    const failed = FAILED.exec(line);
+    if (failed !== null) {
+      namedProgram = true;
+      if (failedProgram === null) {
+        failedProgram = failed[1] ?? "";
+        failedReason = failed[2] ?? "";
+      }
+      stack.pop();
+      continue;
+    }
+    const current = stack[stack.length - 1];
+    if (current === PANGU || !namedProgram) {
+      panguSaid = refusalIn(line) ?? panguSaid;
+    }
+  }
+  if (!namedProgram) {
+    return panguSaid ?? null;
+  }
+  if (failedProgram === null) {
+    return stack.includes(PANGU) ? panguSaid ?? null : null;
+  }
+  if (failedProgram !== PANGU) {
+    return null;
+  }
+  const custom = CUSTOM.exec(failedReason);
+  const byFailedCode = custom === null ? void 0 : byCode.get(toCode(custom[1] ?? ""));
+  return byFailedCode ?? panguSaid ?? null;
+}
+var EXPLANATIONS = {
+  NotTransferring: "This token only moves through a real transfer, and this was not one.",
+  ReceivingAccountOwnerCanChange: "The account you are buying into could be handed to someone else later, so the sale will not send tokens to it. Use the wallet's ordinary holding account for this token, the one your wallet app makes by itself.",
+  WrongMint: "That account belongs to a different token than this sale.",
+  WrongBuyerRecord: "The buyer record sent with this transfer belongs to another wallet.",
+  BuyerRecordMissing: "This wallet has no record in the sale yet. Open one first, then buy.",
+  NotApproved: "The issuer has not approved this wallet to buy in this sale.",
+  CredentialInvalid: "This wallet does not carry a valid approval from the verifier this sale trusts.",
+  CredentialExpired: "The verifier's approval for this wallet has run out.",
+  CredentialSignerNotAuthorized: "The key that signed this wallet's approval is no longer allowed to sign for that verifier.",
+  OverCap: "This purchase would take your wallet past the limit for this sale.",
+  WalletToWalletDuringSale: "This token cannot be sent from one wallet to another while the sale is running.",
+  PriceStale: "The stock price this sale checks against is too old to use. Refresh it and try again. Outside market hours there is no fresh price to get, so the sale stays shut until the market opens.",
+  PriceOutsideBand: "This purchase would push the price too far above the real stock price.",
+  WrongPriceAccount: "The price account sent with this transfer is not the one this sale names.",
+  PriceNotFullyVerified: "The price update has not been signed by two thirds of Pyth's guardians, and this sale will not price against a half signed number.",
+  PriceTooUncertain: "Pyth's own publishers disagree about this stock's price by more than this sale allows, so there is no ceiling worth measuring against right now.",
+  NotPoolCreator: "Only the wallet that created the pool can open its sale.",
+  NotAHookPool: "That account is not a Meteora bonding curve pool of the kind Pangu works with.",
+  HookProgramMismatch: "This token does not name Pangu as its transfer hook, so Pangu cannot hold its rules.",
+  MintAuthorityStillSet: "This token can still be minted, so Pangu will not open a sale on it. Launch it with the minting power revoked.",
+  WrongLaunchTemplate: "That launch template is not the one this pool was opened on.",
+  FeesNotInQuoteToken: "This sale's template collects fees in the sale token, and Pangu only accepts templates that collect them in the paying token.",
+  ZeroCap: "A sale needs a per-wallet limit above zero.",
+  InvalidAccessMode: "That access mode does not exist, or the settings do not match the mode chosen.",
+  InvalidBand: "The price band settings are incomplete or out of range.",
+  SaleStillRunning: "The sale is still running and this record still counts tokens, so it cannot be closed yet. Sell them back or wait for the sale to finish.",
+  NotIssuer: "Only the issuer of this sale can do that.",
+  MathOverflow: "The sale's counters cannot go any higher.",
+  WrongLayoutVersion: "These sale rules were written by an older build of the program, so this build will not act on them.",
+  BandNeedsDollarQuote: "A price ceiling needs buyers to pay in a dollar token the program recognises (USDC, or on devnet the demo dollar). Turn the ceiling off, or pick a dollar paying token.",
+  IssuerControlsPayingToken: "You hold the freeze authority of the token buyers pay in, which would let you stop sellers being paid. Pick a paying token whose freeze authority is not yours.",
+  CapCoversWholeSale: "The per-wallet limit is as large as everything the curve sells, so one wallet could buy the whole sale. Set a limit below the curve's supply.",
+  EndInThePast: "The end of the offering period has to be later than now. Pick a future time, or leave it at zero for no end."
+};
+function explainPanguError(name) {
+  const explanation = EXPLANATIONS[name];
+  return explanation ?? "The transaction was refused, and the reason did not come from this sale's rules.";
+}
+
+// src/feed.ts
+var DISCRIMINATOR = [34, 241, 35, 99, 157, 126, 244, 205];
+var PARTIAL_TAG = 0;
+var FULL_TAG = 1;
+var WRITE_AUTHORITY_OFFSET = 8;
+var VERIFICATION_OFFSET = 40;
+var PUBLISH_FUTURE_TOLERANCE_SECS = 60;
+var CLOCK_UNIX_TIMESTAMP_OFFSET = 32;
+function slice(data, start, length) {
+  const end = start + length;
+  if (start < 0 || length < 0 || end > data.length) {
+    throw new PanguInputError(
+      "these bytes are not a Pyth price update: they end before the layout does"
+    );
+  }
+  return data.subarray(start, end);
+}
+function hex(data) {
+  return Array.from(data, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function unsigned(data, offset, length) {
+  const bytes = slice(data, offset, length);
+  let value = 0n;
+  for (let index = length - 1; index >= 0; index -= 1) {
+    value = value << 8n | BigInt(bytes[index] ?? 0);
+  }
+  return value;
+}
+function signed(data, offset, length) {
+  const value = unsigned(data, offset, length);
+  const bits = BigInt(length * 8);
+  return value >= 1n << bits - 1n ? value - (1n << bits) : value;
+}
+function decodePriceUpdate(data) {
+  const discriminator = slice(data, 0, DISCRIMINATOR.length);
+  if (DISCRIMINATOR.some((byte, index) => discriminator[index] !== byte)) {
+    throw new PanguInputError("these bytes are not a Pyth price feed account");
+  }
+  const tag = slice(data, VERIFICATION_OFFSET, 1)[0];
+  if (tag !== FULL_TAG && tag !== PARTIAL_TAG) {
+    throw new PanguInputError(
+      `${String(tag)} is not a verification level Pyth writes, so these bytes cannot be read`
+    );
+  }
+  const message = VERIFICATION_OFFSET + (tag === FULL_TAG ? 1 : 2);
+  return {
+    writeAuthority: new Web3PublicKey(slice(data, WRITE_AUTHORITY_OFFSET, 32)),
+    fullyVerified: tag === FULL_TAG,
+    feedId: hex(slice(data, message, 32)),
+    price: signed(data, message + 32, 8),
+    conf: unsigned(data, message + 40, 8),
+    exponent: Number(signed(data, message + 48, 4)),
+    publishTime: Number(signed(data, message + 52, 8)),
+    prevPublishTime: Number(signed(data, message + 60, 8)),
+    postedSlot: unsigned(data, message + 84, 8)
+  };
+}
+function unusable(address, error, partial = {}) {
+  return {
+    address,
+    price: 0n,
+    priceDollars: 0,
+    publishTime: 0,
+    ageSecs: 0,
+    confBps: 0,
+    fullyVerified: false,
+    usable: false,
+    error,
+    reason: explainPanguError(error),
+    ...partial
+  };
+}
+async function readPrice(connection, sale) {
+  if (sale === null || sale === void 0 || !sale.hasBand) {
+    throw new PanguInputError(
+      "this sale has no price band, so there is no price account to read"
+    );
+  }
+  const address = sale.priceAccount;
+  if (!priceFeedAddress(sale.priceFeedId, sale.priceShard).equals(address)) {
+    return unusable(address, "WrongPriceAccount");
+  }
+  const [info, clock] = await connection.getMultipleAccountsInfo([
+    address,
+    SYSVAR_CLOCK_PUBKEY
+  ]);
+  if (info === null || info === void 0) {
+    return unusable(address, "PriceStale");
+  }
+  if (!info.owner.equals(PYTH_RECEIVER_PROGRAM_ID)) {
+    return unusable(address, "WrongPriceAccount");
+  }
+  let update;
+  try {
+    update = decodePriceUpdate(info.data);
+  } catch {
+    return unusable(address, "WrongPriceAccount");
+  }
+  if (!update.fullyVerified) {
+    return unusable(address, "PriceNotFullyVerified", {
+      publishTime: update.publishTime
+    });
+  }
+  if (update.feedId !== sale.priceFeedId) {
+    return unusable(address, "WrongPriceAccount");
+  }
+  if (update.price <= 0n || update.exponent > 0 || update.exponent < -LIMITS.maxDecimals) {
+    return unusable(
+      address,
+      update.price <= 0n ? "PriceStale" : "WrongPriceAccount",
+      { fullyVerified: true, publishTime: update.publishTime }
+    );
+  }
+  const now = clock !== null && clock !== void 0 && clock.data.length >= CLOCK_UNIX_TIMESTAMP_OFFSET + 8 ? Number(clock.data.readBigInt64LE(CLOCK_UNIX_TIMESTAMP_OFFSET)) : Math.floor(Date.now() / 1e3);
+  const price = stockPriceDollars(update.price, update.exponent);
+  const confBps = Number(confidenceBps(update.price, update.conf));
+  const reading = {
+    address,
+    price,
+    priceDollars: dollars(price),
+    publishTime: update.publishTime,
+    ageSecs: now - update.publishTime,
+    confBps,
+    fullyVerified: true,
+    usable: true,
+    error: null,
+    reason: null
+  };
+  const refuse = (error) => ({
+    ...reading,
+    usable: false,
+    error,
+    reason: explainPanguError(error)
+  });
+  if (reading.ageSecs > sale.maxPriceAgeSecs || update.publishTime > now + PUBLISH_FUTURE_TOLERANCE_SECS || price <= 0n) {
+    return refuse("PriceStale");
+  }
+  if (confBps > sale.maxConfBps) {
+    return refuse("PriceTooUncertain");
+  }
+  return reading;
+}
+
+// src/standing.ts
+var SHARE_SCALE = 1000000000n;
+function share(part, whole) {
+  if (whole <= 0n) {
+    return 0;
+  }
+  return Number(part * SHARE_SCALE / whole) / Number(SHARE_SCALE);
+}
+function saleStanding(sale, records, now = Math.floor(Date.now() / 1e3)) {
+  if (!Array.isArray(records)) {
+    throw new PanguInputError("records must be an array of buyer records");
+  }
+  let total = 0n;
+  let buyers = 0;
+  let largestWallet = null;
+  let largestNetBought = 0n;
+  for (const record of records) {
+    if (!record.mint.equals(sale.mint)) {
+      throw new PanguInputError(
+        `a record for ${record.mint.toBase58()} was passed with the sale of ${sale.mint.toBase58()}`
+      );
+    }
+    total += record.netBought;
+    if (record.netBought > 0n) {
+      buyers += 1;
+    }
+    if (record.netBought > largestNetBought) {
+      largestNetBought = record.netBought;
+      largestWallet = record.wallet;
+    }
+  }
+  return {
+    buyers,
+    totalNetBought: total,
+    largestWallet,
+    largestNetBought,
+    largestShare: share(largestNetBought, total),
+    capShare: share(sale.cap, total),
+    offeringOver: sale.endsAt !== null && now >= sale.endsAt
+  };
+}
+
+// src/directory.ts
+import { SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2 } from "@solana/web3.js";
+import {
+  ExtensionType,
+  getExtensionData,
+  getMetadataPointerState,
+  unpackMint as unpackMint2
+} from "@solana/spl-token";
+var METADATA_NAME_OFFSET = 64;
+function readMint(mint, info) {
+  if (info === null || !info.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+    return null;
+  }
+  try {
+    return unpackMint2(mint, info, TOKEN_2022_PROGRAM_ID);
+  } catch {
+    return null;
+  }
+}
+function decodeMetadata(mint, data) {
+  if (data.length < METADATA_NAME_OFFSET) {
+    return null;
+  }
+  const named = data.subarray(32, METADATA_NAME_OFFSET);
+  if (!mint.toBytes().every((byte, index) => byte === named[index])) {
+    return null;
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const utf8 = new TextDecoder("utf-8", { fatal: true });
+  const fields = [];
+  let offset = METADATA_NAME_OFFSET;
+  for (let field = 0; field < 3; field += 1) {
+    if (offset + 4 > data.length) {
+      return null;
+    }
+    const length = view.getUint32(offset, true);
+    offset += 4;
+    if (length > data.length - offset) {
+      return null;
+    }
+    try {
+      fields.push(utf8.decode(data.subarray(offset, offset + length)));
+    } catch {
+      return null;
+    }
+    offset += length;
+  }
+  const [name, symbol, uri] = fields;
+  return { name, symbol, uri };
+}
+function tokenInfoFromMint(mint, info) {
+  const state = readMint(mint, info);
+  if (state === null) {
+    return null;
+  }
+  const pointer = getMetadataPointerState(state);
+  if (pointer?.metadataAddress?.equals(mint) !== true) {
+    return null;
+  }
+  const data = getExtensionData(ExtensionType.TokenMetadata, state.tlvData);
+  return data === null ? null : decodeMetadata(mint, data);
+}
+async function saleTokenInfo(connection, mint) {
+  const key = requirePublicKey(mint, "mint");
+  return tokenInfoFromMint(key, await connection.getAccountInfo(key));
+}
+var ACCOUNTS_PER_CALL = 100;
+var HOOK_POOL_DISCRIMINATOR = Uint8Array.from([237, 219, 184, 23, 42, 189, 169, 35]);
+var HOOK_POOL_SIZE = 424;
+var POOL_BASE_MINT_OFFSET = 136;
+var POOL_MIGRATION_PROGRESS_OFFSET = 308;
+var CLOCK_UNIX_TIMESTAMP_OFFSET2 = 32;
+async function readAccounts(connection, addresses) {
+  const found = [];
+  for (let start = 0; start < addresses.length; start += ACCOUNTS_PER_CALL) {
+    const chunk = addresses.slice(start, start + ACCOUNTS_PER_CALL);
+    const infos = await connection.getMultipleAccountsInfo(chunk);
+    if (infos.length !== chunk.length) {
+      throw new Error(
+        `asked the node for ${chunk.length} accounts and it answered with ${infos.length}`
+      );
+    }
+    found.push(...infos);
+  }
+  return found;
+}
+function sameBytes(left, right) {
+  return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function poolGraduated(mint, info) {
+  if (info === null || !info.owner.equals(DBC_PROGRAM_ID) || info.data.length !== HOOK_POOL_SIZE || !sameBytes(info.data.subarray(0, 8), HOOK_POOL_DISCRIMINATOR) || !sameBytes(
+    info.data.subarray(POOL_BASE_MINT_OFFSET, POOL_BASE_MINT_OFFSET + 32),
+    mint.toBytes()
+  )) {
+    return null;
+  }
+  return info.data[POOL_MIGRATION_PROGRESS_OFFSET] !== 0;
+}
+function chainNow(info) {
+  if (info === null || info.data.length < CLOCK_UNIX_TIMESTAMP_OFFSET2 + 8) {
+    return Math.floor(Date.now() / 1e3);
+  }
+  const view = new DataView(info.data.buffer, info.data.byteOffset, info.data.byteLength);
+  return Number(view.getBigInt64(CLOCK_UNIX_TIMESTAMP_OFFSET2, true));
+}
+function isRunning(mint, info) {
+  try {
+    return mintRunsPangu(mint, info);
+  } catch {
+    return false;
+  }
+}
+async function saleDirectory(connection, options = {}) {
+  const sales = await listSales(connection, options);
+  const addresses = [SYSVAR_CLOCK_PUBKEY2, ...sales.flatMap((sale) => [sale.mint, sale.pool])];
+  const infos = await readAccounts(connection, addresses);
+  const now = chainNow(infos[0] ?? null);
+  return sales.map((listed, index) => {
+    const mintInfo = infos[1 + index * 2] ?? null;
+    const poolInfo = infos[2 + index * 2] ?? null;
+    const decimals = listed.baseDecimals === 0 ? readMint(listed.mint, mintInfo)?.decimals : void 0;
+    const sale = decimals === void 0 ? listed : { ...listed, baseDecimals: decimals };
+    const token = tokenInfoFromMint(sale.mint, mintInfo);
+    return {
+      mint: sale.mint,
+      pool: sale.pool,
+      name: token?.name ?? null,
+      symbol: token?.symbol ?? null,
+      running: isRunning(sale.mint, mintInfo),
+      graduated: poolGraduated(sale.mint, poolInfo),
+      offeringOver: saleStanding(sale, [], now).offeringOver,
+      hasBand: sale.hasBand,
+      accessMode: sale.accessMode,
+      quoteMint: sale.quoteMint,
+      endsAt: sale.endsAt,
+      buyers: sale.buyers,
+      issuer: sale.issuer,
+      sale
+    };
+  });
+}
+
+// src/instructions.ts
+import { BN } from "@anchor-lang/core";
+import {
+  PublicKey as PublicKey4,
+  SystemProgram,
+  TransactionInstruction
+} from "@solana/web3.js";
+var ZERO_FEED = Array(LIMITS.feedIdLength).fill(0);
+var NO_BAND = {
+  band_bps: 0,
+  price_account: PublicKey4.default,
+  price_feed_id: ZERO_FEED,
+  price_shard: 0,
+  max_price_age_secs: 0,
+  max_conf_bps: 0
+};
+function meta(pubkey, isSigner, isWritable) {
+  return { pubkey, isSigner, isWritable };
+}
+function absentAccount() {
+  return meta(PANGU_PROGRAM_ID, false, false);
+}
+function build(name, keys, args) {
+  return new TransactionInstruction({
+    programId: PANGU_PROGRAM_ID,
+    keys,
+    data: panguCoder().instruction.encode(name, args)
+  });
+}
+function bandFields(band, field) {
+  const bps = requireWholeNumber(
+    band.bps,
+    `${field}.bps`,
+    LIMITS.minBandBps,
+    LIMITS.maxBandBps
+  );
+  const priceFeedId = feedIdBytes(band.priceFeedId);
+  if (priceFeedId.every((byte) => byte === 0)) {
+    throw new PanguInputError(`${field}.priceFeedId of all zeros is not a feed`);
+  }
+  const shard = band.shard === void 0 ? PANGU_SHARD_ID : requireWholeNumber(band.shard, `${field}.shard`, 0, LIMITS.maxShard);
+  const maxPriceAgeSecs = requireWholeNumber(
+    band.maxPriceAgeSecs,
+    `${field}.maxPriceAgeSecs`,
+    LIMITS.minPriceAgeSecs,
+    LIMITS.maxPriceAgeSecs
+  );
+  const maxConfBps = requireWholeNumber(
+    band.maxConfBps,
+    `${field}.maxConfBps`,
+    LIMITS.minConfBps,
+    LIMITS.maxConfBps
+  );
+  return {
+    band_bps: bps,
+    // Derived here rather than asked for: the price account is the one program
+    // address this shard and this feed id can produce under Pyth's price feed
+    // program, and create_sale derives the same one and refuses anything else.
+    price_account: priceFeedAddress(priceFeedId, shard),
+    price_feed_id: Array.from(priceFeedId),
+    price_shard: shard,
+    max_price_age_secs: maxPriceAgeSecs,
+    max_conf_bps: maxConfBps
+  };
+}
+function createSaleInstruction(input) {
+  const issuer = requireRealPublicKey(input.issuer, "issuer");
+  const pool = requireRealPublicKey(input.pool, "pool");
+  const mint = requireRealPublicKey(input.mint, "mint");
+  const cap = requireBigint(input.cap, "cap");
+  if (cap <= 0n) {
+    throw new PanguInputError("cap must be above zero, the program refuses a zero cap");
+  }
+  if (cap > LIMITS.maxCap) {
+    throw new PanguInputError("cap must fit in 64 bits");
+  }
+  const accessMode = requireWholeNumber(input.accessMode, "accessMode", 0, 2);
+  const wantsCredential = accessMode === ACCESS_MODE.verifierCredential;
+  let credential = PublicKey4.default;
+  let schema = PublicKey4.default;
+  if (wantsCredential) {
+    if (input.credential === void 0 || input.schema === void 0) {
+      throw new PanguInputError(
+        "access mode 2 needs both a credential and a schema, the program has nothing to check against without them"
+      );
+    }
+    credential = requireRealPublicKey(input.credential, "credential");
+    schema = requireRealPublicKey(input.schema, "schema");
+  } else {
+    const reason = "belongs to access mode 2, and the program refuses a sale that names it in any other mode";
+    requireAbsent(input.credential, "credential", reason);
+    requireAbsent(input.schema, "schema", reason);
+  }
+  const dbcConfig = requireRealPublicKey(input.dbcConfig, "dbcConfig");
+  const quoteMint = requireRealPublicKey(input.quoteMint, "quoteMint");
+  const band = input.band !== void 0 && input.band !== null ? bandFields(input.band, "band") : NO_BAND;
+  const endsAt = input.endsAt === void 0 ? 0 : requireWholeNumber(input.endsAt, "endsAt", 0, Number.MAX_SAFE_INTEGER);
+  const keys = [
+    meta(issuer, true, true),
+    meta(pool, false, false),
+    meta(mint, false, false),
+    wantsCredential ? meta(credential, false, false) : absentAccount(),
+    wantsCredential ? meta(schema, false, false) : absentAccount(),
+    meta(dbcConfig, false, false),
+    meta(quoteMint, false, false),
+    meta(saleRulesAddress(mint), false, true),
+    meta(extraAccountListAddress(mint), false, true),
+    meta(SystemProgram.programId, false, false)
+  ];
+  return build("create_sale", keys, {
+    cap: new BN(cap.toString()),
+    access_mode: accessMode,
+    credential,
+    schema,
+    band,
+    ends_at: new BN(endsAt)
+  });
+}
+function openBuyerRecordInstruction(input) {
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  const mint = requireRealPublicKey(input.mint, "mint");
+  return build(
+    "open_buyer_record",
+    [
+      meta(wallet, true, true),
+      meta(mint, false, false),
+      meta(saleRulesAddress(mint), false, false),
+      meta(buyerRecordAddress(mint, wallet), false, true),
+      meta(SystemProgram.programId, false, false)
+    ],
+    {}
+  );
+}
+function approveBuyerInstruction(input) {
+  const issuer = requireRealPublicKey(input.issuer, "issuer");
+  const mint = requireRealPublicKey(input.mint, "mint");
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  return build(
+    "approve_buyer",
+    [
+      meta(issuer, true, true),
+      meta(mint, false, false),
+      meta(saleRulesAddress(mint), false, false),
+      meta(buyerRecordAddress(mint, wallet), false, true),
+      meta(SystemProgram.programId, false, false)
+    ],
+    { wallet }
+  );
+}
+function revokeBuyerInstruction(input) {
+  const issuer = requireRealPublicKey(input.issuer, "issuer");
+  const mint = requireRealPublicKey(input.mint, "mint");
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  return build(
+    "revoke_buyer",
+    [
+      meta(issuer, true, false),
+      meta(mint, false, false),
+      meta(saleRulesAddress(mint), false, false),
+      meta(buyerRecordAddress(mint, wallet), false, true)
+    ],
+    { wallet }
+  );
+}
+function closeBuyerRecordInstruction(input) {
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  const mint = requireRealPublicKey(input.mint, "mint");
+  return build(
+    "close_buyer_record",
+    [
+      meta(wallet, true, true),
+      meta(mint, false, false),
+      meta(buyerRecordAddress(mint, wallet), false, true),
+      meta(saleRulesAddress(mint), false, false)
+    ],
+    {}
+  );
+}
+
+// src/sas.ts
+import { Buffer as Buffer2 } from "buffer";
+import {
+  PublicKey as PublicKey5,
+  SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY3,
+  SystemProgram as SystemProgram2,
+  TransactionInstruction as TransactionInstruction2
+} from "@solana/web3.js";
+var CREATE_CREDENTIAL = 0;
+var CREATE_SCHEMA = 1;
+var CREATE_ATTESTATION = 6;
+var CLOSE_ATTESTATION = 7;
+var FIRST_SCHEMA_VERSION = 1;
+var MAX_NAME_BYTES = 32;
+var MAX_AUTHORIZED_SIGNERS = 64;
+var LAYOUT_U8 = 0;
+var VERIFIED_SCHEMA = {
+  layout: [LAYOUT_U8],
+  fieldNames: ["verified"],
+  attestationData: [1]
+};
+function meta2(pubkey, isSigner, isWritable) {
+  return { pubkey, isSigner, isWritable };
+}
+function u32(value) {
+  const bytes = Buffer2.alloc(4);
+  bytes.writeUInt32LE(value);
+  return bytes;
+}
+function lengthPrefixed(bytes) {
+  return Buffer2.concat([u32(bytes.length), Buffer2.from(bytes)]);
+}
+function requireName(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new PanguInputError(`${field} must be a name that is not empty`);
+  }
+  const bytes = Buffer2.from(value, "utf8");
+  if (bytes.length > MAX_NAME_BYTES) {
+    throw new PanguInputError(
+      `${field} must be at most ${MAX_NAME_BYTES} bytes, because it is part of an address, got ${bytes.length}`
+    );
+  }
+  return bytes;
+}
+function requireText(value, field) {
+  if (typeof value !== "string") {
+    throw new PanguInputError(`${field} must be text`);
+  }
+  return Buffer2.from(value, "utf8");
+}
+function requireBytes(value, field) {
+  if (value instanceof Uint8Array) {
+    return Buffer2.from(value);
+  }
+  if (Array.isArray(value) && value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+    return Buffer2.from(value);
+  }
+  throw new PanguInputError(`${field} must be bytes`);
+}
+function credentialAddress(authority, name) {
+  return PublicKey5.findProgramAddressSync(
+    [
+      Buffer2.from(SEEDS.credential),
+      requireRealPublicKey(authority, "authority").toBuffer(),
+      requireName(name, "name")
+    ],
+    SAS_PROGRAM_ID
+  )[0];
+}
+function schemaAddress(credential, name) {
+  return PublicKey5.findProgramAddressSync(
+    [
+      Buffer2.from(SEEDS.schema),
+      requireRealPublicKey(credential, "credential").toBuffer(),
+      requireName(name, "name"),
+      Buffer2.from([FIRST_SCHEMA_VERSION])
+    ],
+    SAS_PROGRAM_ID
+  )[0];
+}
+function createCredentialInstruction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const authority = requireRealPublicKey(input.authority, "authority");
+  const name = requireName(input.name, "name");
+  if (!Array.isArray(input.signers) || input.signers.length === 0) {
+    throw new PanguInputError("signers must hold at least one key, or nobody can attest");
+  }
+  if (input.signers.length > MAX_AUTHORIZED_SIGNERS) {
+    throw new PanguInputError(
+      `signers must hold at most ${MAX_AUTHORIZED_SIGNERS} keys, Pangu refuses every buy against a longer list, got ${input.signers.length}`
+    );
+  }
+  const signers = input.signers.map(
+    (signer, index) => requireRealPublicKey(signer, `signers[${index}]`)
+  );
+  if (new Set(signers.map((signer) => signer.toBase58())).size !== signers.length) {
+    throw new PanguInputError("signers must not repeat a key");
+  }
+  return new TransactionInstruction2({
+    programId: SAS_PROGRAM_ID,
+    keys: [
+      meta2(payer, true, true),
+      meta2(credentialAddress(authority, input.name), false, true),
+      meta2(authority, true, false),
+      meta2(SystemProgram2.programId, false, false)
+    ],
+    data: Buffer2.concat([
+      Buffer2.from([CREATE_CREDENTIAL]),
+      lengthPrefixed(name),
+      u32(signers.length),
+      ...signers.map((signer) => signer.toBuffer())
+    ])
+  });
+}
+function createSchemaInstruction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const authority = requireRealPublicKey(input.authority, "authority");
+  const credential = requireRealPublicKey(input.credential, "credential");
+  const name = requireName(input.name, "name");
+  const description = requireText(input.description, "description");
+  const layout = requireBytes(input.layout ?? VERIFIED_SCHEMA.layout, "layout");
+  if (layout.length === 0) {
+    throw new PanguInputError("layout must name at least one field");
+  }
+  const fieldNames = input.fieldNames ?? VERIFIED_SCHEMA.fieldNames;
+  if (!Array.isArray(fieldNames) || fieldNames.length !== layout.length) {
+    throw new PanguInputError(
+      `fieldNames must name every field in the layout, one each: the layout has ${layout.length}`
+    );
+  }
+  const fields = fieldNames.map((field, index) => requireText(field, `fieldNames[${index}]`));
+  return new TransactionInstruction2({
+    programId: SAS_PROGRAM_ID,
+    keys: [
+      meta2(payer, true, true),
+      meta2(authority, true, false),
+      meta2(credential, false, false),
+      meta2(schemaAddress(credential, input.name), false, true),
+      meta2(SystemProgram2.programId, false, false)
+    ],
+    data: Buffer2.concat([
+      Buffer2.from([CREATE_SCHEMA]),
+      lengthPrefixed(name),
+      lengthPrefixed(description),
+      lengthPrefixed(layout),
+      u32(fields.length),
+      ...fields.map((field) => lengthPrefixed(field))
+    ])
+  });
+}
+function createAttestationInstruction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const authorizedSigner = requireRealPublicKey(input.authorizedSigner, "authorizedSigner");
+  const credential = requireRealPublicKey(input.credential, "credential");
+  const schema = requireRealPublicKey(input.schema, "schema");
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  const expiry = requireWholeNumber(input.expiry, "expiry", 0, Number.MAX_SAFE_INTEGER);
+  const data = requireBytes(input.data ?? VERIFIED_SCHEMA.attestationData, "data");
+  const expiryBytes = Buffer2.alloc(8);
+  expiryBytes.writeBigInt64LE(BigInt(expiry));
+  return new TransactionInstruction2({
+    programId: SAS_PROGRAM_ID,
+    keys: [
+      meta2(payer, true, true),
+      meta2(authorizedSigner, true, false),
+      meta2(credential, false, false),
+      meta2(schema, false, false),
+      meta2(attestationAddress(credential, schema, wallet), false, true),
+      meta2(SystemProgram2.programId, false, false)
+    ],
+    data: Buffer2.concat([
+      Buffer2.from([CREATE_ATTESTATION]),
+      wallet.toBuffer(),
+      lengthPrefixed(data),
+      expiryBytes
+    ])
+  });
+}
+function eventAuthorityAddress() {
+  return PublicKey5.findProgramAddressSync([Buffer2.from("__event_authority")], SAS_PROGRAM_ID)[0];
+}
+function closeAttestationInstruction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const authorizedSigner = requireRealPublicKey(input.authorizedSigner, "authorizedSigner");
+  const credential = requireRealPublicKey(input.credential, "credential");
+  const schema = requireRealPublicKey(input.schema, "schema");
+  const wallet = requireRealPublicKey(input.wallet, "wallet");
+  return new TransactionInstruction2({
+    programId: SAS_PROGRAM_ID,
+    keys: [
+      meta2(payer, true, true),
+      meta2(authorizedSigner, true, false),
+      meta2(credential, false, false),
+      meta2(attestationAddress(credential, schema, wallet), false, true),
+      meta2(eventAuthorityAddress(), false, false),
+      meta2(SystemProgram2.programId, false, false),
+      meta2(SAS_PROGRAM_ID, false, false)
+    ],
+    data: Buffer2.from([CLOSE_ATTESTATION])
+  });
+}
+var ACCOUNT_ATTESTATION = 2;
+var ATTESTATION_NONCE_OFFSET = 1;
+var ATTESTATION_CREDENTIAL_OFFSET = 33;
+var ATTESTATION_SCHEMA_OFFSET = 65;
+var ATTESTATION_DATA_LEN_OFFSET = 97;
+var ATTESTATION_DATA_OFFSET = 101;
+var PUBKEY_BYTES = 32;
+var ATTESTATION_DISCRIMINATOR_BASE58 = "3";
+var CLOCK_UNIX_TIMESTAMP_OFFSET3 = 32;
+var CREATED_SIGNATURES = 20;
+var CREATED_TRANSACTIONS = 5;
+function readKey(data, offset) {
+  return offset >= 0 && offset + PUBKEY_BYTES <= data.length ? new PublicKey5(data.subarray(offset, offset + PUBKEY_BYTES)) : null;
+}
+function decodeAttestation(owner, data) {
+  if (!owner.equals(SAS_PROGRAM_ID) || data.length < ATTESTATION_DATA_OFFSET) {
+    return null;
+  }
+  if (data[0] !== ACCOUNT_ATTESTATION) {
+    return null;
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.length);
+  const signerOffset = ATTESTATION_DATA_OFFSET + view.getUint32(ATTESTATION_DATA_LEN_OFFSET, true);
+  const signer = readKey(data, signerOffset);
+  const expiryOffset = signerOffset + PUBKEY_BYTES;
+  if (signer === null || expiryOffset + 8 > data.length) {
+    return null;
+  }
+  return {
+    nonce: readKey(data, ATTESTATION_NONCE_OFFSET),
+    credential: readKey(data, ATTESTATION_CREDENTIAL_OFFSET),
+    schema: readKey(data, ATTESTATION_SCHEMA_OFFSET),
+    signer,
+    expiry: Number(view.getBigInt64(expiryOffset, true))
+  };
+}
+function standingOf(expiry, now) {
+  return expiry !== 0 && expiry <= now ? "expired" : "valid";
+}
+function clockTime(data) {
+  if (data === void 0 || data.length < CLOCK_UNIX_TIMESTAMP_OFFSET3 + 8) {
+    throw new Error("the node returned no clock, so no credential can be judged in or out of date");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.length);
+  return Number(view.getBigInt64(CLOCK_UNIX_TIMESTAMP_OFFSET3, true));
+}
+async function openedAt(connection, address) {
+  const signatures = await connection.getSignaturesForAddress(
+    address,
+    { limit: CREATED_SIGNATURES },
+    "confirmed"
+  );
+  let read = 0;
+  for (const entry of signatures) {
+    if (entry.err !== null) {
+      continue;
+    }
+    if (read === CREATED_TRANSACTIONS) {
+      break;
+    }
+    read += 1;
+    const detail = await connection.getTransaction(entry.signature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0
+    });
+    if (detail === null || detail.meta === null || detail.meta === void 0) {
+      continue;
+    }
+    const keys = detail.transaction.message.getAccountKeys({ accountKeysFromLookups: detail.meta.loadedAddresses }).keySegments().flat();
+    const index = keys.findIndex((key) => key.equals(address));
+    if (index >= 0 && detail.meta.preBalances[index] === 0 && (detail.meta.postBalances[index] ?? 0) > 0) {
+      return detail.blockTime ?? entry.blockTime ?? null;
+    }
+  }
+  return null;
+}
+async function listAttestations(connection, credential, schema) {
+  const credentialKey = requireRealPublicKey(credential, "credential");
+  const schemaKey = requireRealPublicKey(schema, "schema");
+  const accounts = await connection.getProgramAccounts(SAS_PROGRAM_ID, {
+    commitment: "confirmed",
+    filters: [
+      { memcmp: { offset: 0, bytes: ATTESTATION_DISCRIMINATOR_BASE58 } },
+      { memcmp: { offset: ATTESTATION_CREDENTIAL_OFFSET, bytes: credentialKey.toBase58() } },
+      { memcmp: { offset: ATTESTATION_SCHEMA_OFFSET, bytes: schemaKey.toBase58() } }
+    ]
+  });
+  const clock = await connection.getAccountInfo(SYSVAR_CLOCK_PUBKEY3, "confirmed");
+  const now = clockTime(clock?.data);
+  const issued = [];
+  for (const entry of accounts) {
+    const decoded = decodeAttestation(entry.account.owner, entry.account.data);
+    if (decoded === null || !decoded.credential.equals(credentialKey) || !decoded.schema.equals(schemaKey) || !attestationAddress(credentialKey, schemaKey, decoded.nonce).equals(entry.pubkey)) {
+      continue;
+    }
+    issued.push({
+      address: entry.pubkey,
+      wallet: decoded.nonce,
+      signer: decoded.signer,
+      expiry: decoded.expiry,
+      created: await openedAt(connection, entry.pubkey),
+      standing: standingOf(decoded.expiry, now)
+    });
+  }
+  return issued;
+}
+async function credentialStatus(connection, credential, schema, wallet) {
+  const credentialKey = requireRealPublicKey(credential, "credential");
+  const schemaKey = requireRealPublicKey(schema, "schema");
+  const walletKey = requireRealPublicKey(wallet, "wallet");
+  const [attestation, clock] = await connection.getMultipleAccountsInfo(
+    [attestationAddress(credentialKey, schemaKey, walletKey), SYSVAR_CLOCK_PUBKEY3],
+    "confirmed"
+  );
+  const now = clockTime(clock?.data);
+  if (attestation === null || attestation === void 0) {
+    return "absent";
+  }
+  const decoded = decodeAttestation(attestation.owner, attestation.data);
+  if (decoded === null || !decoded.nonce.equals(walletKey) || !decoded.credential.equals(credentialKey) || !decoded.schema.equals(schemaKey)) {
+    return "absent";
+  }
+  return standingOf(decoded.expiry, now);
+}
+export {
+  ACCESS_MODE,
+  DBC_PROGRAM_ID,
+  DOLLAR_SCALE,
+  LIMITS,
+  PANGU_ERRORS,
+  PANGU_IDL,
+  PANGU_PROGRAM_ID,
+  PANGU_SHARD_ID,
+  PYTH_PRICE_FEED_PROGRAM_ID,
+  PYTH_RECEIVER_PROGRAM_ID,
+  PanguInputError,
+  PanguLayoutError,
+  SALE_RULES_LAYOUT_VERSIONS,
+  SAS_PROGRAM_ID,
+  SEEDS,
+  TOKEN_2022_PROGRAM_ID,
+  VERIFIED_SCHEMA,
+  approveBuyerInstruction,
+  attestationAddress,
+  buyerRecordAddress,
+  closeAttestationInstruction,
+  closeBuyerRecordInstruction,
+  confidenceBps,
+  createAttestationInstruction,
+  createCredentialInstruction,
+  createSaleInstruction,
+  createSchemaInstruction,
+  credentialAddress,
+  credentialStatus,
+  curvePriceDollars,
+  dbcBaseVaultAddress,
+  decodeBuyerRecord,
+  decodePriceUpdate,
+  decodeSale,
+  dollarMints,
+  dollars,
+  explainPanguError,
+  extraAccountListAddress,
+  feedIdBytes,
+  feedIdHex,
+  getBuyerRecord,
+  getSale,
+  isSaleRunning,
+  listAttestations,
+  listBuyerRecords,
+  listSales,
+  openBuyerRecordInstruction,
+  panguErrorFromLogs,
+  priceCeiling,
+  priceFeedAddress,
+  readPrice,
+  revokeBuyerInstruction,
+  saleDirectory,
+  saleRulesAddress,
+  saleStanding,
+  saleTokenInfo,
+  schemaAddress,
+  stockPriceDollars
+};
+//# sourceMappingURL=index.mjs.map