@piprail/sdk 2.3.0 → 2.4.0

package/dist/algorand-HZS43N4P.cjs

@@ -1,389 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-var _chunkJG6KRAW6cjs = require('./chunk-JG6KRAW6.cjs');
-
-// src/drivers/algorand/index.ts
-var _algosdk = require('algosdk'); var _algosdk2 = _interopRequireDefault(_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 _nullishCoalesce(_chunkJG6KRAW6cjs.toInsufficientFundsError.call(void 0, 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 (0, _chunkJG6KRAW6cjs.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 (0, _chunkJG6KRAW6cjs.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 (e2) {
-    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 (e3) {
-    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: _nullishCoalesce(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
-
-function assertAlgorandWallet(wallet, network) {
-  if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkJG6KRAW6cjs.WrongFamilyError)(
-      `chain ${network} is Algorand; wallet must be { key } (25-word mnemonic) or { account }.`
-    );
-  }
-  _chunkJG6KRAW6cjs.assertNoLegacyWalletKey.call(void 0, wallet, "Algorand");
-  if (!("key" in wallet) && !("account" in wallet)) {
-    throw new (0, _chunkJG6KRAW6cjs.WrongFamilyError)(
-      `chain ${network} is Algorand; wallet must be { key } (25-word mnemonic) or { account }.`
-    );
-  }
-  return wallet;
-}
-function resolveAlgorandWallet(config) {
-  if (config.account) {
-    return { addr: String(config.account.addr), sk: config.account.sk };
-  }
-  if (config.key != null) {
-    try {
-      const { addr, sk } = _algosdk2.default.mnemonicToSecretKey(config.key);
-      return { addr: addr.toString(), sk };
-    } catch (cause) {
-      throw new (0, _chunkJG6KRAW6cjs.WrongFamilyError)(
-        "Algorand wallet { key } is not a valid 25-word Algorand mnemonic.",
-        { cause }
-      );
-    }
-  }
-  throw new (0, _chunkJG6KRAW6cjs.WrongFamilyError)("Algorand wallet needs { key } (25-word mnemonic) or { account }.");
-}
-
-// src/drivers/algorand/index.ts
-var algorandDriver = {
-  family: "algorand",
-  resolve(opts) {
-    if (opts.chain !== "algorand") return null;
-    const algodUrl = _nullishCoalesce(opts.rpcUrl, () => ( ALGORAND_MAINNET.defaultAlgod));
-    return makeAlgorandNetwork(ALGORAND_MAINNET, algodUrl);
-  }
-};
-function makeAlgorandNetwork(preset, algodUrl) {
-  const algod = new _algosdk2.default.Algodv2("", algodUrl, "");
-  const indexer = new _algosdk2.default.Indexer("", preset.defaultIndexer, "");
-  const network = preset.caip2;
-  const reader = {
-    async transactionsForAccount(account, limit) {
-      const res = await indexer.lookupAccountTransactions(account).limit(limit).do();
-      return (_nullishCoalesce(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.default.makePaymentTxnWithSuggestedParamsFromObject(common) : _algosdk2.default.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 (0, _chunkJG6KRAW6cjs.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 };
-      }
-      _chunkJG6KRAW6cjs.rejectForeignToken.call(void 0, token, "algorand", network);
-      const t = token;
-      if (typeof t.assetId !== "number" || typeof t.decimals !== "number") {
-        throw new (0, _chunkJG6KRAW6cjs.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 (0, _chunkJG6KRAW6cjs.WrongFamilyError)(
-          `chain ${network} is Algorand, but payTo "${payTo}" looks like an EVM address.`
-        );
-      }
-      if (!_algosdk2.default.isValidAddress(payTo)) {
-        throw new (0, _chunkJG6KRAW6cjs.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.default.waitForConfirmation(algod, ref, 10);
-        return { height: String(_nullishCoalesce(info.confirmedRound, () => ( 0))) };
-      } catch (err) {
-        throw new (0, _chunkJG6KRAW6cjs.ConfirmationTimeoutError)(`Algorand tx ${ref} did not confirm in time.`, {
-          cause: err
-        });
-      }
-    },
-    async estimateCost() {
-      return _chunkJG6KRAW6cjs.nativeCost.call(void 0, {
-        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 (e4) {
-        return { token: null, native: null };
-      }
-      let info;
-      try {
-        info = await algod.accountInformation(owner).do();
-      } catch (e5) {
-        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 = (_nullishCoalesce(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 = (_nullishCoalesce(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(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _ => _.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(_nullishCoalesce(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 (e6) {
-    return void 0;
-  }
-}
-
-
-exports.algorandDriver = algorandDriver;