@piprail/sdk 1.3.1 → 1.5.0

package/dist/algorand-IJJKE35X.cjs

@@ -0,0 +1,397 @@
+"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 _chunkIQGT65WScjs = require('./chunk-IQGT65WS.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(_chunkIQGT65WScjs.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, _chunkIQGT65WScjs.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, _chunkIQGT65WScjs.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, _chunkIQGT65WScjs.WrongFamilyError)(
+      `chain ${network} is Algorand; wallet must be { mnemonic } (25 words) or { account }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new (0, _chunkIQGT65WScjs.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 (0, _chunkIQGT65WScjs.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 (0, _chunkIQGT65WScjs.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 } = _algosdk2.default.mnemonicToSecretKey(config.mnemonic);
+      return { addr: addr.toString(), sk };
+    } catch (cause) {
+      throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
+        "Algorand wallet { mnemonic } is not a valid 25-word Algorand mnemonic.",
+        { cause }
+      );
+    }
+  }
+  throw new (0, _chunkIQGT65WScjs.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 = _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, _chunkIQGT65WScjs.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 };
+      }
+      _chunkIQGT65WScjs.rejectForeignToken.call(void 0, token, "algorand", network);
+      const t = token;
+      if (typeof t.assetId !== "number" || typeof t.decimals !== "number") {
+        throw new (0, _chunkIQGT65WScjs.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, _chunkIQGT65WScjs.WrongFamilyError)(
+          `chain ${network} is Algorand, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!_algosdk2.default.isValidAddress(payTo)) {
+        throw new (0, _chunkIQGT65WScjs.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, _chunkIQGT65WScjs.ConfirmationTimeoutError)(`Algorand tx ${ref} did not confirm in time.`, {
+          cause: err
+        });
+      }
+    },
+    async estimateCost() {
+      return _chunkIQGT65WScjs.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;

package/dist/{aptos-MKZ5MAGL.cjs → aptos-X3G2UBYW.cjs}

@@ -6,7 +6,7 @@
 
 
 
-var _chunkYJPWIK5Lcjs = require('./chunk-YJPWIK5L.cjs');
+var _chunkIQGT65WScjs = require('./chunk-IQGT65WS.cjs');
 
 // src/drivers/aptos/index.ts
 var _tssdk = require('@aptos-labs/ts-sdk');
@@ -55,14 +55,14 @@ async function payAptos(params) {
     const res = await client.signSubmit({ signer, transaction });
     return res.hash;
   } catch (err) {
-    if (err instanceof _chunkYJPWIK5Lcjs.InsufficientFundsError) throw err;
+    if (err instanceof _chunkIQGT65WScjs.InsufficientFundsError) throw err;
     if (isAptosAffordability(err)) {
-      throw new (0, _chunkYJPWIK5Lcjs.InsufficientFundsError)(
+      throw new (0, _chunkIQGT65WScjs.InsufficientFundsError)(
         err instanceof Error ? err.message : "Insufficient APT/token balance for the payment.",
         { cause: err }
       );
     }
-    throw _nullishCoalesce(_chunkYJPWIK5Lcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    throw _nullishCoalesce(_chunkIQGT65WScjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 function isAptosAffordability(err) {
@@ -146,22 +146,22 @@ function txNotFound(hash) {
 
 function assertAptosWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+    throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
       `chain ${network} is Aptos; wallet must be { privateKey } (ed25519-priv-0x\u2026) or { account }.`
     );
   }
   if ("walletClient" in wallet) {
-    throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+    throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
       `chain ${network} is Aptos; a viem { walletClient } can't be used \u2014 pass { privateKey } (ed25519-priv-0x\u2026) or { account }.`
     );
   }
   if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keypair" in wallet || "keyPair" in wallet || "secret" in wallet || "seed" in wallet || "accountId" in wallet) {
-    throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+    throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
       `chain ${network} is Aptos; that looks like another family's wallet \u2014 pass { privateKey } (ed25519-priv-0x\u2026) or { account }.`
     );
   }
   if (!("privateKey" in wallet) && !("account" in wallet)) {
-    throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+    throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
       `chain ${network} is Aptos; wallet must be { privateKey } (ed25519-priv-0x\u2026) or { account }.`
     );
   }
@@ -173,13 +173,13 @@ function resolveAptosAccount(config) {
     try {
       return _tssdk.Account.fromPrivateKey({ privateKey: new (0, _tssdk.Ed25519PrivateKey)(config.privateKey) });
     } catch (cause) {
-      throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+      throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
         "Aptos wallet { privateKey } is not a valid ed25519 secret (ed25519-priv-0x\u2026 or 0x\u2026 hex).",
         { cause }
       );
     }
   }
