@piprail/sdk 1.3.0 → 1.4.0

package/dist/algorand-XJ5OVWQB.js

@@ -0,0 +1,363 @@
+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 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
+};

package/dist/{aptos-MQY7KOOJ.js → aptos-AWWSCPDH.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";
@@ -37,6 +37,7 @@ var APTOS_MAINNET = {
 };
 
 // src/drivers/aptos/pay.ts
+var MAX_GAS_AMOUNT = 5e4;
 async function payAptos(params) {
   const { client, signer, sender, accept } = params;
   const metadata = accept.asset === "native" ? APT_FA_METADATA : accept.asset;
@@ -48,7 +49,8 @@ async function payAptos(params) {
         typeArguments: ["0x1::fungible_asset::Metadata"],
         // u64 amount goes as a base-unit string; the FA metadata object + recipient are addresses.
         functionArguments: [metadata, accept.payTo, accept.amount]
-      }
+      },
+      options: { maxGasAmount: MAX_GAS_AMOUNT }
     });
     const res = await client.signSubmit({ signer, transaction });
     return res.hash;
@@ -227,7 +229,8 @@ function makeAptosNetwork(preset, rpcUrl) {
     build: (input) => aptos.transaction.build.simple({
       sender: input.sender,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      data: input.data
+      data: input.data,
+      ...input.options ? { options: input.options } : {}
     }),
     signSubmit: (input) => aptos.signAndSubmitTransaction({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/{aptos-T3MNKUPB.cjs → aptos-TPSOQ2VL.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');
@@ -37,6 +37,7 @@ var APTOS_MAINNET = {
 };
 
 // src/drivers/aptos/pay.ts
+var MAX_GAS_AMOUNT = 5e4;
 async function payAptos(params) {
   const { client, signer, sender, accept } = params;
   const metadata = accept.asset === "native" ? APT_FA_METADATA : accept.asset;
@@ -48,19 +49,20 @@ async function payAptos(params) {
         typeArguments: ["0x1::fungible_asset::Metadata"],
         // u64 amount goes as a base-unit string; the FA metadata object + recipient are addresses.
         functionArguments: [metadata, accept.payTo, accept.amount]
-      }
+      },
+      options: { maxGasAmount: MAX_GAS_AMOUNT }
     });
     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) {
@@ -144,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 }.`
     );
   }
@@ -171,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
@@ -227,7 +229,8 @@ function makeAptosNetwork(preset, rpcUrl) {
     build: (input) => aptos.transaction.build.simple({
       sender: input.sender,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      data: input.data
+      data: input.data,
+      ...input.options ? { options: input.options } : {}
     }),
     signSubmit: (input) => aptos.signAndSubmitTransaction({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -248,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 }.`
         );
       }
@@ -284,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).`
         );
       }
@@ -306,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,

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];