pangu-sdk 0.1.0

package/dist/price.mjs

@@ -0,0 +1,1533 @@
+// src/price.ts
+import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
+
+// src/addresses.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+
+// 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 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
+};
+
+// 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 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;
+}
+
+// src/addresses.ts
+var HEX = /^[0-9a-fA-F]+$/;
+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 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/price.ts
+var HERMES_URL = "https://hermes.pyth.network";
+var API_KEY_VARIABLE = "PYTH_API_KEY";
+var COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 2e4;
+var HERMES_TIMEOUT_MS = 15e3;
+function feedOf(input) {
+  if (input.sale !== void 0 && input.sale !== null) {
+    if (!input.sale.hasBand) {
+      throw new PanguInputError(
+        "this sale has no price band, so it has no price to refresh"
+      );
+    }
+    return { feedId: input.sale.priceFeedId, shard: input.sale.priceShard };
+  }
+  if (input.feed === void 0 || input.feed === null) {
+    throw new PanguInputError("a refresh needs either a sale or a feed id");
+  }
+  return {
+    feedId: feedIdHex(input.feed.priceFeedId),
+    shard: input.feed.shard === void 0 ? PANGU_SHARD_ID : requireWholeNumber(input.feed.shard, "feed.shard", 0, LIMITS.maxShard)
+  };
+}
+function apiKey(given) {
+  const key = given === void 0 || given === "" ? globalThis.process?.env?.[API_KEY_VARIABLE] : given;
+  if (key === void 0 || key === "") {
+    throw new PanguInputError(
+      `${API_KEY_VARIABLE} is not set. Every Hermes read has needed a key since 26 August 2026, and it belongs in the server's environment, never in a browser.`
+    );
+  }
+  return key;
+}
+async function latestUpdate(host, feedId, key) {
+  const url = `${host}/v2/updates/price/latest?ids[]=${feedId}&encoding=base64`;
+  const response = await fetch(url, {
+    headers: { Authorization: `Bearer ${key}` },
+    signal: AbortSignal.timeout(HERMES_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const body2 = (await response.text()).slice(0, 200).split(key).join("[key]");
+    throw new PanguInputError(`Hermes answered ${response.status}: ${body2}`);
+  }
+  const body = await response.json();
+  const data = body?.binary?.data;
+  if (!Array.isArray(data) || data.length === 0 || typeof data[0] !== "string") {
+    throw new PanguInputError("Hermes returned no price update for this feed");
+  }
+  return data;
+}
+async function refreshPriceTransaction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const { feedId, shard } = feedOf(input);
+  const key = apiKey(input.apiKey);
+  const updateData = await latestUpdate(
+    input.hermesUrl ?? HERMES_URL,
+    feedId,
+    key
+  );
+  const wallet = {
+    publicKey: payer,
+    signTransaction: () => {
+      throw new PanguInputError("pangu-sdk never signs, sign the transactions yourself");
+    },
+    signAllTransactions: () => {
+      throw new PanguInputError("pangu-sdk never signs, sign the transactions yourself");
+    }
+  };
+  const receiver = new PythSolanaReceiver({ connection: input.connection, wallet });
+  const builder = receiver.newTransactionBuilder({ closeUpdateAccounts: true });
+  await builder.addUpdatePriceFeed(updateData, shard);
+  const built = await builder.buildVersionedTransactions({
+    computeUnitPriceMicroLamports: COMPUTE_UNIT_PRICE_MICRO_LAMPORTS
+  });
+  const transactions = built.map((entry) => ({
+    transaction: entry.tx,
+    signers: entry.signers
+  }));
+  return {
+    transactions,
+    priceAccount: priceFeedAddress(feedId, shard),
+    shard,
+    feedId,
+    bytes: transactions.reduce(
+      (total, entry) => total + entry.transaction.serialize().length,
+      0
+    )
+  };
+}
+export {
+  API_KEY_VARIABLE,
+  refreshPriceTransaction
+};
+//# sourceMappingURL=price.mjs.map