pangu-sdk 0.1.0

package/dist/dbc.mjs

@@ -0,0 +1,3027 @@
+// src/dbc/template.ts
+import { Keypair } from "@solana/web3.js";
+import {
+  CollectFeeMode,
+  DynamicBondingCurveClient as DynamicBondingCurveClient2,
+  MigrationOption,
+  TokenAuthorityOption,
+  TokenType,
+  buildCurve,
+  hasMintAuthority
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+// 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
+};
+
+// 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/dbc/budget.ts
+import { ComputeBudgetProgram } from "@solana/web3.js";
+var TRANSACTION_SIZE_LIMIT = 1232;
+var COMPUTE_LIMIT = {
+  /** Measured: 113,000 to 130,000 units for a buy, 83,000 for a sell. */
+  swap: 3e5,
+  /** Measured: 55,192 for the partner claim, 51,742 for the creator claim. */
+  claim: 15e4
+};
+function computeLimit(units) {
+  return ComputeBudgetProgram.setComputeUnitLimit({ units });
+}
+function transactionBytes(transaction) {
+  const message = transaction.compileMessage();
+  return message.serialize().length + 1 + 64 * message.header.numRequiredSignatures;
+}
+function requireOneTransaction(transaction, action) {
+  const bytes = transactionBytes(transaction);
+  if (bytes > TRANSACTION_SIZE_LIMIT) {
+    throw new PanguInputError(
+      `${action} does not fit in one transaction: ${bytes} bytes against the ${TRANSACTION_SIZE_LIMIT} byte limit`
+    );
+  }
+  return bytes;
+}
+
+// src/dbc/state.ts
+import {
+  BaseFeeMode,
+  DynamicBondingCurveClient,
+  createDbcProgram,
+  deriveDbcPoolAuthority,
+  getCurrentPoint,
+  getTokenProgram
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+// src/accounts.ts
+import { Buffer } from "buffer";
+import { getTransferHook, unpackMint } from "@solana/spl-token";
+
+// 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 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/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);
+}
+
+// src/dbc/state.ts
+var DBC_POOL_AUTHORITY = deriveDbcPoolAuthority();
+var POOL_BASE_MINT_OFFSET = 136;
+function dbcProgram(connection) {
+  return createDbcProgram(connection, "confirmed").program;
+}
+async function requireSale(connection, mint) {
+  const sale = await getSale(connection, requirePublicKey(mint, "mint"));
+  if (sale === null) {
+    throw new PanguInputError(
+      `${mint.toBase58()} has no Pangu sale, so there is nothing to trade here`
+    );
+  }
+  return sale;
+}
+async function loadConfig(connection, config) {
+  const client = new DynamicBondingCurveClient(connection, "confirmed");
+  const state = await client.state.getPoolConfig(config);
+  if (state === null) {
+    throw new PanguInputError(
+      `${config.toBase58()} is not a Meteora launch template`
+    );
+  }
+  return state;
+}
+async function loadPool(connection, mint) {
+  const sale = await requireSale(connection, mint);
+  return { sale, ...await readMarket(connection, sale.pool) };
+}
+async function loadSellPool(connection, mint) {
+  const mintKey = requirePublicKey(mint, "mint");
+  let sale = null;
+  try {
+    sale = await getSale(connection, mintKey);
+  } catch (error) {
+    if (!(error instanceof PanguInputError)) {
+      throw error;
+    }
+  }
+  const pool = sale?.pool ?? await hookPoolSelling(connection, mintKey);
+  const market = await readMarket(connection, pool);
+  if (!market.baseMint.equals(mintKey)) {
+    throw new PanguInputError(
+      `${pool.toBase58()} sells ${market.baseMint.toBase58()}, not ${mintKey.toBase58()}`
+    );
+  }
+  return { sale, ...market };
+}
+async function hookPoolSelling(connection, mint) {
+  const found = await dbcProgram(connection).account.transferHookPool.all([
+    { memcmp: { offset: POOL_BASE_MINT_OFFSET, bytes: mint.toBase58() } }
+  ]);
+  if (found.length === 0) {
+    throw new PanguInputError(
+      `no Meteora transfer hook pool sells ${mint.toBase58()}, so there is nothing to sell into`
+    );
+  }
+  if (found.length > 1) {
+    throw new PanguInputError(
+      `${found.length} transfer hook pools sell ${mint.toBase58()}, and a sell will not pick one on a guess`
+    );
+  }
+  return found[0].publicKey;
+}
+async function readMarket(connection, pool) {
+  const program = dbcProgram(connection);
+  const poolAccount = await program.account.transferHookPool.fetchNullable(
+    pool,
+    "confirmed"
+  );
+  if (poolAccount === null) {
+    throw new PanguInputError(
+      `${pool.toBase58()} is not a Meteora transfer hook pool`
+    );
+  }
+  const configState = await loadConfig(connection, poolAccount.poolState.config);
+  if (configState.enableFirstSwapWithMinFee || configState.poolFees.baseFee.baseFeeMode === BaseFeeMode.RateLimiter) {
+    throw new PanguInputError(
+      "this launch template puts the instructions sysvar in the swap's remaining accounts, where Pangu's hook accounts have to be. Open the sale with launchTemplateTransaction."
+    );
+  }
+  return {
+    pool,
+    poolAccount,
+    config: poolAccount.poolState.config,
+    configState,
+    baseMint: poolAccount.poolState.baseMint,
+    quoteMint: configState.quoteMint,
+    baseVault: poolAccount.poolState.baseVault,
+    quoteVault: poolAccount.poolState.quoteVault,
+    quoteProgram: getTokenProgram(configState.quoteTokenFlag),
+    currentPoint: await getCurrentPoint(connection, configState.activationType)
+  };
+}
+async function readyToSign(connection, transaction, payer) {
+  transaction.feePayer = payer;
+  transaction.recentBlockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
+  return transaction;
+}
+
+// src/dbc/template.ts
+var FORCED = {
+  tokenType: TokenType.Token2022,
+  tokenUpdateAuthority: TokenAuthorityOption.CreatorUpdateAuthority,
+  collectFeeMode: CollectFeeMode.QuoteToken,
+  migrationOption: MigrationOption.MET_DAMM_V2,
+  transferHookProgram: PANGU_PROGRAM_ID
+};
+function forced(given, wanted, field, why) {
+  if (given !== void 0 && given !== wanted) {
+    throw new PanguInputError(
+      `${field} is fixed at ${String(wanted)} for a Pangu sale and cannot be set to ${String(given)}: ${why}`
+    );
+  }
+  return wanted;
+}
+function withoutMintAuthority(given) {
+  if (given === void 0) {
+    return FORCED.tokenUpdateAuthority;
+  }
+  if (hasMintAuthority(given)) {
+    throw new PanguInputError(
+      `curve.token.tokenAuthorityOption ${String(given)} leaves the mint authority alive, and Pangu will not open a sale on a token that can still be minted: use CreatorUpdateAuthority, Immutable or PartnerUpdateAuthority`
+    );
+  }
+  return given;
+}
+function panguCurve(curve) {
+  if (curve === null || typeof curve !== "object") {
+    throw new PanguInputError("curve must be the parameters buildCurve takes");
+  }
+  return {
+    ...curve,
+    token: {
+      ...curve.token,
+      tokenType: forced(
+        curve.token?.tokenType,
+        FORCED.tokenType,
+        "curve.token.tokenType",
+        "a transfer hook only exists on Token-2022"
+      ),
+      tokenAuthorityOption: withoutMintAuthority(curve.token?.tokenAuthorityOption)
+    },
+    fee: {
+      ...curve.fee,
+      collectFeeMode: forced(
+        curve.fee?.collectFeeMode,
+        FORCED.collectFeeMode,
+        "curve.fee.collectFeeMode",
+        "fees taken in the sale token would move it past every cap and approval"
+      )
+    },
+    migration: {
+      ...curve.migration,
+      migrationOption: forced(
+        curve.migration?.migrationOption,
+        FORCED.migrationOption,
+        "curve.migration.migrationOption",
+        "a Pangu sale graduates to DAMM v2"
+      )
+    }
+  };
+}
+async function launchTemplateTransaction(input) {
+  const partner = requireRealPublicKey(input.partner, "partner");
+  const payer = input.payer === void 0 ? partner : requireRealPublicKey(input.payer, "payer");
+  const quoteMint = requireRealPublicKey(input.quoteMint, "quoteMint");
+  forced(
+    input.transferHookProgram?.toBase58(),
+    FORCED.transferHookProgram.toBase58(),
+    "transferHookProgram",
+    "the sale's rules live in Pangu, so Pangu has to be the hook"
+  );
+  const client = new DynamicBondingCurveClient2(input.connection, "confirmed");
+  const config = Keypair.generate();
+  const transaction = await client.partner.createConfigWithTransferHook({
+    config: config.publicKey,
+    feeClaimer: input.feeClaimer ?? partner,
+    leftoverReceiver: input.leftoverReceiver ?? partner,
+    payer,
+    quoteMint,
+    tokenBadge: input.tokenBadge,
+    transferHookProgram: FORCED.transferHookProgram,
+    ...buildCurve(panguCurve(input.curve))
+  });
+  await readyToSign(input.connection, transaction, payer);
+  return {
+    transaction,
+    config,
+    bytes: requireOneTransaction(transaction, "the launch template")
+  };
+}
+
+// src/dbc/open.ts
+import { Keypair as Keypair2 } from "@solana/web3.js";
+import {
+  DynamicBondingCurveClient as DynamicBondingCurveClient3,
+  deriveDbcPoolAddress
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+// 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)
+    ],
+    {}
+  );
+}
+
+// src/dbc/open.ts
+function capFromShare(swapBaseAmount, capShareBps) {
+  const amount = requireBigint(swapBaseAmount, "swapBaseAmount");
+  if (typeof capShareBps === "number" && capShareBps >= 1e4) {
+    throw new PanguInputError(
+      `sale.capShareBps must be below 10000 (100 percent), got ${capShareBps}: a cap covering the whole curve lets one wallet buy everything, and the program refuses it`
+    );
+  }
+  const bps = requireWholeNumber(capShareBps, "sale.capShareBps", 1, 9999);
+  const cap = amount * BigInt(bps) / 10000n;
+  if (cap <= 0n) {
+    throw new PanguInputError(
+      "that share of this curve rounds down to no tokens at all, raise capShareBps"
+    );
+  }
+  return cap;
+}
+function capOf(terms, config) {
+  const hasCap = terms.cap !== void 0 && terms.cap !== null;
+  const hasShare = terms.capShareBps !== void 0 && terms.capShareBps !== null;
+  if (hasCap === hasShare) {
+    throw new PanguInputError(
+      "a sale needs either cap or capShareBps, and never both, because they would disagree"
+    );
+  }
+  return hasCap ? requireBigint(terms.cap, "sale.cap") : capFromShare(BigInt(config.swapBaseAmount.toString()), terms.capShareBps);
+}
+async function openSaleTransaction(input) {
+  const creator = requireRealPublicKey(input.creator, "creator");
+  const payer = input.payer === void 0 ? creator : requireRealPublicKey(input.payer, "payer");
+  const config = requireRealPublicKey(input.config, "config");
+  const accessMode = requireWholeNumber(input.sale?.accessMode, "sale.accessMode", 0, 2);
+  const configState = await loadConfig(input.connection, config);
+  if (configState.collectFeeMode !== FORCED.collectFeeMode) {
+    throw new PanguInputError(
+      "this template collects fees in the sale token, which would move it past every cap. Open the template with launchTemplateTransaction."
+    );
+  }
+  const cap = capOf(input.sale, configState);
+  const baseMint = input.baseMint ?? Keypair2.generate();
+  const quoteMint = configState.quoteMint;
+  const pool = deriveDbcPoolAddress(quoteMint, baseMint.publicKey, config);
+  const client = new DynamicBondingCurveClient3(input.connection, "confirmed");
+  const transaction = await client.creator.createPoolWithTransferHook({
+    baseMint: baseMint.publicKey,
+    config,
+    name: input.name,
+    symbol: input.symbol,
+    uri: input.uri,
+    payer,
+    poolCreator: creator,
+    tokenBadge: input.tokenBadge,
+    transferHookProgram: FORCED.transferHookProgram
+  });
+  const band = input.sale.band;
+  transaction.add(
+    createSaleInstruction({
+      issuer: creator,
+      pool,
+      mint: baseMint.publicKey,
+      cap,
+      accessMode,
+      credential: accessMode === ACCESS_MODE.verifierCredential ? input.sale.credential : void 0,
+      schema: accessMode === ACCESS_MODE.verifierCredential ? input.sale.schema : void 0,
+      band,
+      dbcConfig: config,
+      quoteMint,
+      endsAt: input.sale.endsAt
+    })
+  );
+  await readyToSign(input.connection, transaction, payer);
+  return {
+    transaction,
+    baseMint,
+    pool,
+    bytes: requireOneTransaction(transaction, "the pool and the sale's rules")
+  };
+}
+
+// src/dbc/trade.ts
+import {
+  SystemProgram as SystemProgram2
+} from "@solana/web3.js";
+import { BN as BN3 } from "@anchor-lang/core";
+import {
+  NATIVE_MINT,
+  createAssociatedTokenAccountIdempotentInstruction,
+  createSyncNativeInstruction,
+  getAssociatedTokenAddressSync
+} from "@solana/spl-token";
+import { SwapMode } from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+// src/dbc/quote.ts
+import { BN as BN2 } from "@anchor-lang/core";
+import {
+  swapQuoteExactIn,
+  swapQuoteExactOut,
+  swapQuotePartialFill
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+function quoteExactIn(view, swapBaseForQuote, amountIn, slippageBps) {
+  return swapQuoteExactIn(
+    view.poolAccount,
+    view.configState,
+    swapBaseForQuote,
+    new BN2(amountIn.toString()),
+    slippageBps,
+    false,
+    view.currentPoint,
+    // The template Pangu builds leaves the first swap minimum fee off, and
+    // loadPool refuses a template that turns it on.
+    false
+  );
+}
+function quoteExactOut(view, swapBaseForQuote, amountOut, slippageBps) {
+  return swapQuoteExactOut(
+    view.poolAccount,
+    view.configState,
+    swapBaseForQuote,
+    new BN2(amountOut.toString()),
+    slippageBps,
+    false,
+    view.currentPoint,
+    false
+  );
+}
+function quotePartialFill(view, swapBaseForQuote, amountIn, slippageBps) {
+  return swapQuotePartialFill(
+    view.poolAccount,
+    view.configState,
+    swapBaseForQuote,
+    new BN2(amountIn.toString()),
+    slippageBps,
+    false,
+    view.currentPoint,
+    false
+  );
+}
+
+// src/dbc/hook.ts
+import { Buffer as Buffer2 } from "buffer";
+import {
+  createExecuteInstruction,
+  getExtraAccountMetas,
+  resolveExtraAccountMeta
+} from "@solana/spl-token";
+import { AccountsType } from "@meteora-ag/dynamic-bonding-curve-sdk";
+function tokenAccountBytes(mint, owner) {
+  const data = Buffer2.alloc(165);
+  mint.toBuffer().copy(data, 0);
+  owner.toBuffer().copy(data, 32);
+  return data;
+}
+function chainPlusPending(connection, pending) {
+  if (pending.length === 0) {
+    return connection;
+  }
+  const known = new Map(
+    pending.map((account) => [
+      account.address.toBase58(),
+      {
+        data: tokenAccountBytes(account.mint, account.owner),
+        owner: TOKEN_2022_PROGRAM_ID,
+        executable: false,
+        lamports: 0,
+        rentEpoch: 0
+      }
+    ])
+  );
+  const reader = {
+    getAccountInfo: async (address) => known.get(address.toBase58()) ?? await connection.getAccountInfo(address)
+  };
+  return reader;
+}
+async function hookAccounts(input) {
+  const validation = extraAccountListAddress(input.mint);
+  const listAccount = await input.connection.getAccountInfo(validation);
+  if (listAccount === null) {
+    throw new PanguInputError(
+      `${input.mint.toBase58()} has no published Pangu account list, so it is not a running Pangu sale`
+    );
+  }
+  const execute = createExecuteInstruction(
+    PANGU_PROGRAM_ID,
+    input.source,
+    input.mint,
+    input.destination,
+    input.authority,
+    validation,
+    input.amount
+  );
+  const reader = chainPlusPending(input.connection, input.pending ?? []);
+  for (const meta2 of getExtraAccountMetas(listAccount)) {
+    execute.keys.push(
+      await resolveExtraAccountMeta(
+        reader,
+        meta2,
+        execute.keys,
+        execute.data,
+        PANGU_PROGRAM_ID
+      )
+    );
+  }
+  return [
+    { pubkey: validation, isSigner: false, isWritable: false },
+    ...execute.keys.slice(5),
+    { pubkey: PANGU_PROGRAM_ID, isSigner: false, isWritable: false }
+  ];
+}
+function hookAccountsInfo(accounts) {
+  return {
+    slices: [
+      { accountsType: AccountsType.TransferHookBase, length: accounts.length }
+    ]
+  };
+}
+
+// src/dbc/trade.ts
+var DEFAULT_SLIPPAGE_BPS = 100;
+async function buildSwap(options) {
+  const { connection, view, owner, swapBaseForQuote, amountIn } = options;
+  const partial = options.fill === "partial";
+  const quote = partial ? quotePartialFill(view, swapBaseForQuote, amountIn, options.slippageBps) : quoteExactIn(view, swapBaseForQuote, amountIn, options.slippageBps);
+  const quoted = BigInt(quote.outputAmount.toString());
+  if (options.floor !== void 0 && quoted < options.floor) {
+    throw new PanguInputError(
+      `the market moved: ${options.action} now returns ${quoted} raw units, below the floor of ${options.floor}. Take a fresh quote`
+    );
+  }
+  const minimumAmountOut = options.floor ?? (partial ? 0n : BigInt((quote.minimumAmountOut ?? 0n).toString()));
+  const quoteAta = getAssociatedTokenAddressSync(
+    view.quoteMint,
+    owner,
+    false,
+    view.quoteProgram
+  );
+  const baseAta = getAssociatedTokenAddressSync(
+    view.baseMint,
+    owner,
+    false,
+    TOKEN_2022_PROGRAM_ID
+  );
+  const pre = [computeLimit(COMPUTE_LIMIT.swap)];
+  const pending = [];
+  pre.push(
+    createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      quoteAta,
+      owner,
+      view.quoteMint,
+      view.quoteProgram
+    )
+  );
+  if (!swapBaseForQuote) {
+    const baseAccount = await connection.getAccountInfo(baseAta);
+    if (baseAccount === null) {
+      pre.push(
+        createAssociatedTokenAccountIdempotentInstruction(
+          owner,
+          baseAta,
+          owner,
+          view.baseMint,
+          TOKEN_2022_PROGRAM_ID
+        )
+      );
+      pending.push({ address: baseAta, mint: view.baseMint, owner });
+    }
+    if (view.quoteMint.equals(NATIVE_MINT)) {
+      pre.push(
+        SystemProgram2.transfer({
+          fromPubkey: owner,
+          toPubkey: quoteAta,
+          lamports: amountIn
+        }),
+        createSyncNativeInstruction(quoteAta, view.quoteProgram)
+      );
+    }
+    const record = await connection.getAccountInfo(
+      buyerRecordAddress(view.baseMint, owner)
+    );
+    if (record === null) {
+      pre.push(openBuyerRecordInstruction({ wallet: owner, mint: view.baseMint }));
+    }
+  }
+  const hook = await hookAccounts({
+    connection,
+    mint: view.baseMint,
+    source: swapBaseForQuote ? baseAta : view.baseVault,
+    destination: swapBaseForQuote ? view.baseVault : baseAta,
+    authority: swapBaseForQuote ? owner : DBC_POOL_AUTHORITY,
+    amount: swapBaseForQuote ? amountIn : BigInt(quote.outputAmount.toString()),
+    pending
+  });
+  const transaction = await dbcProgram(connection).methods.swap2WithTransferHook(
+    {
+      amount0: new BN3(amountIn.toString()),
+      amount1: new BN3(minimumAmountOut.toString()),
+      swapMode: partial ? SwapMode.PartialFill : SwapMode.ExactIn
+    },
+    hookAccountsInfo(hook)
+  ).accountsPartial({
+    poolAuthority: DBC_POOL_AUTHORITY,
+    config: view.config,
+    pool: view.pool,
+    inputTokenAccount: swapBaseForQuote ? baseAta : quoteAta,
+    outputTokenAccount: swapBaseForQuote ? quoteAta : baseAta,
+    baseVault: view.baseVault,
+    quoteVault: view.quoteVault,
+    baseMint: view.baseMint,
+    quoteMint: view.quoteMint,
+    payer: owner,
+    tokenBaseProgram: TOKEN_2022_PROGRAM_ID,
+    tokenQuoteProgram: view.quoteProgram,
+    referralTokenAccount: null
+  }).remainingAccounts(hook).preInstructions(pre).transaction();
+  await readyToSign(connection, transaction, owner);
+  return {
+    transaction,
+    expectedAmountOut: quoted,
+    minimumAmountOut,
+    bytes: requireOneTransaction(transaction, options.action),
+    computeUnitLimit: COMPUTE_LIMIT.swap
+  };
+}
+function slippageOf(value) {
+  return value === void 0 ? DEFAULT_SLIPPAGE_BPS : requireWholeNumber(value, "slippageBps", 0, 1e4);
+}
+function floorOf(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const floor = requireBigint(value, field);
+  if (floor < 0n) {
+    throw new PanguInputError(`${field} must not be below zero`);
+  }
+  return floor;
+}
+function amountOf(value, field) {
+  const amount = requireBigint(value, field);
+  if (amount <= 0n) {
+    throw new PanguInputError(`${field} must be above zero`);
+  }
+  return amount;
+}
+async function buyTransaction(input) {
+  const buyer = requireRealPublicKey(input.buyer, "buyer");
+  const amountIn = amountOf(input.amountIn, "amountIn");
+  const floor = floorOf(input.minimumAmountOut, "minimumAmountOut");
+  const view = await loadPool(input.connection, input.mint);
+  return buildSwap({
+    connection: input.connection,
+    view,
+    owner: buyer,
+    swapBaseForQuote: false,
+    amountIn,
+    slippageBps: slippageOf(input.slippageBps),
+    action: "the buy",
+    fill: input.fill ?? "exactIn",
+    floor
+  });
+}
+async function sellTransaction(input) {
+  const seller = requireRealPublicKey(input.seller, "seller");
+  const amountIn = amountOf(input.amountIn, "amountIn");
+  const floor = floorOf(input.minimumQuoteOut, "minimumQuoteOut");
+  const view = await loadSellPool(input.connection, input.mint);
+  return buildSwap({
+    connection: input.connection,
+    view,
+    owner: seller,
+    swapBaseForQuote: true,
+    amountIn,
+    slippageBps: slippageOf(input.slippageBps),
+    action: "the sell",
+    floor
+  });
+}
+
+// src/dbc/preflight.ts
+import { SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2 } from "@solana/web3.js";
+
+// 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/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 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
+import {
+  SYSVAR_CLOCK_PUBKEY,
+  PublicKey as Web3PublicKey
+} from "@solana/web3.js";
+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/dbc/credential.ts
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
+var ATTESTATION_DISCRIMINATOR = 2;
+var CREDENTIAL_DISCRIMINATOR = 0;
+var 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 CREDENTIAL_NAME_LEN_OFFSET = 33;
+var CREDENTIAL_NAME_OFFSET = 37;
+var PUBKEY_LEN = 32;
+var MAX_AUTHORIZED_SIGNERS = 64;
+var NEVER_EXPIRES = 0;
+function readPubkey(data, offset) {
+  const end = offset + PUBKEY_LEN;
+  if (!Number.isSafeInteger(end) || offset < 0 || end > data.length) {
+    return null;
+  }
+  return new PublicKey5(data.subarray(offset, end));
+}
+function readU32(data, offset) {
+  const end = offset + 4;
+  if (!Number.isSafeInteger(end) || offset < 0 || end > data.length) {
+    return null;
+  }
+  return new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, true);
+}
+function readI64(data, offset) {
+  const end = offset + 8;
+  if (!Number.isSafeInteger(end) || offset < 0 || end > data.length) {
+    return null;
+  }
+  return new DataView(data.buffer, data.byteOffset + offset, 8).getBigInt64(0, true);
+}
+function parseAttestation(account) {
+  if (!account.owner.equals(SAS_PROGRAM_ID)) {
+    return null;
+  }
+  const data = account.data;
+  if (data.length === 0 || data[0] !== ATTESTATION_DISCRIMINATOR) {
+    return null;
+  }
+  const nonce = readPubkey(data, NONCE_OFFSET);
+  const credential = readPubkey(data, ATTESTATION_CREDENTIAL_OFFSET);
+  const schema = readPubkey(data, ATTESTATION_SCHEMA_OFFSET);
+  const blobLength = readU32(data, ATTESTATION_DATA_LEN_OFFSET);
+  if (nonce === null || credential === null || schema === null || blobLength === null) {
+    return null;
+  }
+  const signerOffset = ATTESTATION_DATA_OFFSET + blobLength;
+  const signer = readPubkey(data, signerOffset);
+  const expiry = readI64(data, signerOffset + PUBKEY_LEN);
+  if (signer === null || expiry === null) {
+    return null;
+  }
+  return { nonce, credential, schema, signer, expiry };
+}
+function listsSigner(account, signer) {
+  if (!account.owner.equals(SAS_PROGRAM_ID)) {
+    return null;
+  }
+  const data = account.data;
+  if (data.length === 0 || data[0] !== CREDENTIAL_DISCRIMINATOR) {
+    return null;
+  }
+  const nameLength = readU32(data, CREDENTIAL_NAME_LEN_OFFSET);
+  if (nameLength === null) {
+    return null;
+  }
+  const countOffset = CREDENTIAL_NAME_OFFSET + nameLength;
+  const count = readU32(data, countOffset);
+  if (count === null || count > MAX_AUTHORIZED_SIGNERS) {
+    return null;
+  }
+  let offset = countOffset + 4;
+  for (let index = 0; index < count; index += 1) {
+    const key = readPubkey(data, offset);
+    if (key === null) {
+      return null;
+    }
+    if (key.equals(signer)) {
+      return true;
+    }
+    offset += PUBKEY_LEN;
+  }
+  return false;
+}
+function credentialRefusal(rules, wallet, state) {
+  if (state.attestation === null || state.credential === null) {
+    return "CredentialInvalid";
+  }
+  const attested = parseAttestation(state.attestation);
+  if (attested === null) {
+    return "CredentialInvalid";
+  }
+  if (!attested.credential.equals(rules.credential) || !attested.schema.equals(rules.schema) || !attested.nonce.equals(wallet)) {
+    return "CredentialInvalid";
+  }
+  const expiry = attested.expiry;
+  if (expiry !== BigInt(NEVER_EXPIRES) && expiry <= BigInt(Math.floor(state.now))) {
+    return "CredentialExpired";
+  }
+  const authorized = listsSigner(state.credential, attested.signer);
+  if (authorized === null) {
+    return "CredentialInvalid";
+  }
+  return authorized ? null : "CredentialSignerNotAuthorized";
+}
+
+// src/dbc/preflight.ts
+function refused(error, capRoom, extra = {}) {
+  return {
+    ok: false,
+    error,
+    reason: explainPanguError(error),
+    capRoom,
+    curvePrice: null,
+    ceiling: null,
+    price: null,
+    recordOpensInThisBuy: false,
+    ...extra
+  };
+}
+async function preflightBuy(input) {
+  const buyer = requireRealPublicKey(input.buyer, "buyer");
+  const amountOut = requireBigint(input.amountOut, "amountOut");
+  if (amountOut <= 0n) {
+    throw new PanguInputError("amountOut must be above zero");
+  }
+  const openingRecord = input.openingRecord === true;
+  const view = await loadPool(input.connection, input.mint);
+  const sale = view.sale;
+  const existing = await getBuyerRecord(input.connection, sale.mint, buyer);
+  if (existing === null && !openingRecord) {
+    return refused("BuyerRecordMissing", sale.cap);
+  }
+  const recordOpensInThisBuy = existing === null;
+  const record = existing ?? { approved: false, netBought: 0n };
+  const capRoom = max(sale.cap - record.netBought, 0n);
+  const opened = { recordOpensInThisBuy };
+  if (sale.accessMode === ACCESS_MODE.issuerList && !record.approved) {
+    return refused("NotApproved", capRoom, opened);
+  }
+  if (sale.accessMode === ACCESS_MODE.verifierCredential) {
+    const refusal = await credentialCheck(input.connection, sale, buyer);
+    if (refusal !== null) {
+      return refused(refusal, capRoom, opened);
+    }
+  }
+  let price = null;
+  let curvePrice = null;
+  let ceiling = null;
+  if (sale.hasBand) {
+    price = await readPrice(input.connection, sale);
+    if (!price.usable) {
+      return refused(price.error ?? "PriceStale", capRoom, { price, ...opened });
+    }
+    const quote = quoteExactOut(view, false, amountOut, 0);
+    curvePrice = curvePriceDollars(
+      BigInt(quote.nextSqrtPrice.toString()),
+      sale.baseDecimals,
+      sale.quoteDecimals
+    );
+    ceiling = priceCeiling(sale, price.price);
+    if (curvePrice > ceiling) {
+      return refused("PriceOutsideBand", capRoom, { curvePrice, ceiling, price, ...opened });
+    }
+  }
+  if (amountOut > capRoom) {
+    return refused("OverCap", capRoom, { curvePrice, ceiling, price, ...opened });
+  }
+  return {
+    ok: true,
+    error: null,
+    reason: null,
+    capRoom,
+    curvePrice,
+    ceiling,
+    price,
+    recordOpensInThisBuy
+  };
+}
+function max(a, b) {
+  return a > b ? a : b;
+}
+var CLOCK_UNIX_TIMESTAMP_OFFSET2 = 32;
+async function credentialCheck(connection, sale, buyer) {
+  const read = await connection.getMultipleAccountsInfo([
+    sale.credential,
+    attestationAddress(sale.credential, sale.schema, buyer),
+    SYSVAR_CLOCK_PUBKEY2
+  ]);
+  const credential = read[0] ?? null;
+  const attestation = read[1] ?? null;
+  const clock = read[2] ?? null;
+  const stamp = clock !== null && clock.data.length >= CLOCK_UNIX_TIMESTAMP_OFFSET2 + 8 ? Number(clock.data.readBigInt64LE(CLOCK_UNIX_TIMESTAMP_OFFSET2)) : Math.floor(Date.now() / 1e3);
+  return credentialRefusal(sale, buyer, {
+    credential: credential === null ? null : { owner: credential.owner, data: credential.data },
+    attestation: attestation === null ? null : { owner: attestation.owner, data: attestation.data },
+    now: stamp
+  });
+}
+
+// src/dbc/fees.ts
+import { BN as BN4 } from "@anchor-lang/core";
+import {
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction2,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2
+} from "@solana/spl-token";
+var EVERYTHING = new BN4("18446744073709551615");
+async function claimFeesTransaction(input) {
+  if (input.who !== "partner" && input.who !== "creator") {
+    throw new PanguInputError('who must be "partner" or "creator"');
+  }
+  const view = await loadPool(input.connection, input.mint);
+  const claimer = input.who === "partner" ? view.configState.feeClaimer : view.poolAccount.poolState.creator;
+  const baseAta = getAssociatedTokenAddressSync2(
+    view.baseMint,
+    claimer,
+    false,
+    TOKEN_2022_PROGRAM_ID
+  );
+  const quoteAta = getAssociatedTokenAddressSync2(
+    view.quoteMint,
+    claimer,
+    false,
+    view.quoteProgram
+  );
+  const pending = [];
+  const pre = [computeLimit(COMPUTE_LIMIT.claim)];
+  if (await input.connection.getAccountInfo(baseAta) === null) {
+    pending.push({ address: baseAta, mint: view.baseMint, owner: claimer });
+  }
+  pre.push(
+    createAssociatedTokenAccountIdempotentInstruction2(
+      claimer,
+      baseAta,
+      claimer,
+      view.baseMint,
+      TOKEN_2022_PROGRAM_ID
+    ),
+    createAssociatedTokenAccountIdempotentInstruction2(
+      claimer,
+      quoteAta,
+      claimer,
+      view.quoteMint,
+      view.quoteProgram
+    )
+  );
+  const hook = await hookAccounts({
+    connection: input.connection,
+    mint: view.baseMint,
+    source: view.baseVault,
+    destination: baseAta,
+    authority: DBC_POOL_AUTHORITY,
+    amount: 0n,
+    pending
+  });
+  const shared = {
+    poolAuthority: DBC_POOL_AUTHORITY,
+    pool: view.pool,
+    tokenAAccount: baseAta,
+    tokenBAccount: quoteAta,
+    baseVault: view.baseVault,
+    quoteVault: view.quoteVault,
+    baseMint: view.baseMint,
+    quoteMint: view.quoteMint,
+    tokenBaseProgram: TOKEN_2022_PROGRAM_ID,
+    tokenQuoteProgram: view.quoteProgram
+  };
+  const program = dbcProgram(input.connection);
+  const builder = input.who === "partner" ? program.methods.claimTradingFee2(new BN4(0), EVERYTHING, hookAccountsInfo(hook)).accountsPartial({ ...shared, config: view.config, feeClaimer: claimer }) : program.methods.claimCreatorTradingFee2(new BN4(0), EVERYTHING, hookAccountsInfo(hook)).accountsPartial({ ...shared, creator: claimer });
+  const transaction = await builder.remainingAccounts(hook).preInstructions(pre).transaction();
+  await readyToSign(input.connection, transaction, claimer);
+  return {
+    transaction,
+    claimer,
+    bytes: requireOneTransaction(transaction, `the ${input.who} fee claim`),
+    computeUnitLimit: COMPUTE_LIMIT.claim
+  };
+}
+
+// src/dbc/graduate.ts
+import {
+  DAMM_V2_MIGRATION_FEE_ADDRESS,
+  DynamicBondingCurveClient as DynamicBondingCurveClient4,
+  deriveDammV2PoolAddress
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+function dammConfigOf(view) {
+  const option = view.configState.migrationFeeOption;
+  const config = DAMM_V2_MIGRATION_FEE_ADDRESS[option];
+  if (config === void 0) {
+    throw new PanguInputError(
+      `this template names migration fee option ${option}, which DAMM v2 has no config for`
+    );
+  }
+  return config;
+}
+async function graduateTransaction(input) {
+  const payer = requireRealPublicKey(input.payer, "payer");
+  const view = await loadPool(input.connection, input.mint);
+  const state = view.poolAccount.poolState;
+  if (state.isMigrated !== 0) {
+    throw new PanguInputError("this sale has already been migrated to DAMM v2");
+  }
+  if (state.quoteReserve.lt(view.configState.migrationQuoteThreshold)) {
+    throw new PanguInputError(
+      "the curve is not full yet, so there is nothing to migrate"
+    );
+  }
+  const dammConfig = dammConfigOf(view);
+  const client = new DynamicBondingCurveClient4(input.connection, "confirmed");
+  const { transaction, firstPositionNftKeypair, secondPositionNftKeypair } = await client.migration.migrateToDammV2({
+    pool: view.pool,
+    dammConfig,
+    payer
+  });
+  await readyToSign(input.connection, transaction, payer);
+  return {
+    transaction,
+    signers: [firstPositionNftKeypair, secondPositionNftKeypair],
+    dammPool: deriveDammV2PoolAddress(dammConfig, view.baseMint, view.quoteMint),
+    bytes: requireOneTransaction(transaction, "the migration to DAMM v2")
+  };
+}
+async function saleProgress(connection, mint) {
+  const view = await loadPool(connection, mint);
+  const quoteRaised = BigInt(view.poolAccount.poolState.quoteReserve.toString());
+  const threshold = BigInt(view.configState.migrationQuoteThreshold.toString());
+  const dammPool = deriveDammV2PoolAddress(
+    dammConfigOf(view),
+    view.baseMint,
+    view.quoteMint
+  );
+  const exists = await connection.getAccountInfo(dammPool);
+  return {
+    quoteRaised,
+    threshold,
+    percent: threshold === 0n ? 0 : Math.min(1, Number(quoteRaised * 1000000n / threshold) / 1e6),
+    graduated: quoteRaised >= threshold,
+    dammPool: exists === null ? null : dammPool
+  };
+}
+export {
+  COMPUTE_LIMIT,
+  DBC_POOL_AUTHORITY,
+  FORCED,
+  TRANSACTION_SIZE_LIMIT,
+  buyTransaction,
+  capFromShare,
+  claimFeesTransaction,
+  dbcProgram,
+  graduateTransaction,
+  hookAccounts,
+  hookAccountsInfo,
+  launchTemplateTransaction,
+  loadPool,
+  loadSellPool,
+  openSaleTransaction,
+  panguCurve,
+  preflightBuy,
+  requireOneTransaction,
+  requireSale,
+  saleProgress,
+  sellTransaction,
+  transactionBytes
+};
+//# sourceMappingURL=dbc.mjs.map