@bujius/checkout-sdk 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,891 @@
+// src/errors.ts
+var ErrorCode = {
+  ORDER_NOT_FOUND: "ORDER_NOT_FOUND",
+  ORDER_EXPIRED: "ORDER_EXPIRED",
+  ORDER_PAID: "ORDER_PAID",
+  ORDER_HELD: "ORDER_HELD",
+  INVALID_ACCOUNT: "INVALID_ACCOUNT",
+  INVALID_AMOUNT: "INVALID_AMOUNT",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  RPC_UNAVAILABLE: "RPC_UNAVAILABLE"
+};
+var BujiusCheckoutError = class extends Error {
+  code;
+  constructor(code, options) {
+    super(code, options);
+    this.name = "BujiusCheckoutError";
+    this.code = code;
+  }
+};
+function isBujiusCheckoutError(value) {
+  return value instanceof BujiusCheckoutError;
+}
+
+// src/program/pda.ts
+import { PublicKey } from "@solana/web3.js";
+
+// src/program/idl.json
+var idl_default = {
+  address: "LNv2EvYZFN1fBJeQPDGffRxVYPMCGpa99yCcWDSDdjN",
+  metadata: {
+    name: "bujius_checkout",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "create_split",
+      discriminator: [
+        196,
+        195,
+        250,
+        188,
+        17,
+        255,
+        10,
+        151
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  112,
+                  108,
+                  105,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "arg",
+                path: "id"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint",
+          docs: [
+            "Classic SPL Token mint only (Token-2022 is out of scope)."
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "id",
+          type: "u16"
+        },
+        {
+          name: "recipients",
+          type: {
+            vec: {
+              defined: {
+                name: "Recipient"
+              }
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "pay",
+      discriminator: [
+        119,
+        18,
+        216,
+        65,
+        192,
+        117,
+        122,
+        220
+      ],
+      accounts: [
+        {
+          name: "payer",
+          signer: true
+        },
+        {
+          name: "payer_token",
+          writable: true
+        },
+        {
+          name: "config"
+        },
+        {
+          name: "mint"
+        },
+        {
+          name: "merchant_token",
+          writable: true
+        },
+        {
+          name: "reference"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "SplitConfig",
+      discriminator: [
+        49,
+        201,
+        50,
+        228,
+        22,
+        142,
+        12,
+        222
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "SplitCreated",
+      discriminator: [
+        87,
+        61,
+        160,
+        84,
+        73,
+        204,
+        93,
+        140
+      ]
+    },
+    {
+      name: "SplitPaid",
+      discriminator: [
+        223,
+        17,
+        5,
+        250,
+        228,
+        37,
+        72,
+        80
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "InvalidRecipientCount",
+      msg: "A split config needs between 1 and 4 recipients"
+    },
+    {
+      code: 6001,
+      name: "ZeroBps",
+      msg: "Every recipient needs at least 1 bps"
+    },
+    {
+      code: 6002,
+      name: "SplitOverflow",
+      msg: "The recipients' bps add up to more than 10 000"
+    },
+    {
+      code: 6003,
+      name: "DuplicateRecipient",
+      msg: "Recipient wallets must be distinct and different from the merchant"
+    },
+    {
+      code: 6004,
+      name: "ZeroAmount",
+      msg: "The amount must be greater than zero"
+    },
+    {
+      code: 6005,
+      name: "MintMismatch",
+      msg: "The mint does not match the split config's mint"
+    },
+    {
+      code: 6006,
+      name: "BadTokenAccount",
+      msg: "A token account is not the expected associated token account"
+    },
+    {
+      code: 6007,
+      name: "RecipientCountMismatch",
+      msg: "The number of remaining accounts does not match the recipients"
+    },
+    {
+      code: 6008,
+      name: "MathOverflow",
+      msg: "Arithmetic overflow"
+    }
+  ],
+  types: [
+    {
+      name: "Recipient",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "wallet",
+            type: "pubkey"
+          },
+          {
+            name: "bps",
+            type: "u16"
+          }
+        ]
+      }
+    },
+    {
+      name: "SplitConfig",
+      docs: [
+        "One per merchant per `id`; immutable after creation."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "id",
+            type: "u16"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "recipients",
+            type: {
+              vec: {
+                defined: {
+                  name: "Recipient"
+                }
+              }
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "SplitCreated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "config",
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "recipients",
+            type: {
+              vec: {
+                defined: {
+                  name: "Recipient"
+                }
+              }
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "SplitPaid",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "config",
+            type: "pubkey"
+          },
+          {
+            name: "payer",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "reference",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "merchant_amount",
+            type: "u64"
+          },
+          {
+            name: "shares",
+            type: {
+              vec: "u64"
+            }
+          },
+          {
+            name: "ts",
+            type: "i64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/program/pda.ts
+var PROGRAM_ID = new PublicKey(idl_default.address);
+function findSplitConfig(authority, id) {
+  const idBytes = new Uint8Array(2);
+  new DataView(idBytes.buffer).setUint16(0, id, true);
+  return PublicKey.findProgramAddressSync(
+    [new TextEncoder().encode("split"), authority.toBytes(), idBytes],
+    PROGRAM_ID
+  )[0];
+}
+
+// src/program/config.ts
+import { BorshAccountsCoder } from "@coral-xyz/anchor";
+import "@solana/web3.js";
+var coder = new BorshAccountsCoder(idl_default);
+async function fetchSplitConfig(connection, address) {
+  let info;
+  try {
+    info = await connection.getAccountInfo(address, "confirmed");
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  if (!info || !info.owner.equals(PROGRAM_ID)) {
+    throw new BujiusCheckoutError(ErrorCode.CONFIG_NOT_FOUND);
+  }
+  const decoded = coder.decode("SplitConfig", info.data);
+  return {
+    address,
+    authority: decoded.authority,
+    id: decoded.id,
+    mint: decoded.mint,
+    recipients: decoded.recipients.map((r) => ({
+      wallet: r.wallet,
+      bps: r.bps
+    }))
+  };
+}
+
+// src/program/create-split.ts
+import { BorshInstructionCoder } from "@coral-xyz/anchor";
+import {
+  createAssociatedTokenAccountIdempotentInstruction,
+  getAssociatedTokenAddressSync
+} from "@solana/spl-token";
+import {
+  SystemProgram,
+  Transaction,
+  TransactionInstruction
+} from "@solana/web3.js";
+var coder2 = new BorshInstructionCoder(idl_default);
+async function buildCreateSplit(connection, authority, id, mint, recipients) {
+  const tx = new Transaction();
+  for (const owner of [authority, ...recipients.map((r) => r.wallet)]) {
+    tx.add(
+      createAssociatedTokenAccountIdempotentInstruction(
+        authority,
+        getAssociatedTokenAddressSync(mint, owner),
+        owner,
+        mint
+      )
+    );
+  }
+  tx.add(
+    new TransactionInstruction({
+      programId: PROGRAM_ID,
+      keys: [
+        { pubkey: authority, isSigner: true, isWritable: true },
+        { pubkey: findSplitConfig(authority, id), isSigner: false, isWritable: true },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      ],
+      data: coder2.encode("create_split", { id, recipients })
+    })
+  );
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+  tx.feePayer = authority;
+  tx.recentBlockhash = blockhash;
+  tx.lastValidBlockHeight = lastValidBlockHeight;
+  return tx;
+}
+
+// src/core/amounts.ts
+function toBaseUnits(decimal, decimals) {
+  if (typeof decimal !== "string" || decimal.length === 0) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  if (!/^\d+(\.\d+)?$/.test(decimal)) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  const [wholePart, fractionPart = ""] = decimal.split(".");
+  if (fractionPart.length > decimals) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  return BigInt(`${wholePart}${fractionPart.padEnd(decimals, "0")}`);
+}
+function fromBaseUnits(amount, decimals) {
+  if (typeof amount !== "bigint" || amount < 0n) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  const raw = amount.toString();
+  if (decimals === 0) {
+    return raw;
+  }
+  const padded = raw.padStart(decimals + 1, "0");
+  const whole = padded.slice(0, -decimals);
+  const fraction = padded.slice(-decimals);
+  const trimmedFraction = fraction.replace(/0+$/, "");
+  return trimmedFraction.length === 0 ? whole : `${whole}.${trimmedFraction}`;
+}
+
+// src/core/reference.ts
+import { Keypair } from "@solana/web3.js";
+function newReference() {
+  return Keypair.generate().publicKey;
+}
+
+// src/core/url.ts
+import { encodeURL } from "@solana/pay";
+function paymentUrl(handlerHttpsUrl) {
+  return encodeURL({ link: new URL(handlerHttpsUrl) }).toString();
+}
+
+// src/core/split-math.ts
+function computeSplit(amount, bps) {
+  if (amount < 0n) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  const validBps = bps.every((b) => Number.isInteger(b) && b >= 0);
+  if (!validBps || bps.reduce((total, b) => total + b, 0) > 1e4) {
+    throw new BujiusCheckoutError(ErrorCode.CONFIG_NOT_FOUND);
+  }
+  const shares = bps.map((b) => amount * BigInt(b) / 10000n);
+  let sum = 0n;
+  for (const share of shares) {
+    sum += share;
+  }
+  return { shares, merchant: amount - sum };
+}
+
+// src/strategies/transfers.ts
+import {
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction3,
+  createTransferCheckedInstruction,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3,
+  unpackMint
+} from "@solana/spl-token";
+import { PublicKey as PublicKey3, Transaction as Transaction3 } from "@solana/web3.js";
+
+// src/strategies/program.ts
+import anchor, { BorshInstructionCoder as BorshInstructionCoder2 } from "@coral-xyz/anchor";
+import {
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction2,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2,
+  TOKEN_PROGRAM_ID
+} from "@solana/spl-token";
+import {
+  Transaction as Transaction2,
+  TransactionInstruction as TransactionInstruction2
+} from "@solana/web3.js";
+var { BN } = anchor;
+var coder3 = new BorshInstructionCoder2(idl_default);
+async function buildProgramPayment(connection, config, payer, amount, reference) {
+  const { shares, merchant } = computeSplit(
+    amount,
+    config.recipients.map((r) => r.bps)
+  );
+  const ataOf = (wallet) => getAssociatedTokenAddressSync2(config.mint, wallet, true);
+  const merchantToken = ataOf(config.authority);
+  const recipientAtas = config.recipients.map((r) => ataOf(r.wallet));
+  const source = ataOf(payer);
+  const funded = [
+    ...config.recipients.map((r, i) => ({ wallet: r.wallet, ata: recipientAtas[i], amount: shares[i] })).filter((leg) => leg.amount > 0n),
+    ...merchant > 0n ? [{ wallet: config.authority, ata: merchantToken, amount: merchant }] : []
+  ];
+  let infos;
+  try {
+    infos = await connection.getMultipleAccountsInfo(
+      [...funded.map((leg) => leg.ata), source],
+      "confirmed"
+    );
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  if (!infos[funded.length]) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT);
+  }
+  const tx = new Transaction2();
+  for (let i = 0; i < funded.length; i++) {
+    if (infos[i] == null) {
+      const leg = funded[i];
+      tx.add(
+        createAssociatedTokenAccountIdempotentInstruction2(payer, leg.ata, leg.wallet, config.mint)
+      );
+    }
+  }
+  tx.add(
+    new TransactionInstruction2({
+      programId: PROGRAM_ID,
+      keys: [
+        { pubkey: payer, isSigner: true, isWritable: false },
+        { pubkey: source, isSigner: false, isWritable: true },
+        { pubkey: config.address, isSigner: false, isWritable: false },
+        { pubkey: config.mint, isSigner: false, isWritable: false },
+        { pubkey: merchantToken, isSigner: false, isWritable: true },
+        { pubkey: reference, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        // remaining accounts, in config.recipients order
+        ...recipientAtas.map((pubkey) => ({ pubkey, isSigner: false, isWritable: true }))
+      ],
+      data: coder3.encode("pay", { amount: new BN(amount.toString()) })
+    })
+  );
+  let blockhash;
+  let lastValidBlockHeight;
+  try {
+    ({ blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed"));
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  tx.feePayer = payer;
+  tx.recentBlockhash = blockhash;
+  tx.lastValidBlockHeight = lastValidBlockHeight;
+  return tx;
+}
+
+// src/strategies/transfers.ts
+var U64_MAX = 18446744073709551615n;
+async function buildSplitPayment(connection, config, payer, amount, reference, strategy) {
+  if (amount <= 0n || amount > U64_MAX) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_AMOUNT);
+  }
+  if (!PublicKey3.isOnCurve(payer) || payer.equals(config.authority) || config.recipients.some((r) => r.wallet.equals(payer))) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT);
+  }
+  if (strategy === "program") {
+    return buildProgramPayment(connection, config, payer, amount, reference);
+  }
+  if (strategy !== "transfers") {
+    throw new Error(`unknown payment strategy: ${String(strategy)}`);
+  }
+  return buildTransfersPayment(connection, config, payer, amount, reference);
+}
+async function buildTransfersPayment(connection, config, payer, amount, reference) {
+  const { shares, merchant } = computeSplit(
+    amount,
+    config.recipients.map((r) => r.bps)
+  );
+  const legs = [];
+  for (let i = 0; i < config.recipients.length; i++) {
+    const share = shares[i];
+    if (share > 0n) {
+      legs.push({ wallet: config.recipients[i].wallet, amount: share });
+    }
+  }
+  if (merchant > 0n) {
+    legs.push({ wallet: config.authority, amount: merchant });
+  }
+  const ataOf = (wallet) => getAssociatedTokenAddressSync3(config.mint, wallet, true);
+  const destAtas = legs.map((leg) => ataOf(leg.wallet));
+  const source = ataOf(payer);
+  let infos;
+  try {
+    infos = await connection.getMultipleAccountsInfo(
+      [...destAtas, config.mint, source],
+      "confirmed"
+    );
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  const mintInfo = infos[destAtas.length];
+  const sourceInfo = infos[destAtas.length + 1];
+  if (!mintInfo || !sourceInfo) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT);
+  }
+  let decimals;
+  try {
+    decimals = unpackMint(config.mint, mintInfo).decimals;
+  } catch (cause) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT, { cause });
+  }
+  const tx = new Transaction3();
+  for (let i = 0; i < destAtas.length; i++) {
+    if (infos[i] == null) {
+      const leg = legs[i];
+      const ata = destAtas[i];
+      tx.add(
+        createAssociatedTokenAccountIdempotentInstruction3(
+          payer,
+          ata,
+          leg.wallet,
+          config.mint
+        )
+      );
+    }
+  }
+  let firstTransfer = true;
+  for (let i = 0; i < legs.length; i++) {
+    const leg = legs[i];
+    const destination = destAtas[i];
+    const ix = createTransferCheckedInstruction(
+      source,
+      config.mint,
+      destination,
+      payer,
+      leg.amount,
+      decimals
+    );
+    if (firstTransfer) {
+      ix.keys.push({ pubkey: reference, isSigner: false, isWritable: false });
+      firstTransfer = false;
+    }
+    tx.add(ix);
+  }
+  let blockhash;
+  let lastValidBlockHeight;
+  try {
+    ({ blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed"));
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  tx.feePayer = payer;
+  tx.recentBlockhash = blockhash;
+  tx.lastValidBlockHeight = lastValidBlockHeight;
+  return tx;
+}
+
+// src/verify/find-payment.ts
+async function findPayment(connection, reference) {
+  let signatures;
+  try {
+    signatures = await connection.getSignaturesForAddress(reference, void 0, "confirmed");
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  const successful = signatures.filter((s) => s.err === null);
+  return successful.length > 0 ? successful[successful.length - 1].signature : null;
+}
+
+// src/verify/verify-payment.ts
+function totals(balances, mint) {
+  const byOwner = /* @__PURE__ */ new Map();
+  for (const b of balances ?? []) {
+    if (b.mint !== mint || !b.owner) continue;
+    byOwner.set(b.owner, (byOwner.get(b.owner) ?? 0n) + BigInt(b.uiTokenAmount.amount));
+  }
+  return byOwner;
+}
+async function verifySplitPayment(connection, signature, config, amount, reference, expiresAt) {
+  const expected = computeSplit(
+    amount,
+    config.recipients.map((r) => r.bps)
+  );
+  const wallets = [...config.recipients.map((r) => r.wallet), config.authority];
+  const expectedAmounts = [...expected.shares, expected.merchant];
+  const invalid = (reason, legs2 = []) => ({
+    status: "invalid",
+    reason,
+    legs: legs2
+  });
+  let tx;
+  try {
+    tx = await connection.getParsedTransaction(signature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0
+    });
+  } catch {
+    throw new BujiusCheckoutError(ErrorCode.RPC_UNAVAILABLE);
+  }
+  if (!tx || !tx.meta) return invalid("transaction not found");
+  if (tx.meta.err !== null) return invalid("transaction failed");
+  const referenceKey = reference.toBase58();
+  if (!tx.transaction.message.accountKeys.some((k) => String(k.pubkey) === referenceKey)) {
+    return invalid("reference not in the transaction");
+  }
+  const mint = config.mint.toBase58();
+  const pre = totals(tx.meta.preTokenBalances, mint);
+  const post = totals(tx.meta.postTokenBalances, mint);
+  const legs = wallets.map((wallet) => {
+    const key = wallet.toBase58();
+    return { wallet, amount: (post.get(key) ?? 0n) - (pre.get(key) ?? 0n) };
+  });
+  for (let i = 0; i < legs.length; i++) {
+    if (legs[i].amount !== expectedAmounts[i]) {
+      return invalid(
+        `${legs[i].wallet.toBase58()} received ${legs[i].amount}, expected ${expectedAmounts[i]}`,
+        legs
+      );
+    }
+  }
+  const late = expiresAt !== void 0 && tx.blockTime != null && tx.blockTime * 1e3 > expiresAt.getTime();
+  return { status: late ? "paid_late" : "paid", legs };
+}
+
+// src/server/handler.ts
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+var ERROR_RESPONSES = {
+  [ErrorCode.INVALID_ACCOUNT]: { status: 400, sentence: "We could not read your account. Try again." },
+  [ErrorCode.ORDER_NOT_FOUND]: { status: 404, sentence: "This order does not exist." },
+  [ErrorCode.ORDER_HELD]: { status: 409, sentence: "Someone else is already paying this order." },
+  [ErrorCode.ORDER_PAID]: { status: 409, sentence: "This order is already paid." },
+  [ErrorCode.ORDER_EXPIRED]: {
+    status: 410,
+    sentence: "This order expired. Go back to the store and start again."
+  },
+  [ErrorCode.RPC_UNAVAILABLE]: { status: 503, sentence: "The network is busy. Try again in a moment." }
+};
+var UNPAYABLE = { status: 500, sentence: "This order cannot be paid. Go back to the store." };
+function respond(status, body) {
+  const headers = new Headers(CORS_HEADERS);
+  if (body === void 0) {
+    return new Response(null, { status, headers });
+  }
+  headers.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(body), { status, headers });
+}
+function describeFailure(error) {
+  if (isBujiusCheckoutError(error)) {
+    return error.code;
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message.replace(/[a-z][a-z0-9+.-]*:\/\/\S+/gi, "<url>")}`;
+  }
+  return typeof error;
+}
+function respondToError(error) {
+  const known = isBujiusCheckoutError(error) ? ERROR_RESPONSES[error.code] : void 0;
+  const { status, sentence } = known ?? UNPAYABLE;
+  if (status >= 500) {
+    console.error(`Transaction request failed: ${describeFailure(error)}`);
+  }
+  return respond(status, { error: sentence });
+}
+async function readAccount(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch (cause) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT, { cause });
+  }
+  const account = body?.account;
+  if (typeof account !== "string") {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT);
+  }
+  try {
+    return new PublicKey4(account);
+  } catch (cause) {
+    throw new BujiusCheckoutError(ErrorCode.INVALID_ACCOUNT, { cause });
+  }
+}
+function createTransactionRequestHandler(options) {
+  const { connection, label, iconUrl, strategy, resolve } = options;
+  return async (request) => {
+    if (request.method === "OPTIONS") {
+      return respond(204);
+    }
+    if (request.method === "GET") {
+      return respond(200, { label, icon: iconUrl });
+    }
+    if (request.method !== "POST") {
+      return respond(405, { error: "This request is not supported." });
+    }
+    try {
+      const account = await readAccount(request);
+      const key = new URL(request.url).pathname.split("/").filter(Boolean).at(-1) ?? "";
+      const resolved = await resolve(key, account);
+      if ("error" in resolved) {
+        throw new BujiusCheckoutError(resolved.error);
+      }
+      const { config, amount, reference, message } = resolved;
+      const transaction = await buildSplitPayment(
+        connection,
+        config,
+        account,
+        amount,
+        reference,
+        strategy
+      );
+      const serialized = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      });
+      return respond(200, { transaction: serialized.toString("base64"), message });
+    } catch (error) {
+      return respondToError(error);
+    }
+  };
+}
+export {
+  BujiusCheckoutError,
+  ErrorCode,
+  PROGRAM_ID,
+  buildCreateSplit,
+  buildSplitPayment,
+  computeSplit,
+  createTransactionRequestHandler,
+  fetchSplitConfig,
+  findPayment,
+  findSplitConfig,
+  fromBaseUnits,
+  isBujiusCheckoutError,
+  newReference,
+  paymentUrl,
+  toBaseUnits,
+  verifySplitPayment
+};
+//# sourceMappingURL=index.js.map