@piprail/sdk 1.0.0

package/dist/stellar-BPPQTLNI.cjs

@@ -0,0 +1,389 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/stellar/index.ts
+var _stellarsdk = require('@stellar/stellar-sdk');
+
+// src/drivers/stellar/chains.ts
+var STELLAR_DECIMALS = 7;
+var XLM_SYMBOL = "XLM";
+var STELLAR_PASSPHRASE = "Public Global Stellar Network ; September 2015";
+var STELLAR_MAINNET = {
+  caip2: "stellar:pubnet",
+  passphrase: STELLAR_PASSPHRASE,
+  defaultRpc: "https://horizon.stellar.org",
+  tokens: {
+    // Circle USDC — issuer + code verified live on Horizon /assets before shipping.
+    // (Mainnet issuer; NOT the testnet GBBD47IF… one.)
+    USDC: {
+      issuer: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
+      code: "USDC",
+      decimals: STELLAR_DECIMALS,
+      symbol: "USDC"
+    },
+    // Circle EURC — issuer + code verified live on Horizon /assets before shipping.
+    EURC: {
+      issuer: "GDHU6WRG4IEQXM5NZ4BMPKOXHW76MZM4Y2IEMFDVXBSDP6SJY4ITNPP2",
+      code: "EURC",
+      decimals: STELLAR_DECIMALS,
+      symbol: "EURC"
+    }
+  }
+};
+function stellarAssetId(code, issuer) {
+  return `${code}:${issuer}`;
+}
+function parseStellarAssetId(asset) {
+  if (asset === "native") return null;
+  const i = asset.indexOf(":");
+  if (i <= 0 || i === asset.length - 1) return null;
+  return { code: asset.slice(0, i), issuer: asset.slice(i + 1) };
+}
+
+// src/drivers/stellar/pay.ts
+
+
+
+
+
+
+
+
+function memoHashForNonce(nonce) {
+  return Buffer.from(_stellarsdk.hash.call(void 0, Buffer.from(nonce, "utf8")));
+}
+async function payStellar(params) {
+  const { server, keypair, accept } = params;
+  try {
+    const asset = assetForAccept(accept);
+    const source = await server.loadAccount(keypair.publicKey());
+    const tx = new (0, _stellarsdk.TransactionBuilder)(source, {
+      fee: _stellarsdk.BASE_FEE,
+      networkPassphrase: STELLAR_PASSPHRASE
+    }).addOperation(
+      _stellarsdk.Operation.payment({
+        destination: accept.payTo,
+        asset,
+        amount: accept.extra.amountFormatted
+      })
+    ).addMemo(_stellarsdk.Memo.hash(memoHashForNonce(accept.extra.nonce))).setTimeout(120).build();
+    tx.sign(keypair);
+    const res = await server.submitTransaction(tx);
+    return res.hash;
+  } catch (err) {
+    throw mapSubmitError(err);
+  }
+}
+function assetForAccept(accept) {
+  if (accept.asset === "native") return _stellarsdk.Asset.native();
+  const parts = parseStellarAssetId(accept.asset);
+  if (!parts) throw new Error(`Stellar: malformed asset id "${accept.asset}".`);
+  return new (0, _stellarsdk.Asset)(parts.code, parts.issuer);
+}
+function mapSubmitError(err) {
+  const codes = extractResultCodes(err);
+  if (codes.some((c) => /underfunded|insufficient|low_reserve|no_trust/i.test(c))) {
+    return new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+      "Stellar payment failed: insufficient balance/reserve, or the sender has no trustline for this asset.",
+      { cause: err }
+    );
+  }
+  if (isAccountNotFound(err)) {
+    return new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+      "Stellar source account not found on-chain \u2014 fund it (\u2265 base reserve) before it can pay.",
+      { cause: err }
+    );
+  }
+  return _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+}
+function isAccountNotFound(err) {
+  const e = err;
+  return _optionalChain([e, 'optionalAccess', _ => _.response, 'optionalAccess', _2 => _2.status]) === 404 || _optionalChain([e, 'optionalAccess', _3 => _3.name]) === "NotFoundError" || /not found|resource missing/i.test(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _4 => _4.message]), () => ( "")));
+}
+function extractResultCodes(err) {
+  const extras = _optionalChain([err, 'optionalAccess', _5 => _5.response, 'optionalAccess', _6 => _6.data, 'optionalAccess', _7 => _7.extras, 'optionalAccess', _8 => _8.result_codes]);
+  if (!extras) return [];
+  return [_nullishCoalesce(extras.transaction, () => ( "")), ..._nullishCoalesce(extras.operations, () => ( []))].filter(Boolean);
+}
+
+// src/drivers/stellar/verify.ts
+
+function memoCandidatesForNonce(nonce) {
+  const h = Buffer.from(_stellarsdk.hash.call(void 0, Buffer.from(nonce, "utf8")));
+  return [h.toString("base64"), h.toString("hex")];
+}
+async function verifyStellar(params) {
+  const { reader, accept } = params;
+  const nonce = accept.extra.nonce;
+  const required = BigInt(accept.amount);
+  const wantMemo = memoCandidatesForNonce(nonce);
+  const wantAsset = parseStellarAssetId(accept.asset);
+  let txs;
+  try {
+    txs = await reader.transactionsForAccount(accept.payTo, 50);
+  } catch (e2) {
+    return rpcFailed(nonce);
+  }
+  const tx = txs.find(
+    (t) => t.memo_type === "hash" && typeof t.memo === "string" && wantMemo.includes(t.memo)
+  );
+  if (!tx) return notFound(nonce);
+  if (!tx.successful) {
+    return {
+      ok: false,
+      error: "tx_reverted",
+      detail: `Stellar tx ${tx.hash} for nonce ${nonce} failed on-chain.`
+    };
+  }
+  const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(Date.parse(tx.created_at) / 1e3);
+  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.`
+    };
+  }
+  let payments;
+  try {
+    payments = await reader.paymentsForTransaction(tx.hash);
+  } catch (e3) {
+    return rpcFailed(nonce);
+  }
+  const toUs = payments.filter(
+    (p) => p.type === "payment" && p.to === accept.payTo && assetMatches(p, wantAsset)
+  );
+  if (toUs.length === 0) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `Stellar tx ${tx.hash} carries our nonce but has no matching ${wantAsset ? wantAsset.code : "XLM"} payment to ${accept.payTo}.`
+    };
+  }
+  const paid = toUs.reduce(
+    (sum, p) => sum + parseAmount(p.amount, accept.extra.decimals),
+    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.hash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer: toUs[0].from,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function assetMatches(p, want) {
+  if (want === null) return p.asset_type === "native";
+  return p.asset_type !== "native" && p.asset_code === want.code && p.asset_issuer === want.issuer;
+}
+function parseAmount(amount, decimals) {
+  try {
+    return _chunkWQWNPAYQcjs.parseUnits.call(void 0, amount, decimals);
+  } catch (e4) {
+    return 0n;
+  }
+}
+function notFound(nonce) {
+  return {
+    ok: false,
+    error: "transfer_not_found",
+    detail: `No matching Stellar payment found for nonce ${nonce} (not yet settled, or wrong recipient/amount/asset/memo).`
+  };
+}
+function rpcFailed(nonce) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Could not read Horizon for nonce ${nonce} (transient RPC failure) \u2014 retry.`
+  };
+}
+
+// src/drivers/stellar/wallet.ts
+
+function assertStellarWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Stellar; wallet must be { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Stellar; an EVM wallet can't be used \u2014 pass { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Stellar; that looks like a Solana/TON wallet \u2014 pass { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  if (!("secret" in wallet) && !("keypair" in wallet)) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Stellar; wallet must be { secret } (S\u2026 seed) or { keypair }.`
+    );
+  }
+  return wallet;
+}
+function resolveStellarWallet(config) {
+  if (config.keypair) return config.keypair;
+  if (config.secret) {
+    if (!_stellarsdk.StrKey.isValidEd25519SecretSeed(config.secret)) {
+      throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+        "Stellar wallet { secret } is not a valid S\u2026 secret seed."
+      );
+    }
+    return _stellarsdk.Keypair.fromSecret(config.secret);
+  }
+  throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)("Stellar wallet needs { secret } (S\u2026 seed) or { keypair }.");
+}
+
+// src/drivers/stellar/index.ts
+var stellarDriver = {
+  family: "stellar",
+  resolve(opts) {
+    if (opts.chain !== "stellar") return null;
+    const rpcUrl = _nullishCoalesce(opts.rpcUrl, () => ( STELLAR_MAINNET.defaultRpc));
+    return makeStellarNetwork(STELLAR_MAINNET, rpcUrl);
+  }
+};
+function makeStellarNetwork(preset, rpcUrl) {
+  const server = new _stellarsdk.Horizon.Server(rpcUrl);
+  const network = preset.caip2;
+  const reader = {
+    async transactionsForAccount(account, limit) {
+      const page = await server.transactions().forAccount(account).order("desc").limit(limit).includeFailed(true).call();
+      return page.records.map((r) => ({
+        hash: r.hash,
+        successful: r.successful,
+        memo: r.memo,
+        memo_type: r.memo_type,
+        created_at: r.created_at
+      }));
+    },
+    async paymentsForTransaction(txHash) {
+      const page = await server.payments().forTransaction(txHash).limit(100).call();
+      return page.records.filter((r) => r.type === "payment").map((r) => ({
+        type: r.type,
+        from: r.from,
+        to: r.to,
+        asset_type: r.asset_type,
+        asset_code: r.asset_code,
+        asset_issuer: r.asset_issuer,
+        amount: r.amount
+      }));
+    }
+  };
+  return {
+    family: "stellar",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: STELLAR_DECIMALS, symbol: XLM_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, _chunkWQWNPAYQcjs.UnknownTokenError)(
+            `token "${token}" isn't built in for Stellar (known: ${known}). Pass { issuer, code, decimals } for a custom asset, or use 'native'.`
+          );
+        }
+        return {
+          asset: stellarAssetId(info.code, info.issuer),
+          decimals: info.decimals,
+          symbol: info.symbol
+        };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "stellar", network);
+      const t = token;
+      if (!t.issuer || !t.code || typeof t.decimals !== "number") {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Stellar; a custom token must be { issuer, code, decimals }.`
+        );
+      }
+      return {
+        asset: stellarAssetId(t.code, t.issuer),
+        decimals: t.decimals,
+        symbol: _nullishCoalesce(t.symbol, () => ( t.code))
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: XLM_SYMBOL, decimals: STELLAR_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (stellarAssetId(info.code, info.issuer) === asset) {
+          return { symbol: info.symbol, decimals: info.decimals };
+        }
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Stellar, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!_stellarsdk.StrKey.isValidEd25519PublicKey(payTo)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Stellar, but payTo "${payTo}" is not a valid Stellar account (G\u2026).`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertStellarWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const keypair = resolveStellarWallet(wallet._native);
+      return payStellar({ server, keypair, accept });
+    },
+    async confirm(ref) {
+      for (let i = 0; i < 10; i += 1) {
+        try {
+          const tx = await server.transactions().transaction(ref).call();
+          return { height: String(_nullishCoalesce(_nullishCoalesce(tx.ledger_attr, () => ( tx.ledger)), () => ( 0))) };
+        } catch (e5) {
+          await _chunkCQREG5LEcjs.delay.call(void 0, 1500);
+        }
+      }
+      throw new (0, _chunkWQWNPAYQcjs.ConfirmationTimeoutError)(`Stellar tx ${ref} not visible on Horizon in time.`);
+    },
+    async estimateCost() {
+      return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+        symbol: XLM_SYMBOL,
+        decimals: STELLAR_DECIMALS,
+        fee: 100n,
+        basis: "heuristic",
+        detail: "base fee 100 stroops (1 operation)"
+      });
+    },
+    async verify(_ref, accept) {
+      return verifyStellar({ reader, accept });
+    }
+  };
+}
+
+
+exports.stellarDriver = stellarDriver;