@piprail/sdk 1.3.1 → 1.5.0

package/dist/algorand-B67G4335.js

@@ -0,0 +1,397 @@
+import {
+  ConfirmationTimeoutError,
+  InsufficientFundsError,
+  RecipientNotReadyError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-QDS6FBZP.js";
+
+// src/drivers/algorand/index.ts
+import algosdk2 from "algosdk";
+
+// src/drivers/algorand/chains.ts
+var ALGO_DECIMALS = 6;
+var ALGO_SYMBOL = "ALGO";
+var ALGORAND_MAINNET = {
+  caip2: "algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73k",
+  defaultAlgod: "https://mainnet-api.algonode.cloud",
+  defaultIndexer: "https://mainnet-idx.algonode.cloud",
+  tokens: {
+    // Circle USDC — ASA id + 6 decimals verified live on mainnet algod
+    // (/v2/assets/31566704 → unit-name "USDC", decimals 6, creator = Circle) before shipping.
+    // USDC-only: Tether deprecated USDT on Algorand, so it's intentionally omitted.
+    USDC: { assetId: 31566704, decimals: 6, symbol: "USDC" }
+  }
+};
+function algorandAssetId(assetId) {
+  return String(assetId);
+}
+function parseAlgorandAssetId(asset) {
+  if (asset === "native") return null;
+  if (!/^\d+$/.test(asset)) return null;
+  const n = Number(asset);
+  return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
+
+// src/drivers/algorand/pay.ts
+async function payAlgorand(params) {
+  const { client, sk, sender, accept } = params;
+  const note = new TextEncoder().encode(accept.extra.nonce);
+  const amount = BigInt(accept.amount);
+  const assetId = parseAlgorandAssetId(accept.asset);
+  try {
+    const { txn, txId } = await client.build({
+      sender,
+      receiver: accept.payTo,
+      amount,
+      note,
+      ...assetId === null ? {} : { assetId }
+    });
+    await client.signSend({ txn, sk });
+    return txId;
+  } catch (err) {
+    const mapped = mapAlgorandError(err, accept.payTo);
+    if (mapped) throw mapped;
+    throw toInsufficientFundsError(err) ?? err;
+  }
+}
+function mapAlgorandError(err, payTo) {
+  const m = err instanceof Error ? err.message : String(err);
+  if (/must optin/i.test(m) || /missing from/i.test(m) && m.includes(payTo)) {
+    return new RecipientNotReadyError(
+      `Algorand recipient ${payTo} hasn't opted into this asset \u2014 it must opt in (a 0-amount asset transfer to itself) before it can receive. (Algorand: ${firstLine(m)})`,
+      { cause: err }
+    );
+  }
+  if (/overspend|below min|min(imum)? balance|tried to spend|balance \d+ below|asset \d+ missing from|insufficient|underflow/i.test(
+    m
+  )) {
+    return new InsufficientFundsError(
+      `Algorand payment failed: the sender can't cover it \u2014 token balance, ALGO for fees, the 0.1-ALGO minimum balance, or a missing asset opt-in on the sender. (Algorand: ${firstLine(m)})`,
+      { cause: err }
+    );
+  }
+  return null;
+}
+function firstLine(message) {
+  return message.split("\n")[0].slice(0, 160);
+}
+
+// src/drivers/algorand/verify.ts
+async function verifyAlgorand(params) {
+  const { reader, accept } = params;
+  const nonce = accept.extra.nonce;
+  const required = BigInt(accept.amount);
+  const wantAssetId = parseAlgorandAssetId(accept.asset);
+  let txs;
+  try {
+    txs = await reader.transactionsForAccount(accept.payTo, 50);
+  } catch {
+    return rpcFailed(nonce);
+  }
+  const tx = txs.find((t) => typeof t.note === "string" && t.note === nonce);
+  if (!tx) return notFound(nonce);
+  if (typeof tx.roundTime === "number") {
+    const ageSeconds = Math.floor(Date.now() / 1e3) - tx.roundTime;
+    if (Number.isFinite(ageSeconds) && ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+  }
+  const isNative = wantAssetId === null;
+  const typeOk = isNative ? tx.txType === "pay" : tx.txType === "axfer";
+  const assetOk = isNative ? tx.assetId == null : tx.assetId === wantAssetId;
+  if (!typeOk || tx.receiver !== accept.payTo || !assetOk) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `Algorand tx ${tx.id} carries our nonce but has no matching ${isNative ? "ALGO" : `ASA ${wantAssetId}`} transfer to ${accept.payTo}.`
+    };
+  }
+  let paid = 0n;
+  try {
+    paid = tx.amount ? BigInt(tx.amount) : 0n;
+  } catch {
+    paid = 0n;
+  }
+  if (paid < required) {
+    return { ok: false, error: "amount_too_low", detail: `Paid ${paid}, required ${required}.` };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: tx.id,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer: tx.sender ?? "",
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function notFound(nonce) {
+  return {
+    ok: false,
+    error: "transfer_not_found",
+    detail: `No matching Algorand payment found for nonce ${nonce} (not yet settled, or wrong recipient/amount/asset/note).`
+  };
+}
+function rpcFailed(nonce) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Could not read the Algorand indexer for nonce ${nonce} (transient RPC failure) \u2014 retry.`
+  };
+}
+
+// src/drivers/algorand/wallet.ts
+import algosdk from "algosdk";
+function assertAlgorandWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is Algorand; wallet must be { mnemonic } (25 words) or { account }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Algorand; an EVM/Aptos wallet can't be used \u2014 pass { mnemonic } (25 words) or { account }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "secret" in wallet || "keypair" in wallet || "keyPair" in wallet || "seed" in wallet || "accountId" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Algorand; that looks like another family's wallet \u2014 pass { mnemonic } (25 words) or { account }.`
+    );
+  }
+  if (!("mnemonic" in wallet) && !("account" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is Algorand; wallet must be { mnemonic } (25 words) or { account }.`
+    );
+  }
+  return wallet;
+}
+function resolveAlgorandWallet(config) {
+  if (config.account) {
+    return { addr: String(config.account.addr), sk: config.account.sk };
+  }
+  if (config.mnemonic != null) {
+    try {
+      const { addr, sk } = algosdk.mnemonicToSecretKey(config.mnemonic);
+      return { addr: addr.toString(), sk };
+    } catch (cause) {
+      throw new WrongFamilyError(
+        "Algorand wallet { mnemonic } is not a valid 25-word Algorand mnemonic.",
+        { cause }
+      );
+    }
+  }
+  throw new WrongFamilyError("Algorand wallet needs { mnemonic } (25 words) or { account }.");
+}
+
+// src/drivers/algorand/index.ts
+var algorandDriver = {
+  family: "algorand",
+  resolve(opts) {
+    if (opts.chain !== "algorand") return null;
+    const algodUrl = opts.rpcUrl ?? ALGORAND_MAINNET.defaultAlgod;
+    return makeAlgorandNetwork(ALGORAND_MAINNET, algodUrl);
+  }
+};
+function makeAlgorandNetwork(preset, algodUrl) {
+  const algod = new algosdk2.Algodv2("", algodUrl, "");
+  const indexer = new algosdk2.Indexer("", preset.defaultIndexer, "");
+  const network = preset.caip2;
+  const reader = {
+    async transactionsForAccount(account, limit) {
+      const res = await indexer.lookupAccountTransactions(account).limit(limit).do();
+      return (res.transactions ?? []).map((t) => adaptTxn(t)).filter((r) => r !== null);
+    }
+  };
+  const payClient = {
+    async build(transfer) {
+      const suggestedParams = await algod.getTransactionParams().do();
+      const common = {
+        sender: transfer.sender,
+        receiver: transfer.receiver,
+        amount: transfer.amount,
+        note: transfer.note,
+        suggestedParams
+      };
+      const txn = transfer.assetId === void 0 ? algosdk2.makePaymentTxnWithSuggestedParamsFromObject(common) : algosdk2.makeAssetTransferTxnWithSuggestedParamsFromObject({
+        ...common,
+        assetIndex: transfer.assetId
+      });
+      return { txn, txId: txn.txID() };
+    },
+    async signSend({ txn, sk }) {
+      const signed = txn.signTxn(sk);
+      await algod.sendRawTransaction(signed).do();
+    }
+  };
+  return {
+    family: "algorand",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: ALGO_DECIMALS, symbol: ALGO_SYMBOL };
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new UnknownTokenError(
+            `token "${token}" isn't built in for Algorand (known: ${known}). Pass { assetId, decimals } for a custom ASA, or use 'native'.`
+          );
+        }
+        return { asset: algorandAssetId(info.assetId), decimals: info.decimals, symbol: info.symbol };
+      }
+      rejectForeignToken(token, "algorand", network);
+      const t = token;
+      if (typeof t.assetId !== "number" || typeof t.decimals !== "number") {
+        throw new WrongFamilyError(
+          `chain ${network} is Algorand; a custom token must be { assetId, decimals }.`
+        );
+      }
+      return {
+        asset: algorandAssetId(t.assetId),
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: ALGO_SYMBOL, decimals: ALGO_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (algorandAssetId(info.assetId) === asset) {
+          return { symbol: info.symbol, decimals: info.decimals };
+        }
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new WrongFamilyError(
+          `chain ${network} is Algorand, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!algosdk2.isValidAddress(payTo)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Algorand, but payTo "${payTo}" is not a valid Algorand address.`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertAlgorandWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const signer = resolveAlgorandWallet(wallet._native);
+      return payAlgorand({ client: payClient, sk: signer.sk, sender: signer.addr, accept });
+    },
+    async confirm(ref) {
+      try {
+        const info = await algosdk2.waitForConfirmation(algod, ref, 10);
+        return { height: String(info.confirmedRound ?? 0) };
+      } catch (err) {
+        throw new ConfirmationTimeoutError(`Algorand tx ${ref} did not confirm in time.`, {
+          cause: err
+        });
+      }
+    },
+    async estimateCost() {
+      return nativeCost({
+        symbol: ALGO_SYMBOL,
+        decimals: ALGO_DECIMALS,
+        fee: 1000n,
+        basis: "heuristic",
+        detail: "min fee 1000 \xB5Algos (1 transaction)"
+      });
+    },
+    async balanceOf(wallet, asset) {
+      let owner;
+      try {
+        owner = resolveAlgorandWallet(wallet._native).addr;
+      } catch {
+        return { token: null, native: null };
+      }
+      let info;
+      try {
+        info = await algod.accountInformation(owner).do();
+      } catch {
+        return { token: null, native: null };
+      }
+      const native = info.amount != null ? BigInt(info.amount) : null;
+      if (asset === "native") return { token: native, native };
+      const assetId = parseAlgorandAssetId(asset);
+      const holding = (info.assets ?? []).find((a) => Number(a.assetId) === assetId);
+      return { token: holding ? BigInt(holding.amount) : 0n, native };
+    },
+    async recipientReady(payTo, asset) {
+      if (asset === "native") return { ready: "n/a" };
+      const assetId = parseAlgorandAssetId(asset);
+      if (assetId == null) return { ready: "unknown" };
+      try {
+        const info = await algod.accountInformation(payTo).do();
+        const optedIn = (info.assets ?? []).some((a) => Number(a.assetId) === assetId);
+        return optedIn ? { ready: true } : { ready: false, reason: "NOT_OPTED_IN" };
+      } catch (e) {
+        if (/does not exist|no accounts found|404|account not found/i.test(String(e?.message ?? e))) {
+          return { ready: false, reason: "NOT_OPTED_IN" };
+        }
+        return { ready: "unknown" };
+      }
+    },
+    async verify(_ref, accept) {
+      return verifyAlgorand({ reader, accept });
+    }
+  };
+}
+function adaptTxn(raw) {
+  const t = raw;
+  if (!t || typeof t.id !== "string") return null;
+  const note = t.note && t.note.length ? decodeNote(t.note) : void 0;
+  const base = {
+    id: t.id,
+    txType: String(t.txType ?? ""),
+    ...note !== void 0 ? { note } : {},
+    ...t.sender != null ? { sender: String(t.sender) } : {},
+    ...typeof t.roundTime === "number" ? { roundTime: t.roundTime } : {}
+  };
+  if (t.paymentTransaction) {
+    const pt = t.paymentTransaction;
+    return {
+      ...base,
+      txType: "pay",
+      ...pt.receiver != null ? { receiver: String(pt.receiver) } : {},
+      ...pt.amount != null ? { amount: String(pt.amount) } : {}
+    };
+  }
+  if (t.assetTransferTransaction) {
+    const att = t.assetTransferTransaction;
+    return {
+      ...base,
+      txType: "axfer",
+      ...att.receiver != null ? { receiver: String(att.receiver) } : {},
+      ...att.amount != null ? { amount: String(att.amount) } : {},
+      ...att.assetId != null ? { assetId: Number(att.assetId) } : {}
+    };
+  }
+  return base;
+}
+function decodeNote(bytes) {
+  try {
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+export {
+  algorandDriver
+};