-  throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)("Aptos wallet needs { privateKey } (ed25519-priv-0x\u2026) or { account }.");
+  throw new (0, _chunkIQGT65WScjs.WrongFamilyError)("Aptos wallet needs { privateKey } (ed25519-priv-0x\u2026) or { account }.");
 }
 
 // src/drivers/aptos/index.ts
@@ -251,16 +251,16 @@ function makeAptosNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkYJPWIK5Lcjs.UnknownTokenError)(
+          throw new (0, _chunkIQGT65WScjs.UnknownTokenError)(
             `token "${token}" isn't built in for Aptos (known: ${known}). Pass { metadata, decimals } for a custom Fungible Asset, or use 'native'.`
           );
         }
         return { asset: info.metadata, decimals: info.decimals, symbol: info.symbol };
       }
-      _chunkYJPWIK5Lcjs.rejectForeignToken.call(void 0, token, "aptos", network);
+      _chunkIQGT65WScjs.rejectForeignToken.call(void 0, token, "aptos", network);
       const t = token;
       if (!t.metadata || typeof t.decimals !== "number") {
-        throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+        throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
           `chain ${network} is Aptos; a custom token must be { metadata, decimals }.`
         );
       }
@@ -287,7 +287,7 @@ function makeAptosNetwork(preset, rpcUrl) {
         valid = false;
       }
       if (!valid || evmLike) {
-        throw new (0, _chunkYJPWIK5Lcjs.WrongFamilyError)(
+        throw new (0, _chunkIQGT65WScjs.WrongFamilyError)(
           `chain ${network} is Aptos, but payTo "${payTo}" is not a valid Aptos address (0x + 32 bytes).`
         );
       }
@@ -309,11 +309,11 @@ function makeAptosNetwork(preset, rpcUrl) {
         const tx = await aptos.waitForTransaction({ transactionHash: ref });
         return { height: String(_nullishCoalesce(tx.version, () => ( "0"))) };
       } catch (err) {
-        throw new (0, _chunkYJPWIK5Lcjs.ConfirmationTimeoutError)(`Aptos tx ${ref} did not finalize in time.`, { cause: err });
+        throw new (0, _chunkIQGT65WScjs.ConfirmationTimeoutError)(`Aptos tx ${ref} did not finalize in time.`, { cause: err });
       }
     },
     async estimateCost() {
-      return _chunkYJPWIK5Lcjs.nativeCost.call(void 0, {
+      return _chunkIQGT65WScjs.nativeCost.call(void 0, {
         symbol: APT_SYMBOL,
         decimals: APT_DECIMALS,
         fee: 100000n,
@@ -322,6 +322,34 @@ function makeAptosNetwork(preset, rpcUrl) {
         detail: "\u22480.001 APT (a simple Fungible-Asset transfer; Aptos gas is sub-cent)"
       });
     },
+    async balanceOf(wallet, asset) {
+      let owner;
+      try {
+        owner = resolveAptosAccount(wallet._native).accountAddress.toString();
+      } catch (e7) {
+        return { token: null, native: null };
+      }
+      const native = await aptos.getAccountAPTAmount({ accountAddress: owner }).then((n) => BigInt(n)).catch(() => null);
+      if (asset === "native") return { token: native, native };
+      let token = null;
+      try {
+        const [bal] = await aptos.view({
+          payload: {
+            function: "0x1::primary_fungible_store::balance",
+            typeArguments: ["0x1::fungible_asset::Metadata"],
+            functionArguments: [owner, asset]
+          }
+        });
+        token = BigInt(String(bal));
+      } catch (e8) {
+        token = null;
+      }
+      return { token, native };
+    },
+    // No receive prerequisite — the recipient's primary FA store auto-creates on receipt.
+    async recipientReady() {
+      return { ready: "n/a" };
+    },
     async verify(ref, accept) {
       return verifyAptos({ reader, hash: ref, accept });
     }

package/dist/{aptos-DTAONNMM.js → aptos-YQWTGFRZ.js}

@@ -6,7 +6,7 @@ import {
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-AGKC3C7Y.js";
+} from "./chunk-QDS6FBZP.js";
 
 // src/drivers/aptos/index.ts
 import { Aptos, AptosConfig, Network, AccountAddress } from "@aptos-labs/ts-sdk";
@@ -322,6 +322,34 @@ function makeAptosNetwork(preset, rpcUrl) {
         detail: "\u22480.001 APT (a simple Fungible-Asset transfer; Aptos gas is sub-cent)"
       });
     },
+    async balanceOf(wallet, asset) {
+      let owner;
+      try {
+        owner = resolveAptosAccount(wallet._native).accountAddress.toString();
+      } catch {
+        return { token: null, native: null };
+      }
+      const native = await aptos.getAccountAPTAmount({ accountAddress: owner }).then((n) => BigInt(n)).catch(() => null);
+      if (asset === "native") return { token: native, native };
+      let token = null;
+      try {
+        const [bal] = await aptos.view({
+          payload: {
+            function: "0x1::primary_fungible_store::balance",
+            typeArguments: ["0x1::fungible_asset::Metadata"],
+            functionArguments: [owner, asset]
+          }
+        });
+        token = BigInt(String(bal));
+      } catch {
+        token = null;
+      }
+      return { token, native };
+    },
+    // No receive prerequisite — the recipient's primary FA store auto-creates on receipt.
+    async recipientReady() {
+      return { ready: "n/a" };
+    },
     async verify(ref, accept) {
       return verifyAptos({ reader, hash: ref, accept });
     }

package/dist/{chunk-YJPWIK5L.cjs → chunk-IQGT65WS.cjs}

@@ -82,7 +82,8 @@ var FAMILY_LABEL = {
   tron: "Tron",
   sui: "Sui",
   near: "NEAR",
-  aptos: "Aptos"
+  aptos: "Aptos",
+  algorand: "Algorand"
 };
 var FAMILY_TOKEN = {
   evm: { key: "address", shape: "{ address }", hint: "{ address, decimals }" },
@@ -93,7 +94,8 @@ var FAMILY_TOKEN = {
   tron: { key: "address", shape: "{ address }", hint: "{ address, decimals }" },
   sui: { key: "coinType", shape: "{ coinType }", hint: "{ coinType, decimals }" },
   near: { key: "contractId", shape: "{ contractId }", hint: "{ contractId, decimals }" },
-  aptos: { key: "metadata", shape: "{ metadata }", hint: "{ metadata, decimals }" }
+  aptos: { key: "metadata", shape: "{ metadata }", hint: "{ metadata, decimals }" },
+  algorand: { key: "assetId", shape: "{ assetId }", hint: "{ assetId, decimals }" }
 };
 function rejectForeignToken(token, family, network) {
   const own = FAMILY_TOKEN[family];

package/dist/{chunk-AGKC3C7Y.js → chunk-QDS6FBZP.js}

@@ -82,7 +82,8 @@ var FAMILY_LABEL = {
   tron: "Tron",
   sui: "Sui",
   near: "NEAR",
-  aptos: "Aptos"
+  aptos: "Aptos",
+  algorand: "Algorand"
 };
 var FAMILY_TOKEN = {
   evm: { key: "address", shape: "{ address }", hint: "{ address, decimals }" },
@@ -93,7 +94,8 @@ var FAMILY_TOKEN = {
   tron: { key: "address", shape: "{ address }", hint: "{ address, decimals }" },
   sui: { key: "coinType", shape: "{ coinType }", hint: "{ coinType, decimals }" },
   near: { key: "contractId", shape: "{ contractId }", hint: "{ contractId, decimals }" },
-  aptos: { key: "metadata", shape: "{ metadata }", hint: "{ metadata, decimals }" }
+  aptos: { key: "metadata", shape: "{ metadata }", hint: "{ metadata, decimals }" },
+  algorand: { key: "assetId", shape: "{ assetId }", hint: "{ assetId, decimals }" }
 };
 function rejectForeignToken(token, family, network) {
   const own = FAMILY_TOKEN[family];