@talken/talkenkit 2.8.4 → 2.8.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (99) hide show
  1. package/dist/{AbcCredentialManager-QM2BNLSR.js → AbcCredentialManager-WZBF3GHF.js} +1 -1
  2. package/dist/{abcWallet-4PXYWHYM.js → abcWallet-EOHU5AIB.js} +2 -2
  3. package/dist/{chunk-PS5CBMY5.js → chunk-CUPPBGFC.js} +13 -6
  4. package/dist/{chunk-ZISAJ7BZ.js → chunk-WGSS57V6.js} +998 -453
  5. package/dist/config/networks.d.ts +12 -0
  6. package/dist/gasless/utils/revokeDelegation.d.ts +4 -3
  7. package/dist/index.js +27 -21
  8. package/dist/utils/amount.d.ts +17 -0
  9. package/dist/wallets/walletConnectors/abcWallet/AbcCredentialManager.js +3 -3
  10. package/dist/wallets/walletConnectors/abcWallet/AbcEvmAutoConnector.js +4 -4
  11. package/dist/wallets/walletConnectors/abcWallet/ProviderError.d.ts +7 -0
  12. package/dist/wallets/walletConnectors/abcWallet/StorageService.js +2 -2
  13. package/dist/wallets/walletConnectors/abcWallet/abcBitcoinConnector.js +5 -5
  14. package/dist/wallets/walletConnectors/abcWallet/abcBitcoinProvider.js +13 -4
  15. package/dist/wallets/walletConnectors/abcWallet/abcConnector.js +19 -18
  16. package/dist/wallets/walletConnectors/abcWallet/abcProvider.d.ts +3 -4
  17. package/dist/wallets/walletConnectors/abcWallet/abcProvider.js +9 -6
  18. package/dist/wallets/walletConnectors/abcWallet/abcSolanaProvider.js +21 -19
  19. package/dist/wallets/walletConnectors/abcWallet/abcSolanaWalletAdapter.js +3 -3
  20. package/dist/wallets/walletConnectors/abcWallet/abcTronProvider.d.ts +1 -1
  21. package/dist/wallets/walletConnectors/abcWallet/abcTronProvider.js +13 -4
  22. package/dist/wallets/walletConnectors/abcWallet/abcWallet.js +20 -19
  23. package/dist/wallets/walletConnectors/abcWallet/abcXrplProvider.d.ts +18 -1
  24. package/dist/wallets/walletConnectors/abcWallet/abcXrplProvider.js +17 -6
  25. package/dist/wallets/walletConnectors/abcWallet/api/ConfigApi.js +2 -2
  26. package/dist/wallets/walletConnectors/abcWallet/api/TalkenApiClient.js +16 -15
  27. package/dist/wallets/walletConnectors/abcWallet/api/TokenApi.js +2 -2
  28. package/dist/wallets/walletConnectors/abcWallet/api/WalletscanApi.js +3 -3
  29. package/dist/wallets/walletConnectors/abcWallet/api/index.js +21 -20
  30. package/dist/wallets/walletConnectors/abcWallet/api/modules/auth.js +3 -3
  31. package/dist/wallets/walletConnectors/abcWallet/api/modules/bitcoin.d.ts +16 -2
  32. package/dist/wallets/walletConnectors/abcWallet/api/modules/bitcoin.js +9 -8
  33. package/dist/wallets/walletConnectors/abcWallet/api/modules/evm.d.ts +19 -3
  34. package/dist/wallets/walletConnectors/abcWallet/api/modules/evm.js +8 -7
  35. package/dist/wallets/walletConnectors/abcWallet/api/modules/executeBodies.d.ts +79 -0
  36. package/dist/wallets/walletConnectors/abcWallet/api/modules/executeBodies.js +32 -0
  37. package/dist/wallets/walletConnectors/abcWallet/api/modules/signBodies.d.ts +4 -1
  38. package/dist/wallets/walletConnectors/abcWallet/api/modules/signBodies.js +6 -2
  39. package/dist/wallets/walletConnectors/abcWallet/api/modules/signingRefresh.d.ts +6 -2
  40. package/dist/wallets/walletConnectors/abcWallet/api/modules/signingRefresh.js +5 -5
  41. package/dist/wallets/walletConnectors/abcWallet/api/modules/solana.d.ts +9 -3
  42. package/dist/wallets/walletConnectors/abcWallet/api/modules/solana.js +5 -4
  43. package/dist/wallets/walletConnectors/abcWallet/api/modules/tron.d.ts +10 -4
  44. package/dist/wallets/walletConnectors/abcWallet/api/modules/tron.js +13 -2
  45. package/dist/wallets/walletConnectors/abcWallet/api/modules/wallet.js +2 -2
  46. package/dist/wallets/walletConnectors/abcWallet/api/modules/walletscan.js +2 -2
  47. package/dist/wallets/walletConnectors/abcWallet/api/modules/xrp.d.ts +13 -3
  48. package/dist/wallets/walletConnectors/abcWallet/api/modules/xrp.js +13 -2
  49. package/dist/wallets/walletConnectors/abcWallet/constants.d.ts +17 -5
  50. package/dist/wallets/walletConnectors/abcWallet/constants.js +3 -1
  51. package/dist/wallets/walletConnectors/abcWallet/index.js +36 -34
  52. package/dist/wallets/walletConnectors/abcWallet/sendFailure.d.ts +10 -0
  53. package/dist/wallets/walletConnectors/abcWallet/sendFailure.js +7 -0
  54. package/dist/wallets/walletConnectors/abcWallet/sessionUtils.js +3 -3
  55. package/dist/wallets/walletConnectors/abcWallet/types/api.types.d.ts +76 -1
  56. package/dist/wallets/walletConnectors/abcWallet/types/config.types.d.ts +4 -0
  57. package/dist/wallets/walletConnectors/abcWallet/types/error.types.d.ts +14 -1
  58. package/dist/wallets/walletConnectors/abcWallet/types/error.types.js +1 -1
  59. package/dist/wallets/walletConnectors/abcWallet/types.js +5 -5
  60. package/dist/wallets/walletConnectors/abcWallet/utils.js +4 -4
  61. package/dist/wallets/walletConnectors/abcWallet/walletGeneration.js +5 -5
  62. package/dist/wallets/walletConnectors/{chunk-KX3IFHJQ.js → chunk-2M6E3YXU.js} +28 -16
  63. package/dist/wallets/walletConnectors/{chunk-DPYQH3WE.js → chunk-365TL36N.js} +36 -31
  64. package/dist/wallets/walletConnectors/{chunk-CCUNTMLD.js → chunk-4CKIGJZD.js} +8 -8
  65. package/dist/wallets/walletConnectors/{chunk-XQTK7NGN.js → chunk-5SRSGEZR.js} +2 -2
  66. package/dist/wallets/walletConnectors/{chunk-HFW2XV2R.js → chunk-6MZWQBNQ.js} +28 -7
  67. package/dist/wallets/walletConnectors/chunk-6X2XITQP.js +71 -0
  68. package/dist/wallets/walletConnectors/{chunk-F6EG7H2O.js → chunk-743DKBGG.js} +2 -2
  69. package/dist/wallets/walletConnectors/chunk-DFG3BSSC.js +341 -0
  70. package/dist/wallets/walletConnectors/{chunk-ZTIRW7TR.js → chunk-DKMR2ML5.js} +3 -1
  71. package/dist/wallets/walletConnectors/{chunk-TXB6KXPR.js → chunk-DRL2CDHT.js} +24 -22
  72. package/dist/wallets/walletConnectors/{chunk-HXYOWG5P.js → chunk-EGLT3GPM.js} +1 -1
  73. package/dist/wallets/walletConnectors/{chunk-YECMDMEA.js → chunk-F4JUKZBB.js} +3 -3
  74. package/dist/wallets/walletConnectors/chunk-GAJ4FJTW.js +382 -0
  75. package/dist/wallets/walletConnectors/{chunk-UNLWNVSN.js → chunk-GO6HUJTP.js} +39 -10
  76. package/dist/wallets/walletConnectors/{chunk-5E7TNMON.js → chunk-HMIFFMGK.js} +18 -7
  77. package/dist/wallets/walletConnectors/chunk-M4SNNQU2.js +56 -0
  78. package/dist/wallets/walletConnectors/{chunk-6LPMWYFM.js → chunk-MNGSJBPX.js} +31 -14
  79. package/dist/wallets/walletConnectors/{chunk-6HR6CEOY.js → chunk-OMZSFUVN.js} +1 -1
  80. package/dist/wallets/walletConnectors/{chunk-75H6DQT6.js → chunk-OTLPTGHO.js} +1 -1
  81. package/dist/wallets/walletConnectors/{chunk-OEZE4GBQ.js → chunk-P64PMEPU.js} +2 -2
  82. package/dist/wallets/walletConnectors/{chunk-F6AHT6K4.js → chunk-PL56SINL.js} +1 -1
  83. package/dist/wallets/walletConnectors/{chunk-YUBS7MJ6.js → chunk-RSR35XOZ.js} +47 -12
  84. package/dist/wallets/walletConnectors/{chunk-5SHN7JNR.js → chunk-SORKIBWX.js} +1 -1
  85. package/dist/wallets/walletConnectors/{chunk-CIAVEXOY.js → chunk-SUPFF4EQ.js} +37 -811
  86. package/dist/wallets/walletConnectors/{chunk-BUAWEYGV.js → chunk-TP4BDK7W.js} +5 -1
  87. package/dist/wallets/walletConnectors/{chunk-FWKMNVWU.js → chunk-TRFREYPH.js} +1 -1
  88. package/dist/wallets/walletConnectors/{chunk-RQYBKCWA.js → chunk-UHVJ6AF6.js} +1 -1
  89. package/dist/wallets/walletConnectors/{chunk-ZITVWA4X.js → chunk-V6R6WDOQ.js} +1 -1
  90. package/dist/wallets/walletConnectors/chunk-XGQUYXTL.js +1215 -0
  91. package/dist/wallets/walletConnectors/{chunk-7GBAUSQJ.js → chunk-XPZCOEQL.js} +13 -6
  92. package/dist/wallets/walletConnectors/{chunk-QTBJ6WNZ.js → chunk-YPMD3ZHF.js} +33 -18
  93. package/dist/wallets/walletConnectors/chunk-Z66ETAKN.js +20 -0
  94. package/dist/wallets/walletConnectors/{chunk-HMMEOZDT.js → chunk-ZBI7MSWF.js} +5 -5
  95. package/dist/wallets/walletConnectors/chunk-ZWIAZOVB.js +58 -0
  96. package/dist/wallets/walletConnectors/index.js +51 -50
  97. package/package.json +1 -1
  98. package/dist/wallets/walletConnectors/chunk-6BHMNR5X.js +0 -46
  99. package/dist/wallets/walletConnectors/chunk-FLBJ7T4Q.js +0 -44
@@ -7,6 +7,7 @@ import {
7
7
  ABC_WALLET_METADATA,
8
8
  DEFAULT_TALKEN_API_CONFIG,
9
9
  PIN_CONFIG,
10
+ SEND_REQUEST_TIMEOUT,
10
11
  STORAGE_NS,
11
12
  TALKEN_API_ENDPOINTS,
12
13
  TOKEN_EXPIRY,
@@ -18,7 +19,7 @@ import {
18
19
  remove,
19
20
  set,
20
21
  setJSON
21
- } from "./chunk-PS5CBMY5.js";
22
+ } from "./chunk-CUPPBGFC.js";
22
23
 
23
24
  // src/wallets/walletConnectors/abcWallet/abcWallet.ts
24
25
  import { setTalkenApiClient as setTalkenApiClient2 } from "@talken/talkenkit";
@@ -943,6 +944,25 @@ function networkNameToChainKey(network) {
943
944
  return network;
944
945
  return CHAIN_ID_TO_KEY[chainId] ?? network;
945
946
  }
947
+ function getNetworkType(network) {
948
+ const byParam = NETWORK_BY_PARAM[network];
949
+ if (byParam)
950
+ return byParam.type;
951
+ const nonEvmParam = Object.keys(NON_EVM_CHAIN_KEY).find(
952
+ (param) => NON_EVM_CHAIN_KEY[param] === network
953
+ );
954
+ if (nonEvmParam)
955
+ return NETWORK_BY_PARAM[nonEvmParam]?.type ?? "Non-EVM" /* NON_EVM */;
956
+ if (Object.values(CHAIN_ID_TO_KEY).includes(network))
957
+ return "EVM" /* EVM */;
958
+ return void 0;
959
+ }
960
+ function getEvmChainKey(network) {
961
+ const chainId = NETWORK_BY_PARAM[network]?.chainId;
962
+ if (chainId != null)
963
+ return CHAIN_ID_TO_KEY[chainId];
964
+ return Object.values(CHAIN_ID_TO_KEY).includes(network) ? network : void 0;
965
+ }
946
966
  function networkToChainId(network) {
947
967
  return NETWORK_BY_PARAM[network]?.chainId;
948
968
  }
@@ -1481,29 +1501,614 @@ var GaslessFeeService = class {
1481
1501
  return "0";
1482
1502
  }
1483
1503
  }
1484
- buildEstimate(feeToken, feeAmount, feeAmountRaw, gaslessMode) {
1485
- return { feeToken, feeAmount, feeAmountRaw, gaslessMode };
1504
+ buildEstimate(feeToken, feeAmount, feeAmountRaw, gaslessMode) {
1505
+ return { feeToken, feeAmount, feeAmountRaw, gaslessMode };
1506
+ }
1507
+ };
1508
+ var _sharedInstance = null;
1509
+ function getSharedGaslessFeeService() {
1510
+ if (!_sharedInstance) {
1511
+ _sharedInstance = new GaslessFeeService();
1512
+ }
1513
+ return _sharedInstance;
1514
+ }
1515
+
1516
+ // src/gasless/services/GaslessTransferService.ts
1517
+ import { encodeFunctionData, erc20Abi, isAddress as isAddress2 } from "viem";
1518
+
1519
+ // src/gasless/utils/revokeDelegation.ts
1520
+ import {
1521
+ isAddress,
1522
+ keccak256,
1523
+ recoverAddress,
1524
+ toHex,
1525
+ toRlp
1526
+ } from "viem";
1527
+
1528
+ // src/utils/amount.ts
1529
+ var MAX_DECIMALS = 255;
1530
+ var U64_MAX = BigInt("18446744073709551615");
1531
+ var ZERO = BigInt(0);
1532
+ var TEN = BigInt(10);
1533
+ var CANONICAL_DECIMAL = /^(0|[1-9]\d*)(\.\d+)?$/;
1534
+ var BASE_UNIT_INTEGER = /^(0|[1-9]\d*)$/;
1535
+ function validateAmount(amount) {
1536
+ if (typeof amount === "string") {
1537
+ if (!CANONICAL_DECIMAL.test(amount))
1538
+ throw new Error(
1539
+ "Token amount must be a plain decimal string (no sign, exponent or separators)"
1540
+ );
1541
+ if (!/[1-9]/.test(amount))
1542
+ throw new Error("Token amount must be finite and positive");
1543
+ return;
1544
+ }
1545
+ if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0)
1546
+ throw new Error("Token amount must be finite and positive");
1547
+ }
1548
+ function isValidDecimals(decimals) {
1549
+ return decimals !== void 0 && Number.isInteger(decimals) && decimals >= 0 && decimals <= MAX_DECIMALS;
1550
+ }
1551
+ function assertDecimals(decimals) {
1552
+ if (!isValidDecimals(decimals))
1553
+ throw new Error("Token decimals are missing or invalid");
1554
+ }
1555
+ function splitAmount(amount) {
1556
+ const [coefficient, exponent = "0"] = String(amount).toLowerCase().split("e");
1557
+ const [whole, fraction = ""] = coefficient.split(".");
1558
+ return {
1559
+ digits: BigInt(`${whole}${fraction}`),
1560
+ fractionLength: fraction.length,
1561
+ exponent: Number(exponent)
1562
+ };
1563
+ }
1564
+ function toBaseUnits(amount, decimals) {
1565
+ validateAmount(amount);
1566
+ assertDecimals(decimals);
1567
+ const { digits, fractionLength, exponent } = splitAmount(amount);
1568
+ if (typeof amount === "string" && fractionLength > decimals)
1569
+ throw new Error(
1570
+ `Token amount exceeds decimal precision (${decimals} decimals)`
1571
+ );
1572
+ const scale = decimals + exponent - fractionLength;
1573
+ if (scale >= 0)
1574
+ return digits * TEN ** BigInt(scale);
1575
+ const divisor = TEN ** BigInt(-scale);
1576
+ if (digits % divisor !== ZERO)
1577
+ throw new Error(
1578
+ `Token amount exceeds decimal precision (${decimals} decimals)`
1579
+ );
1580
+ return digits / divisor;
1581
+ }
1582
+ function toDecimalAmount(baseUnits, decimals) {
1583
+ assertDecimals(decimals);
1584
+ if (typeof baseUnits === "string" && !BASE_UNIT_INTEGER.test(baseUnits))
1585
+ throw new Error("Base-unit amount must be a non-negative integer string");
1586
+ const value = BigInt(baseUnits);
1587
+ if (value <= ZERO)
1588
+ throw new Error("Token amount must be finite and positive");
1589
+ const unit = TEN ** BigInt(decimals);
1590
+ const whole = value / unit;
1591
+ const fraction = (value % unit).toString().padStart(decimals, "0").replace(/0+$/, "");
1592
+ return fraction ? `${whole}.${fraction}` : whole.toString();
1593
+ }
1594
+ function toSplRawAmount(amount, decimals) {
1595
+ validateAmount(amount);
1596
+ if (!isValidDecimals(decimals))
1597
+ throw new Error("SPL token decimals are missing or invalid");
1598
+ const raw = toBaseUnits(amount, decimals);
1599
+ if (raw > U64_MAX)
1600
+ throw new Error("Token amount is outside the SPL u64 range");
1601
+ return raw;
1602
+ }
1603
+
1604
+ // src/wallets/walletConnectors/abcWallet/types/error.types.ts
1605
+ var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode3) => {
1606
+ AbcErrorCode3["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
1607
+ AbcErrorCode3["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
1608
+ AbcErrorCode3["WALLET_NOT_FOUND"] = "WALLET_NOT_FOUND";
1609
+ AbcErrorCode3["INVALID_PIN"] = "INVALID_PIN";
1610
+ AbcErrorCode3["NETWORK_ERROR"] = "NETWORK_ERROR";
1611
+ AbcErrorCode3["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
1612
+ AbcErrorCode3["USER_CANCELLED"] = "USER_CANCELLED";
1613
+ AbcErrorCode3["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
1614
+ return AbcErrorCode3;
1615
+ })(AbcErrorCode || {});
1616
+ var AbcError = class extends Error {
1617
+ constructor(code, message, details, statusCode) {
1618
+ super(message);
1619
+ this.name = "AbcError";
1620
+ this.code = code;
1621
+ this.details = details;
1622
+ this.statusCode = statusCode;
1623
+ }
1624
+ };
1625
+ var TalkenApiError = class extends Error {
1626
+ constructor(code, message, statusCode, details, outcome) {
1627
+ super(message);
1628
+ this.name = "TalkenApiError";
1629
+ this.code = code;
1630
+ this.statusCode = statusCode;
1631
+ this.details = details;
1632
+ if (outcome?.retryable !== void 0)
1633
+ this.retryable = outcome.retryable;
1634
+ if (outcome?.possibleTxHash !== void 0)
1635
+ this.possibleTxHash = outcome.possibleTxHash;
1636
+ }
1637
+ };
1638
+
1639
+ // src/wallets/walletConnectors/abcWallet/types/config.types.ts
1640
+ var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
1641
+ AbcStorageKey2["USER"] = "user";
1642
+ AbcStorageKey2["WALLET"] = "wallet";
1643
+ AbcStorageKey2["SOLANA_WALLET"] = "solana_wallet";
1644
+ AbcStorageKey2["BITCOIN_WALLET"] = "bitcoin_wallet";
1645
+ AbcStorageKey2["TRON_WALLET"] = "tron_wallet";
1646
+ AbcStorageKey2["XRPL_WALLET"] = "xrpl_wallet";
1647
+ AbcStorageKey2["ACCESS_TOKEN"] = "access_token";
1648
+ AbcStorageKey2["REFRESH_TOKEN"] = "refresh_token";
1649
+ AbcStorageKey2["EXPIRES_AT"] = "expires_at";
1650
+ AbcStorageKey2["AUTH_STATE"] = "auth_state";
1651
+ return AbcStorageKey2;
1652
+ })(AbcStorageKey || {});
1653
+
1654
+ // src/wallets/walletConnectors/abcWallet/api/modules/signBodies.ts
1655
+ function badRequest(message) {
1656
+ return new TalkenApiError("BAD_REQUEST", message, 400);
1657
+ }
1658
+ function compact(body) {
1659
+ return Object.fromEntries(
1660
+ Object.entries(body).filter(([, value]) => value != null)
1661
+ );
1662
+ }
1663
+ function isRecord(value) {
1664
+ return typeof value === "object" && value !== null && !Array.isArray(value);
1665
+ }
1666
+ function toDecimalString(value, field) {
1667
+ const text = typeof value === "string" ? value.trim() : String(value);
1668
+ if (!/^(0x[0-9a-fA-F]+|\d+)$/.test(text)) {
1669
+ throw badRequest(`${field} must be a decimal or 0x-hex integer`);
1670
+ }
1671
+ return BigInt(text).toString(10);
1672
+ }
1673
+ function toSignTxBody(params) {
1674
+ if (!params.network || !params.to) {
1675
+ throw badRequest("network and to are required");
1676
+ }
1677
+ return compact({
1678
+ chainKey: params.network,
1679
+ to: params.to,
1680
+ amountWei: toDecimalString(params.value || "0", "value"),
1681
+ data: params.data,
1682
+ nonce: params.nonce,
1683
+ gasLimit: params.gasLimit,
1684
+ gasPrice: params.gasPrice,
1685
+ maxFeePerGas: params.maxFeePerGas,
1686
+ maxPriorityFeePerGas: params.maxPriorityFeePerGas,
1687
+ type: params.type,
1688
+ pin: params.pin,
1689
+ email: params.email
1690
+ });
1691
+ }
1692
+ function referencedTypeNames(types) {
1693
+ const names = /* @__PURE__ */ new Set();
1694
+ for (const fields of Object.values(types)) {
1695
+ if (!Array.isArray(fields))
1696
+ continue;
1697
+ for (const field of fields) {
1698
+ const type = isRecord(field) ? field.type : void 0;
1699
+ if (typeof type === "string")
1700
+ names.add(type.replace(/(\[\d*\])+$/, ""));
1701
+ }
1702
+ }
1703
+ return names;
1704
+ }
1705
+ function inferPrimaryType(types) {
1706
+ const referenced = referencedTypeNames(types);
1707
+ const roots = Object.keys(types).filter(
1708
+ (name) => name !== "EIP712Domain" && !referenced.has(name)
1709
+ );
1710
+ if (roots.length !== 1) {
1711
+ throw badRequest(
1712
+ "typedData.primaryType is required when types has no single root struct"
1713
+ );
1714
+ }
1715
+ return roots[0];
1716
+ }
1717
+ function toSignTypedDataBody(params) {
1718
+ if (!params.network || !params.typedData) {
1719
+ throw badRequest("network and typedData are required");
1720
+ }
1721
+ let parsed = params.typedData;
1722
+ if (typeof parsed === "string") {
1723
+ try {
1724
+ parsed = JSON.parse(parsed);
1725
+ } catch {
1726
+ throw badRequest("typedData must be valid JSON");
1727
+ }
1728
+ }
1729
+ if (!isRecord(parsed))
1730
+ throw badRequest("typedData must be a JSON object");
1731
+ const { domain, types, primaryType, message } = parsed;
1732
+ if (!isRecord(domain))
1733
+ throw badRequest("typedData.domain must be an object");
1734
+ if (!isRecord(types))
1735
+ throw badRequest("typedData.types must be an object");
1736
+ if (!isRecord(message)) {
1737
+ throw badRequest("typedData.message must be an object");
1738
+ }
1739
+ if (primaryType != null && (typeof primaryType !== "string" || primaryType.trim() === "")) {
1740
+ throw badRequest("typedData.primaryType must be a non-empty string");
1741
+ }
1742
+ return compact({
1743
+ chainKey: params.network,
1744
+ domain,
1745
+ types,
1746
+ primaryType: primaryType ?? inferPrimaryType(types),
1747
+ message,
1748
+ pin: params.pin,
1749
+ email: params.email
1750
+ });
1751
+ }
1752
+ function toSignMessageBody(params) {
1753
+ return compact({
1754
+ chainKey: params.network,
1755
+ message: params.message,
1756
+ address: params.address,
1757
+ signaturePrefix: params.signaturePrefix,
1758
+ pin: params.pin,
1759
+ email: params.email
1760
+ });
1761
+ }
1762
+ function toSignAuthorizationBody(params) {
1763
+ const { authorization } = params;
1764
+ if (!authorization?.address || authorization.chainId == null || authorization.nonce == null) {
1765
+ throw badRequest(
1766
+ "authorization.chainId, authorization.address, authorization.nonce are required"
1767
+ );
1768
+ }
1769
+ return compact({
1770
+ chainKey: params.network,
1771
+ authorization: {
1772
+ chainId: Number(
1773
+ toDecimalString(authorization.chainId, "authorization.chainId")
1774
+ ),
1775
+ address: authorization.address,
1776
+ nonce: toDecimalString(authorization.nonce, "authorization.nonce")
1777
+ },
1778
+ pin: params.pin,
1779
+ email: params.email
1780
+ });
1781
+ }
1782
+ function toSignSolanaBody(params) {
1783
+ return compact({
1784
+ message: params.message,
1785
+ network: params.network,
1786
+ pin: params.pin,
1787
+ keyId: params.keyId,
1788
+ encryptedShare: params.encryptedShare,
1789
+ secretStore: params.secretStore
1790
+ });
1791
+ }
1792
+ function toSignHashBody(params) {
1793
+ return compact({
1794
+ hash: params.hash,
1795
+ chainKey: params.network || void 0,
1796
+ pin: params.pin,
1797
+ email: params.email
1798
+ });
1799
+ }
1800
+
1801
+ // src/wallets/walletConnectors/abcWallet/api/modules/executeBodies.ts
1802
+ var NATIVE_DECIMALS = {
1803
+ solana: 9,
1804
+ tron: 6,
1805
+ xrpl: 6,
1806
+ bitcoin: 8
1807
+ };
1808
+ var MAX_IDEMPOTENCY_KEY_LENGTH = 200;
1809
+ var IDEMPOTENCY_KEY_BYTES = 16;
1810
+ var BTC_FEE_RATE_PATTERN = /^[1-9][0-9]{0,3}$/;
1811
+ var BTC_FEE_RATE_MAX = 1e3;
1812
+ var XRP_FEE_PATTERN = /^[1-9][0-9]{0,6}$/;
1813
+ var XRP_FEE_MAX_DROPS = 1e6;
1814
+ var TRC20_FEE_LIMIT_MAX_SUN = 1e9;
1815
+ var XRP_DESTINATION_TAG_MAX = 4294967295;
1816
+ var SOLANA_CHAIN_KEYS = { solana: "solana", solana_devnet: "solanaDevnet" };
1817
+ var TRON_CHAIN_KEYS = { tron: "tron", tron_nile: "tronNile" };
1818
+ var XRPL_CHAIN_KEYS = { xrpl: "xrpl", xrpl_testnet: "xrplTestnet" };
1819
+ var BITCOIN_CHAIN_KEYS = {
1820
+ bitcoin: "bitcoin",
1821
+ bitcoin_testnet: "bitcoinTestnet"
1822
+ };
1823
+ function newIdempotencyKey() {
1824
+ const bytes = crypto.getRandomValues(new Uint8Array(IDEMPOTENCY_KEY_BYTES));
1825
+ return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(
1826
+ ""
1827
+ );
1828
+ }
1829
+ function acceptIdempotencyKey(key) {
1830
+ if (key === void 0)
1831
+ return newIdempotencyKey();
1832
+ if (typeof key !== "string" || key === "" || key.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
1833
+ throw badRequest(
1834
+ `idempotencyKey must be a string of 1 to ${MAX_IDEMPOTENCY_KEY_LENGTH} characters`
1835
+ );
1836
+ }
1837
+ return key;
1838
+ }
1839
+ function chainKeyFor(label, table, network) {
1840
+ if (typeof network === "string" && Object.prototype.hasOwnProperty.call(table, network)) {
1841
+ return table[network];
1842
+ }
1843
+ throw badRequest(
1844
+ `${label} network must be one of: ${Object.keys(table).join(", ")}`
1845
+ );
1846
+ }
1847
+ function required(value, field) {
1848
+ if (typeof value !== "string" || value === "") {
1849
+ throw badRequest(`${field} is required`);
1850
+ }
1851
+ return value;
1852
+ }
1853
+ function refuseDefined(params, fields, context) {
1854
+ for (const field of fields) {
1855
+ if (params[field] != null) {
1856
+ throw badRequest(`${field} is not supported ${context}`);
1857
+ }
1858
+ }
1859
+ }
1860
+ function humanAmount(baseUnits, decimals, field) {
1861
+ try {
1862
+ return toDecimalAmount(required(baseUnits, field), decimals);
1863
+ } catch (error) {
1864
+ if (error instanceof TalkenApiError)
1865
+ throw error;
1866
+ throw badRequest(
1867
+ `${field}: ${error instanceof Error ? error.message : String(error)}`
1868
+ );
1869
+ }
1870
+ }
1871
+ function toExecuteTxBody(params) {
1872
+ return compact({
1873
+ chainKey: params.chainKey,
1874
+ to: params.to,
1875
+ amountWei: params.amountWei,
1876
+ data: params.data,
1877
+ gasLimit: params.gasLimit,
1878
+ gasPrice: params.gasPrice,
1879
+ maxFeePerGas: params.maxFeePerGas,
1880
+ maxPriorityFeePerGas: params.maxPriorityFeePerGas,
1881
+ pin: params.pin,
1882
+ email: params.email,
1883
+ waitForReceipt: params.waitForReceipt,
1884
+ idempotencyKey: acceptIdempotencyKey(params.idempotencyKey)
1885
+ });
1886
+ }
1887
+ function toSolanaSendBody(params) {
1888
+ const chainKey = chainKeyFor("Solana", SOLANA_CHAIN_KEYS, params.network);
1889
+ const to = required(params.toAddress, "toAddress");
1890
+ const kind = params.kind ?? (params.mintAddress ? "spl" : "native");
1891
+ if (kind !== "native" && kind !== "spl") {
1892
+ throw badRequest("kind must be native or spl");
1893
+ }
1894
+ const common = {
1895
+ pin: params.pin,
1896
+ email: params.email,
1897
+ waitForReceipt: params.waitForConfirmation,
1898
+ idempotencyKey: acceptIdempotencyKey(params.idempotencyKey)
1899
+ };
1900
+ if (kind === "native") {
1901
+ refuseDefined(
1902
+ params,
1903
+ ["mintAddress", "amount", "decimals"],
1904
+ "for a native SOL transfer"
1905
+ );
1906
+ return compact({
1907
+ to,
1908
+ chainKey,
1909
+ amount: humanAmount(
1910
+ params.amountLamports,
1911
+ NATIVE_DECIMALS.solana,
1912
+ "amountLamports"
1913
+ ),
1914
+ ...common
1915
+ });
1916
+ }
1917
+ refuseDefined(params, ["amountLamports"], "for an SPL transfer");
1918
+ return compact({
1919
+ to,
1920
+ chainKey,
1921
+ amount: humanAmount(params.amount, params.decimals, "amount"),
1922
+ token: required(params.mintAddress, "mintAddress"),
1923
+ decimals: params.decimals,
1924
+ ...common
1925
+ });
1926
+ }
1927
+ function toTronSendBody(params) {
1928
+ const chainKey = chainKeyFor("TRON", TRON_CHAIN_KEYS, params.network);
1929
+ const to = required(params.toAddress, "toAddress");
1930
+ const kind = params.kind ?? "native";
1931
+ refuseDefined(
1932
+ params,
1933
+ ["data", "callValue", "confirmPollMs", "confirmMaxAttempts"],
1934
+ "by /execute/send"
1935
+ );
1936
+ const common = {
1937
+ pin: params.pin,
1938
+ email: params.email,
1939
+ waitForReceipt: params.waitForConfirmation,
1940
+ idempotencyKey: acceptIdempotencyKey(params.idempotencyKey)
1941
+ };
1942
+ if (kind === "native") {
1943
+ refuseDefined(
1944
+ params,
1945
+ ["contractAddress", "amount", "decimals", "feeLimit"],
1946
+ "for a native TRX transfer"
1947
+ );
1948
+ return compact({
1949
+ to,
1950
+ chainKey,
1951
+ amount: humanAmount(params.amountSun, NATIVE_DECIMALS.tron, "amountSun"),
1952
+ ...common
1953
+ });
1954
+ }
1955
+ if (kind !== "trc20") {
1956
+ throw badRequest("kind must be native or trc20");
1957
+ }
1958
+ refuseDefined(params, ["amountSun"], "for a TRC-20 transfer");
1959
+ if (params.feeLimit != null && !(Number.isSafeInteger(params.feeLimit) && params.feeLimit >= 1 && params.feeLimit <= TRC20_FEE_LIMIT_MAX_SUN)) {
1960
+ throw badRequest(
1961
+ `feeLimit must be an integer number of sun from 1 to ${TRC20_FEE_LIMIT_MAX_SUN}`
1962
+ );
1963
+ }
1964
+ return compact({
1965
+ to,
1966
+ chainKey,
1967
+ amount: humanAmount(params.amount, params.decimals, "amount"),
1968
+ token: required(params.contractAddress, "contractAddress"),
1969
+ decimals: params.decimals,
1970
+ feeLimit: params.feeLimit,
1971
+ ...common
1972
+ });
1973
+ }
1974
+ function toXrpSendBody(params) {
1975
+ const chainKey = chainKeyFor("XRPL", XRPL_CHAIN_KEYS, params.network);
1976
+ const to = required(params.destination, "destination");
1977
+ if (params.destinationTag != null && !(Number.isInteger(params.destinationTag) && params.destinationTag >= 0 && params.destinationTag <= XRP_DESTINATION_TAG_MAX)) {
1978
+ throw badRequest(
1979
+ `destinationTag must be an integer from 0 to ${XRP_DESTINATION_TAG_MAX}`
1980
+ );
1981
+ }
1982
+ if (params.fee != null && !(typeof params.fee === "string" && XRP_FEE_PATTERN.test(params.fee) && Number(params.fee) <= XRP_FEE_MAX_DROPS)) {
1983
+ throw badRequest(
1984
+ `fee must be a decimal string of whole drops from 1 to ${XRP_FEE_MAX_DROPS}`
1985
+ );
1986
+ }
1987
+ const common = {
1988
+ destinationTag: params.destinationTag,
1989
+ fee: params.fee,
1990
+ pin: params.pin,
1991
+ email: params.email,
1992
+ waitForReceipt: params.waitForConfirmation,
1993
+ idempotencyKey: acceptIdempotencyKey(params.idempotencyKey)
1994
+ };
1995
+ if (params.kind === "native") {
1996
+ refuseDefined(params, ["currency", "issuer"], "for a native XRP transfer");
1997
+ return compact({
1998
+ to,
1999
+ chainKey,
2000
+ amount: humanAmount(params.amount, NATIVE_DECIMALS.xrpl, "amount"),
2001
+ ...common
2002
+ });
2003
+ }
2004
+ if (params.kind !== "fungible") {
2005
+ throw badRequest("kind must be native or fungible");
2006
+ }
2007
+ try {
2008
+ validateAmount(required(params.amount, "amount"));
2009
+ } catch (error) {
2010
+ if (error instanceof TalkenApiError)
2011
+ throw error;
2012
+ throw badRequest(
2013
+ `amount: ${error instanceof Error ? error.message : String(error)}`
2014
+ );
2015
+ }
2016
+ return compact({
2017
+ to,
2018
+ chainKey,
2019
+ amount: params.amount,
2020
+ token: required(params.currency, "currency"),
2021
+ issuer: required(params.issuer, "issuer"),
2022
+ ...common
2023
+ });
2024
+ }
2025
+ function toBitcoinSendBody(params) {
2026
+ if (params.action !== void 0 && params.action !== "transfer") {
2027
+ throw badRequest("only action=transfer is sent through /execute/send");
2028
+ }
2029
+ refuseDefined(
2030
+ params,
2031
+ [
2032
+ "blocks",
2033
+ "hash",
2034
+ "signatureHex",
2035
+ "confirmPollMs",
2036
+ "confirmMaxAttempts",
2037
+ "minConfirmations"
2038
+ ],
2039
+ "by /execute/send"
2040
+ );
2041
+ const chainKey = chainKeyFor("Bitcoin", BITCOIN_CHAIN_KEYS, params.network);
2042
+ let feeRate;
2043
+ if (params.feeRate != null) {
2044
+ feeRate = String(params.feeRate);
2045
+ if (!BTC_FEE_RATE_PATTERN.test(feeRate) || Number(feeRate) > BTC_FEE_RATE_MAX) {
2046
+ throw badRequest(
2047
+ `feeRate must be a whole sat/vB from 1 to ${BTC_FEE_RATE_MAX}`
2048
+ );
2049
+ }
2050
+ }
2051
+ return compact({
2052
+ to: required(params.toAddress, "toAddress"),
2053
+ chainKey,
2054
+ amount: humanAmount(
2055
+ params.amountSats,
2056
+ NATIVE_DECIMALS.bitcoin,
2057
+ "amountSats"
2058
+ ),
2059
+ feeRate,
2060
+ pin: params.pin,
2061
+ email: params.email,
2062
+ idempotencyKey: acceptIdempotencyKey(params.idempotencyKey)
2063
+ });
2064
+ }
2065
+ function toBroadcastBody(chainKey, transaction) {
2066
+ return {
2067
+ chainKey: required(chainKey, "chainKey"),
2068
+ transaction: required(transaction, "transaction")
2069
+ };
2070
+ }
2071
+ function routeRawTransaction(params) {
2072
+ const { chain } = params;
2073
+ if (chain === "tvm" && params.network == null)
2074
+ return "legacy";
2075
+ const network = required(params.network, "network");
2076
+ const family = getNetworkType(network);
2077
+ const contradiction = () => badRequest(`chain=${chain} contradicts network=${network}`);
2078
+ if (chain === "tvm" || family === "TRX" /* TRON */) {
2079
+ if (chain !== void 0 && chain !== "tvm" || family !== "TRX" /* TRON */) {
2080
+ throw family === void 0 && chain === "tvm" ? badRequest(`network ${network} is not a TRON network`) : contradiction();
2081
+ }
2082
+ return "legacy";
2083
+ }
2084
+ if (chain === "svm") {
2085
+ throw badRequest(
2086
+ "sendRawTransaction broadcasts signed EVM transactions only; send a Solana transfer with solana.transfer, or sign a Solana message or transaction with solana.sign"
2087
+ );
2088
+ }
2089
+ if (family !== "EVM" /* EVM */) {
2090
+ throw badRequest(
2091
+ `network ${network} is not an EVM network; /execute/broadcast takes signed EVM transactions only`
2092
+ );
1486
2093
  }
1487
- };
1488
- var _sharedInstance = null;
1489
- function getSharedGaslessFeeService() {
1490
- if (!_sharedInstance) {
1491
- _sharedInstance = new GaslessFeeService();
2094
+ if (chain !== void 0 && chain !== "evm")
2095
+ throw contradiction();
2096
+ return getEvmChainKey(network) === void 0 ? "legacy" : "broadcast";
2097
+ }
2098
+ function toExecuteBroadcastBody(params) {
2099
+ const chainKey = routeRawTransaction(params) === "broadcast" ? getEvmChainKey(required(params.network, "network")) : void 0;
2100
+ if (chainKey === void 0) {
2101
+ throw badRequest(
2102
+ "Only a signed EVM transaction on a network with a chain key is broadcast through /execute/broadcast"
2103
+ );
1492
2104
  }
1493
- return _sharedInstance;
2105
+ return toBroadcastBody(
2106
+ chainKey,
2107
+ required(params.signedSerializeTx, "signedSerializeTx")
2108
+ );
1494
2109
  }
1495
2110
 
1496
- // src/gasless/services/GaslessTransferService.ts
1497
- import { encodeFunctionData, erc20Abi, isAddress as isAddress2 } from "viem";
1498
-
1499
2111
  // src/gasless/utils/revokeDelegation.ts
1500
- import {
1501
- isAddress,
1502
- keccak256,
1503
- recoverAddress,
1504
- toHex,
1505
- toRlp
1506
- } from "viem";
1507
2112
  var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
1508
2113
  var DEFAULT_GAS_LIMIT = BigInt(1e5);
1509
2114
  var DEFAULT_MAX_FEE = BigInt(3e10);
@@ -1531,7 +2136,7 @@ async function recoverYParity(hash, r, s, expectedAddress) {
1531
2136
  }
1532
2137
  throw new Error("Failed to recover yParity from tx signature");
1533
2138
  }
1534
- async function sendRevokeTx(userAddress, _chainKey, chainId) {
2139
+ async function sendRevokeTx(userAddress, chainKey, chainId) {
1535
2140
  const api = getTalkenApiClient();
1536
2141
  if (!api)
1537
2142
  throw new Error("TalkenApiClient not initialized");
@@ -1639,17 +2244,12 @@ async function sendRevokeTx(userAddress, _chainKey, chainId) {
1639
2244
  );
1640
2245
  const signedFields = [...unsignedFields, txYParity ? "0x01" : "0x", txR, txS];
1641
2246
  const signedTx = `0x04${toRlp(signedFields).slice(2)}`;
1642
- const result = await api.post(
1643
- "/wallet/tx/raw",
1644
- {
1645
- chain: "evm",
1646
- network,
1647
- signedSerializeTx: signedTx,
1648
- waitForConfirmation: true
1649
- }
2247
+ const { txHash } = await api.post(
2248
+ TALKEN_API_ENDPOINTS.EXECUTE_BROADCAST,
2249
+ toBroadcastBody(chainKey, signedTx),
2250
+ { timeout: SEND_REQUEST_TIMEOUT }
1650
2251
  );
1651
- const txHash = result?.txHash ?? result?.hash ?? keccak256(signedTx);
1652
- console.log(`[RevokeDelegation] Revoke tx confirmed: ${txHash}`);
2252
+ console.log(`[RevokeDelegation] Revoke tx broadcast: ${txHash}`);
1653
2253
  return { txHash };
1654
2254
  }
1655
2255
  async function sendRevokeViaWalletClient(walletClient, chainId, userAddress) {
@@ -2625,6 +3225,47 @@ var AbstractChainProvider = class extends EventEmitter {
2625
3225
  }
2626
3226
  };
2627
3227
 
3228
+ // src/wallets/walletConnectors/abcWallet/api/modules/signingRefresh.ts
3229
+ function isSigningCredentialError(error) {
3230
+ if (!(error instanceof TalkenApiError) || error.statusCode !== 502 || !error.message.includes("Missing required wallet fields")) {
3231
+ return false;
3232
+ }
3233
+ const broadcast = broadcastMarker(error.details);
3234
+ if (broadcast === false)
3235
+ return true;
3236
+ return !(error.retryable === false || broadcast === "unknown" || isUnconfirmedBroadcastCode(error.code) || error.possibleTxHash !== void 0);
3237
+ }
3238
+ function isUnconfirmedBroadcastCode(code) {
3239
+ return code === "BROADCAST_UNCONFIRMED" || code.endsWith("_BROADCAST_UNCONFIRMED");
3240
+ }
3241
+ function broadcastMarker(details) {
3242
+ return typeof details === "object" && details !== null ? details.broadcast : void 0;
3243
+ }
3244
+ async function withSigningCredentialRefresh(client, call, options) {
3245
+ try {
3246
+ return await call();
3247
+ } catch (error) {
3248
+ if (!isSigningCredentialError(error))
3249
+ throw error;
3250
+ let pin = null;
3251
+ let email = null;
3252
+ try {
3253
+ const credentials = getCredentialManager();
3254
+ pin = credentials.getPinHash();
3255
+ email = options?.email || credentials.getEmail();
3256
+ } catch {
3257
+ }
3258
+ if (!pin || !email)
3259
+ throw error;
3260
+ await client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
3261
+ action: "create",
3262
+ email,
3263
+ pin
3264
+ });
3265
+ return call();
3266
+ }
3267
+ }
3268
+
2628
3269
  // src/wallets/walletConnectors/abcWallet/evmTxType.ts
2629
3270
  var QUANTITY = /^(?:0x[0-9a-fA-F]+|[0-9]+)$/;
2630
3271
  function resolveEvmSignType(tx) {
@@ -2654,52 +3295,6 @@ function unsupported7702() {
2654
3295
  );
2655
3296
  }
2656
3297
 
2657
- // src/wallets/walletConnectors/abcWallet/types/error.types.ts
2658
- var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode3) => {
2659
- AbcErrorCode3["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
2660
- AbcErrorCode3["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
2661
- AbcErrorCode3["WALLET_NOT_FOUND"] = "WALLET_NOT_FOUND";
2662
- AbcErrorCode3["INVALID_PIN"] = "INVALID_PIN";
2663
- AbcErrorCode3["NETWORK_ERROR"] = "NETWORK_ERROR";
2664
- AbcErrorCode3["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
2665
- AbcErrorCode3["USER_CANCELLED"] = "USER_CANCELLED";
2666
- AbcErrorCode3["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
2667
- return AbcErrorCode3;
2668
- })(AbcErrorCode || {});
2669
- var AbcError = class extends Error {
2670
- constructor(code, message, details, statusCode) {
2671
- super(message);
2672
- this.name = "AbcError";
2673
- this.code = code;
2674
- this.details = details;
2675
- this.statusCode = statusCode;
2676
- }
2677
- };
2678
- var TalkenApiError = class extends Error {
2679
- constructor(code, message, statusCode, details) {
2680
- super(message);
2681
- this.name = "TalkenApiError";
2682
- this.code = code;
2683
- this.statusCode = statusCode;
2684
- this.details = details;
2685
- }
2686
- };
2687
-
2688
- // src/wallets/walletConnectors/abcWallet/types/config.types.ts
2689
- var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
2690
- AbcStorageKey2["USER"] = "user";
2691
- AbcStorageKey2["WALLET"] = "wallet";
2692
- AbcStorageKey2["SOLANA_WALLET"] = "solana_wallet";
2693
- AbcStorageKey2["BITCOIN_WALLET"] = "bitcoin_wallet";
2694
- AbcStorageKey2["TRON_WALLET"] = "tron_wallet";
2695
- AbcStorageKey2["XRPL_WALLET"] = "xrpl_wallet";
2696
- AbcStorageKey2["ACCESS_TOKEN"] = "access_token";
2697
- AbcStorageKey2["REFRESH_TOKEN"] = "refresh_token";
2698
- AbcStorageKey2["EXPIRES_AT"] = "expires_at";
2699
- AbcStorageKey2["AUTH_STATE"] = "auth_state";
2700
- return AbcStorageKey2;
2701
- })(AbcStorageKey || {});
2702
-
2703
3298
  // src/wallets/walletConnectors/abcWallet/utils.ts
2704
3299
  function validatePin(pin) {
2705
3300
  if (!pin || typeof pin !== "string") {
@@ -2902,7 +3497,7 @@ var AbcEvmProvider = class extends AbstractChainProvider {
2902
3497
  * a wallet.generate() call (idempotent create/recover) to repopulate.
2903
3498
  */
2904
3499
  isSigningCredentialError(error) {
2905
- return error instanceof TalkenApiError && error.statusCode === 502 && error.message.includes("Missing required wallet fields");
3500
+ return isSigningCredentialError(error);
2906
3501
  }
2907
3502
  /**
2908
3503
  * Refresh server-side signing credentials.
@@ -2911,9 +3506,8 @@ var AbcEvmProvider = class extends AbstractChainProvider {
2911
3506
  * 1. PIN hash in memory → wallet.generate() to repopulate server cache
2912
3507
  * 2. Neither available → throw UNAUTHORIZED
2913
3508
  *
2914
- * Note: sessionStorage-cached credentials (evmCreds) are automatically
2915
- * attached to every signing request by TalkenApiClient, so the server
2916
- * can use them as fallback without a separate refresh call.
3509
+ * Note: the /sign/* and /execute/* routes do not accept cached `evmCreds`,
3510
+ * so this refresh is the only recovery from a cold server credential cache.
2917
3511
  */
2918
3512
  async refreshSigningCredentials() {
2919
3513
  const credMgr = getCredentialManager();
@@ -3175,23 +3769,21 @@ var AbcEvmProvider = class extends AbstractChainProvider {
3175
3769
  const amountWei = BigInt(hexValue).toString();
3176
3770
  try {
3177
3771
  const gasLimit = tx.gas || tx.gasLimit;
3178
- const result = await this.withSigningCredentialRetry(
3179
- () => api.evm.sendTransaction({
3180
- chainKey,
3181
- to: tx.to,
3182
- amountWei,
3183
- pin: pinHash,
3184
- data: tx.data || "0x",
3185
- waitForReceipt: true,
3186
- ...gasLimit && { gasLimit },
3187
- ...tx.gasPrice && { gasPrice: tx.gasPrice },
3188
- ...tx.maxFeePerGas && { maxFeePerGas: tx.maxFeePerGas },
3189
- ...tx.maxPriorityFeePerGas && {
3190
- maxPriorityFeePerGas: tx.maxPriorityFeePerGas
3191
- },
3192
- ...email && { email }
3193
- })
3194
- );
3772
+ const result = await api.evm.sendTransaction({
3773
+ chainKey,
3774
+ to: tx.to,
3775
+ amountWei,
3776
+ pin: pinHash,
3777
+ data: tx.data || "0x",
3778
+ waitForReceipt: true,
3779
+ ...gasLimit && { gasLimit },
3780
+ ...tx.gasPrice && { gasPrice: tx.gasPrice },
3781
+ ...tx.maxFeePerGas && { maxFeePerGas: tx.maxFeePerGas },
3782
+ ...tx.maxPriorityFeePerGas && {
3783
+ maxPriorityFeePerGas: tx.maxPriorityFeePerGas
3784
+ },
3785
+ ...email && { email }
3786
+ });
3195
3787
  this.updateTxResult({
3196
3788
  txHash: result.txHash,
3197
3789
  network: chainKey,
@@ -3786,257 +4378,81 @@ var TalkenAuthModule = class {
3786
4378
  }
3787
4379
  /**
3788
4380
  * Login with social provider (Google, Apple, Kakao, etc.)
3789
- * POST /wallet/auth { action: 'login', method: 'sns', token, service, audience? }
3790
- */
3791
- async loginWithSns(params) {
3792
- const raw = await this.client.post(
3793
- TALKEN_API_ENDPOINTS.AUTH,
3794
- {
3795
- action: "login",
3796
- method: "sns",
3797
- token: params.token,
3798
- service: params.service,
3799
- ...params.audience && { audience: params.audience }
3800
- },
3801
- { skipAuth: true }
3802
- );
3803
- const res = normalizeAuthResponse(raw);
3804
- this.client.handleAuthResponse(res);
3805
- return res;
3806
- }
3807
- /**
3808
- * Refresh access token
3809
- * POST /wallet/auth { action: 'token.refresh', refreshToken }
3810
- */
3811
- async refresh() {
3812
- const refreshToken = this.client.getRefreshToken();
3813
- if (!refreshToken) {
3814
- throw new TalkenApiError(
3815
- "TOKEN_EXPIRED",
3816
- "No refresh token available",
3817
- 401
3818
- );
3819
- }
3820
- const raw = await this.client.post(
3821
- TALKEN_API_ENDPOINTS.AUTH,
3822
- { action: "token.refresh", refreshToken },
3823
- { skipAuth: true }
3824
- );
3825
- const res = normalizeAuthResponse(raw);
3826
- this.client.handleAuthResponse(res);
3827
- return res;
3828
- }
3829
- /**
3830
- * Server-side unified onboarding: email + OTP → access key + wallets.
3831
- * POST /wallet/auth { action: 'ensure-user', email, otpCode, accessKeyName }
3832
- */
3833
- async ensureUser(email, otpCode, accessKeyName = "talkenkit") {
3834
- const raw = await this.client.post(
3835
- TALKEN_API_ENDPOINTS.AUTH,
3836
- { action: "ensure-user", email, otpCode, accessKeyName },
3837
- { skipAuth: true }
3838
- );
3839
- return raw.data || raw;
3840
- }
3841
- /**
3842
- * Create an Access Key for delegated authentication
3843
- * POST /agent/access-keys { name, pin, refreshToken, email, ttlSeconds }
3844
- */
3845
- async createAccessKey(params) {
3846
- const raw = await this.client.post(
3847
- TALKEN_API_ENDPOINTS.ACCESS_KEYS,
3848
- params
3849
- );
3850
- const d = raw.data || raw;
3851
- return {
3852
- accessKey: d.accessKey,
3853
- keyId: d.keyId,
3854
- expiresAt: d.expiresAt
3855
- };
3856
- }
3857
- /**
3858
- * Logout (clear local session only — no server endpoint)
3859
- */
3860
- logout() {
3861
- this.client.clearSession();
3862
- }
3863
- };
3864
-
3865
- // src/wallets/walletConnectors/abcWallet/api/modules/signBodies.ts
3866
- function badRequest(message) {
3867
- return new TalkenApiError("BAD_REQUEST", message, 400);
3868
- }
3869
- function compact(body) {
3870
- return Object.fromEntries(
3871
- Object.entries(body).filter(([, value]) => value != null)
3872
- );
3873
- }
3874
- function isRecord(value) {
3875
- return typeof value === "object" && value !== null && !Array.isArray(value);
3876
- }
3877
- function toDecimalString(value, field) {
3878
- const text = typeof value === "string" ? value.trim() : String(value);
3879
- if (!/^(0x[0-9a-fA-F]+|\d+)$/.test(text)) {
3880
- throw badRequest(`${field} must be a decimal or 0x-hex integer`);
3881
- }
3882
- return BigInt(text).toString(10);
3883
- }
3884
- function toSignTxBody(params) {
3885
- if (!params.network || !params.to) {
3886
- throw badRequest("network and to are required");
3887
- }
3888
- return compact({
3889
- chainKey: params.network,
3890
- to: params.to,
3891
- amountWei: toDecimalString(params.value || "0", "value"),
3892
- data: params.data,
3893
- nonce: params.nonce,
3894
- gasLimit: params.gasLimit,
3895
- gasPrice: params.gasPrice,
3896
- maxFeePerGas: params.maxFeePerGas,
3897
- maxPriorityFeePerGas: params.maxPriorityFeePerGas,
3898
- type: params.type,
3899
- pin: params.pin,
3900
- email: params.email
3901
- });
3902
- }
3903
- function referencedTypeNames(types) {
3904
- const names = /* @__PURE__ */ new Set();
3905
- for (const fields of Object.values(types)) {
3906
- if (!Array.isArray(fields))
3907
- continue;
3908
- for (const field of fields) {
3909
- const type = isRecord(field) ? field.type : void 0;
3910
- if (typeof type === "string")
3911
- names.add(type.replace(/(\[\d*\])+$/, ""));
3912
- }
3913
- }
3914
- return names;
3915
- }
3916
- function inferPrimaryType(types) {
3917
- const referenced = referencedTypeNames(types);
3918
- const roots = Object.keys(types).filter(
3919
- (name) => name !== "EIP712Domain" && !referenced.has(name)
3920
- );
3921
- if (roots.length !== 1) {
3922
- throw badRequest(
3923
- "typedData.primaryType is required when types has no single root struct"
4381
+ * POST /wallet/auth { action: 'login', method: 'sns', token, service, audience? }
4382
+ */
4383
+ async loginWithSns(params) {
4384
+ const raw = await this.client.post(
4385
+ TALKEN_API_ENDPOINTS.AUTH,
4386
+ {
4387
+ action: "login",
4388
+ method: "sns",
4389
+ token: params.token,
4390
+ service: params.service,
4391
+ ...params.audience && { audience: params.audience }
4392
+ },
4393
+ { skipAuth: true }
3924
4394
  );
4395
+ const res = normalizeAuthResponse(raw);
4396
+ this.client.handleAuthResponse(res);
4397
+ return res;
3925
4398
  }
3926
- return roots[0];
3927
- }
3928
- function toSignTypedDataBody(params) {
3929
- if (!params.network || !params.typedData) {
3930
- throw badRequest("network and typedData are required");
3931
- }
3932
- let parsed = params.typedData;
3933
- if (typeof parsed === "string") {
3934
- try {
3935
- parsed = JSON.parse(parsed);
3936
- } catch {
3937
- throw badRequest("typedData must be valid JSON");
4399
+ /**
4400
+ * Refresh access token
4401
+ * POST /wallet/auth { action: 'token.refresh', refreshToken }
4402
+ */
4403
+ async refresh() {
4404
+ const refreshToken = this.client.getRefreshToken();
4405
+ if (!refreshToken) {
4406
+ throw new TalkenApiError(
4407
+ "TOKEN_EXPIRED",
4408
+ "No refresh token available",
4409
+ 401
4410
+ );
3938
4411
  }
4412
+ const raw = await this.client.post(
4413
+ TALKEN_API_ENDPOINTS.AUTH,
4414
+ { action: "token.refresh", refreshToken },
4415
+ { skipAuth: true }
4416
+ );
4417
+ const res = normalizeAuthResponse(raw);
4418
+ this.client.handleAuthResponse(res);
4419
+ return res;
3939
4420
  }
3940
- if (!isRecord(parsed))
3941
- throw badRequest("typedData must be a JSON object");
3942
- const { domain, types, primaryType, message } = parsed;
3943
- if (!isRecord(domain))
3944
- throw badRequest("typedData.domain must be an object");
3945
- if (!isRecord(types))
3946
- throw badRequest("typedData.types must be an object");
3947
- if (!isRecord(message)) {
3948
- throw badRequest("typedData.message must be an object");
3949
- }
3950
- if (primaryType != null && (typeof primaryType !== "string" || primaryType.trim() === "")) {
3951
- throw badRequest("typedData.primaryType must be a non-empty string");
4421
+ /**
4422
+ * Server-side unified onboarding: email + OTP → access key + wallets.
4423
+ * POST /wallet/auth { action: 'ensure-user', email, otpCode, accessKeyName }
4424
+ */
4425
+ async ensureUser(email, otpCode, accessKeyName = "talkenkit") {
4426
+ const raw = await this.client.post(
4427
+ TALKEN_API_ENDPOINTS.AUTH,
4428
+ { action: "ensure-user", email, otpCode, accessKeyName },
4429
+ { skipAuth: true }
4430
+ );
4431
+ return raw.data || raw;
3952
4432
  }
3953
- return compact({
3954
- chainKey: params.network,
3955
- domain,
3956
- types,
3957
- primaryType: primaryType ?? inferPrimaryType(types),
3958
- message,
3959
- pin: params.pin,
3960
- email: params.email
3961
- });
3962
- }
3963
- function toSignMessageBody(params) {
3964
- return compact({
3965
- chainKey: params.network,
3966
- message: params.message,
3967
- address: params.address,
3968
- signaturePrefix: params.signaturePrefix,
3969
- pin: params.pin,
3970
- email: params.email
3971
- });
3972
- }
3973
- function toSignAuthorizationBody(params) {
3974
- const { authorization } = params;
3975
- if (!authorization?.address || authorization.chainId == null || authorization.nonce == null) {
3976
- throw badRequest(
3977
- "authorization.chainId, authorization.address, authorization.nonce are required"
4433
+ /**
4434
+ * Create an Access Key for delegated authentication
4435
+ * POST /agent/access-keys { name, pin, refreshToken, email, ttlSeconds }
4436
+ */
4437
+ async createAccessKey(params) {
4438
+ const raw = await this.client.post(
4439
+ TALKEN_API_ENDPOINTS.ACCESS_KEYS,
4440
+ params
3978
4441
  );
4442
+ const d = raw.data || raw;
4443
+ return {
4444
+ accessKey: d.accessKey,
4445
+ keyId: d.keyId,
4446
+ expiresAt: d.expiresAt
4447
+ };
3979
4448
  }
3980
- return compact({
3981
- chainKey: params.network,
3982
- authorization: {
3983
- chainId: Number(
3984
- toDecimalString(authorization.chainId, "authorization.chainId")
3985
- ),
3986
- address: authorization.address,
3987
- nonce: toDecimalString(authorization.nonce, "authorization.nonce")
3988
- },
3989
- pin: params.pin,
3990
- email: params.email
3991
- });
3992
- }
3993
- function toSignSolanaBody(params) {
3994
- return compact({
3995
- message: params.message,
3996
- network: params.network,
3997
- pin: params.pin,
3998
- keyId: params.keyId,
3999
- encryptedShare: params.encryptedShare,
4000
- secretStore: params.secretStore
4001
- });
4002
- }
4003
- function toSignHashBody(params) {
4004
- return compact({
4005
- hash: params.hash,
4006
- chainKey: params.network || void 0,
4007
- pin: params.pin,
4008
- email: params.email
4009
- });
4010
- }
4011
-
4012
- // src/wallets/walletConnectors/abcWallet/api/modules/signingRefresh.ts
4013
- function isSigningCredentialError(error) {
4014
- return error instanceof TalkenApiError && error.statusCode === 502 && error.message.includes("Missing required wallet fields");
4015
- }
4016
- async function withSigningCredentialRefresh(client, call) {
4017
- try {
4018
- return await call();
4019
- } catch (error) {
4020
- if (!isSigningCredentialError(error))
4021
- throw error;
4022
- let pin = null;
4023
- let email = null;
4024
- try {
4025
- const credentials = getCredentialManager();
4026
- pin = credentials.getPinHash();
4027
- email = credentials.getEmail();
4028
- } catch {
4029
- }
4030
- if (!pin || !email)
4031
- throw error;
4032
- await client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
4033
- action: "create",
4034
- email,
4035
- pin
4036
- });
4037
- return call();
4449
+ /**
4450
+ * Logout (clear local session only — no server endpoint)
4451
+ */
4452
+ logout() {
4453
+ this.client.clearSession();
4038
4454
  }
4039
- }
4455
+ };
4040
4456
 
4041
4457
  // src/wallets/walletConnectors/abcWallet/api/modules/evm.ts
4042
4458
  function withCachedEvmCreds(params) {
@@ -4116,23 +4532,52 @@ var TalkenEvmModule = class {
4116
4532
  );
4117
4533
  }
4118
4534
  /**
4119
- * Broadcast signed transaction
4120
- * POST /wallet/tx/raw { network, signedSerializeTx }
4535
+ * Broadcast a signed EVM transaction
4536
+ * POST /execute/broadcast { chainKey, transaction }
4537
+ * `network` (a WaaS network name or a chain key) is sent as the chain key the
4538
+ * kit's network tables map it to, never as the WaaS name, and
4539
+ * `signedSerializeTx` as `transaction`. The answer is the submission
4540
+ * acknowledgement (`txHash`); the route does not wait for a receipt.
4541
+ *
4542
+ * Deprecated for raw TRON (`chain: 'tvm'` or a TRON network) and for an EVM
4543
+ * network the kit has no chain key for (`optimism`, `moonbeam`, ...): they have
4544
+ * no /execute/* successor and stay on POST /wallet/tx/raw until its 2027-03-10
4545
+ * sunset. A Solana or Bitcoin network, an unknown network, and a `chain` that
4546
+ * contradicts the network are refused.
4121
4547
  */
4122
4548
  async sendRawTransaction(params) {
4549
+ if (routeRawTransaction(params) === "legacy") {
4550
+ return this.client.post(
4551
+ TALKEN_API_ENDPOINTS.TX_RAW,
4552
+ params
4553
+ );
4554
+ }
4123
4555
  return this.client.post(
4124
- TALKEN_API_ENDPOINTS.TX_RAW,
4125
- params
4556
+ TALKEN_API_ENDPOINTS.EXECUTE_BROADCAST,
4557
+ toExecuteBroadcastBody(params),
4558
+ { timeout: SEND_REQUEST_TIMEOUT }
4126
4559
  );
4127
4560
  }
4128
4561
  /**
4129
4562
  * Integrated EVM transfer (sign + broadcast)
4130
- * POST /wallet/tx/evm { chainKey, to, amountWei, pin, ... }
4563
+ * POST /execute/tx { chainKey, to, amountWei, pin, idempotencyKey, ... }
4564
+ * Cached `evmCreds` are not attached: the route does not accept them. Pass one
4565
+ * `idempotencyKey` per user action to share it across a re-send of that
4566
+ * action; without one the call generates its own.
4567
+ * A cold server credential cache (502 "Missing required wallet fields", which
4568
+ * the server answers before anything is signed) is refreshed once and the same
4569
+ * request re-sent under the same key, as for the /sign/* methods.
4131
4570
  */
4132
4571
  async sendTransaction(params) {
4133
- return this.client.post(
4134
- TALKEN_API_ENDPOINTS.TX_EVM,
4135
- withCachedEvmCreds(params)
4572
+ const body = toExecuteTxBody(params);
4573
+ return withSigningCredentialRefresh(
4574
+ this.client,
4575
+ () => this.client.post(
4576
+ TALKEN_API_ENDPOINTS.EXECUTE_TX,
4577
+ body,
4578
+ { timeout: SEND_REQUEST_TIMEOUT }
4579
+ ),
4580
+ { email: params.email }
4136
4581
  );
4137
4582
  }
4138
4583
  /**
@@ -4251,20 +4696,41 @@ var TalkenBitcoinModule = class {
4251
4696
  }
4252
4697
  /**
4253
4698
  * Send BTC (integrated sign + broadcast, action=transfer)
4254
- * POST /wallet/tx/btc
4699
+ * POST /execute/send { to, chainKey, amount, feeRate?, pin, email, idempotencyKey }
4700
+ * `amountSats` is sent as a BTC `amount` and `network` (required) as the chain
4701
+ * key. `waitForConfirmation` is not forwarded: the server's confirmation poll
4702
+ * outlasts the client timeout, so the answer is the broadcast `txHash`.
4703
+ * A cold server credential cache (502 "Missing required wallet fields",
4704
+ * answered before anything is signed, `details.broadcast: false`) is refreshed
4705
+ * once and the same request re-sent under the same key. The cached `evmCreds`
4706
+ * the legacy route took as its fallback are not accepted by /execute/send.
4255
4707
  */
4256
4708
  async sendTransaction(params) {
4257
- const payload = { action: "transfer", ...params };
4258
- return this.client.post(
4259
- TALKEN_API_ENDPOINTS.TX_BTC,
4260
- withCachedEvmCreds(payload)
4709
+ const body = toBitcoinSendBody(params);
4710
+ return withSigningCredentialRefresh(
4711
+ this.client,
4712
+ () => this.client.post(
4713
+ TALKEN_API_ENDPOINTS.EXECUTE_SEND,
4714
+ body,
4715
+ { timeout: SEND_REQUEST_TIMEOUT }
4716
+ ),
4717
+ { email: params.email }
4261
4718
  );
4262
4719
  }
4263
4720
  /**
4264
- * Execute BTC action endpoint (transfer|generate|signHash|finalize)
4721
+ * Execute a BTC action endpoint (generate|finalize)
4265
4722
  * POST /wallet/tx/btc
4723
+ *
4724
+ * @deprecated No /execute/* successor for the generate and finalize steps; stays
4725
+ * on /wallet/tx/btc until its 2027-03-10 sunset. Use `sendTransaction` to send
4726
+ * and `signHash` to sign.
4266
4727
  */
4267
4728
  async execute(params) {
4729
+ if (params.action !== "generate" && params.action !== "finalize") {
4730
+ throw badRequest(
4731
+ "execute supports only action=generate or finalize; use sendTransaction to send and signHash to sign"
4732
+ );
4733
+ }
4268
4734
  return this.client.post(
4269
4735
  TALKEN_API_ENDPOINTS.TX_BTC,
4270
4736
  withCachedEvmCreds(params)
@@ -4287,6 +4753,9 @@ var TalkenBitcoinModule = class {
4287
4753
  /**
4288
4754
  * Broadcast raw BTC transaction
4289
4755
  * POST /wallet/tx/raw { network, signedSerializeTx }
4756
+ *
4757
+ * @deprecated No /execute/* successor (/execute/broadcast answers 501 for
4758
+ * Bitcoin); stays on /wallet/tx/raw until its 2027-03-10 sunset.
4290
4759
  */
4291
4760
  async broadcastRawTransaction(params) {
4292
4761
  return this.client.post(TALKEN_API_ENDPOINTS.TX_RAW, {
@@ -4321,14 +4790,21 @@ var TalkenSolanaModule = class {
4321
4790
  }
4322
4791
  /**
4323
4792
  * Transfer SOL or SPL token (integrated sign + broadcast)
4324
- * POST /wallet/tx/sol
4325
- * - kind='native': { toAddress, amountLamports, pin }
4326
- * - kind='spl': { toAddress, mintAddress, amount, decimals, network, pin }
4793
+ * POST /execute/send { to, chainKey, amount, token?, decimals?, pin, ... }
4794
+ * - kind='native': `amountLamports` (base units) is sent as a SOL `amount`
4795
+ * - kind='spl': `amount` (raw units) and `decimals` are sent as the human
4796
+ * `amount` with `token` (the mint) and `decimals`
4797
+ * `network` is required and becomes the chain key; `waitForConfirmation` is
4798
+ * sent as `waitForReceipt`.
4799
+ * Not wrapped in `withSigningCredentialRefresh`: Solana signs with the
4800
+ * wallet's encrypted share, not the EVM signing credentials, so the server
4801
+ * never answers this send with the cold-credential 502.
4327
4802
  */
4328
4803
  async transfer(params) {
4329
4804
  return this.client.post(
4330
- TALKEN_API_ENDPOINTS.TX_SOL,
4331
- params
4805
+ TALKEN_API_ENDPOINTS.EXECUTE_SEND,
4806
+ toSolanaSendBody(params),
4807
+ { timeout: SEND_REQUEST_TIMEOUT }
4332
4808
  );
4333
4809
  }
4334
4810
  /**
@@ -4356,15 +4832,33 @@ var TalkenTronModule = class {
4356
4832
  }
4357
4833
  /**
4358
4834
  * Execute TVM(TRON) transfer/call (integrated sign + broadcast)
4359
- * POST /wallet/tx/tvm
4360
- * - kind=native: TRX transfer (amountSun)
4361
- * - kind=trc20: TRC-20 transfer (contractAddress + amount)
4362
- * - kind=contract: arbitrary contract call (contractAddress + data)
4835
+ * POST /execute/send { to, chainKey, amount, token?, decimals?, feeLimit?, pin, ... }
4836
+ * - kind=native: TRX transfer; `amountSun` is sent as a TRX `amount`
4837
+ * - kind=trc20: TRC-20 transfer; `amount` (raw units) and `decimals` are sent as
4838
+ * the human `amount` with `token` (the contract) and `decimals`. `decimals`
4839
+ * is required, and `feeLimit` (sun, an integer) is sent for TRC-20 only.
4840
+ * A cold server credential cache (502 "Missing required wallet fields",
4841
+ * answered before anything is signed, `details.broadcast: false`) is refreshed
4842
+ * once and the same request re-sent under the same key.
4843
+ * - kind=contract: arbitrary contract call. Deprecated: it has no /execute/*
4844
+ * successor and stays on POST /wallet/tx/tvm until its 2027-03-10 sunset.
4363
4845
  */
4364
4846
  async transferTrx(params) {
4365
- return this.client.post(
4366
- TALKEN_API_ENDPOINTS.TX_TVM,
4367
- params
4847
+ if (params.kind === "contract") {
4848
+ return this.client.post(
4849
+ TALKEN_API_ENDPOINTS.TX_TVM,
4850
+ params
4851
+ );
4852
+ }
4853
+ const body = toTronSendBody(params);
4854
+ return withSigningCredentialRefresh(
4855
+ this.client,
4856
+ () => this.client.post(
4857
+ TALKEN_API_ENDPOINTS.EXECUTE_SEND,
4858
+ body,
4859
+ { timeout: SEND_REQUEST_TIMEOUT }
4860
+ ),
4861
+ { email: params.email }
4368
4862
  );
4369
4863
  }
4370
4864
  /**
@@ -4513,14 +5007,28 @@ var TalkenXrpModule = class {
4513
5007
  }
4514
5008
  /**
4515
5009
  * Execute XRP transfer (integrated sign + broadcast)
4516
- * POST /wallet/tx/xrp
4517
- * - kind=native: XRP transfer (amount in drops)
4518
- * - kind=fungible: IOU token transfer (currency + issuer)
5010
+ * POST /execute/send { to, chainKey, amount, token?, issuer?, fee?, destinationTag?, pin, ... }
5011
+ * - kind=native: XRP transfer; `amount` (drops) is sent as an XRP `amount`
5012
+ * - kind=fungible: IOU token transfer; `amount` is already in human units and
5013
+ * is sent unscaled, with `currency` as `token` and `issuer`. `decimals` is
5014
+ * never sent: the route refuses it on XRPL.
5015
+ * A cold server credential cache (502 "Missing required wallet fields",
5016
+ * answered before anything is signed, `details.broadcast: false`) is refreshed
5017
+ * once and the same request re-sent under the same key.
5018
+ * The route answers once the transaction is submitted (`engineResult`
5019
+ * `tesSUCCESS`) or queued (`terQUEUED`, `submissionStatus: 'queued'`);
5020
+ * `validated` is always false.
4519
5021
  */
4520
5022
  async transferXrp(params) {
4521
- return this.client.post(
4522
- TALKEN_API_ENDPOINTS.TX_XRP,
4523
- params
5023
+ const body = toXrpSendBody(params);
5024
+ return withSigningCredentialRefresh(
5025
+ this.client,
5026
+ () => this.client.post(
5027
+ TALKEN_API_ENDPOINTS.EXECUTE_SEND,
5028
+ body,
5029
+ { timeout: SEND_REQUEST_TIMEOUT }
5030
+ ),
5031
+ { email: params.email }
4524
5032
  );
4525
5033
  }
4526
5034
  /**
@@ -4646,6 +5154,16 @@ function saveToken(key, value) {
4646
5154
  function removeToken(key) {
4647
5155
  remove(STORAGE_NS.API, key);
4648
5156
  }
5157
+ function errorOutcome(error, details) {
5158
+ const fromDetails = typeof details === "object" && details !== null ? details.possibleTxHash : void 0;
5159
+ const hash = error?.possibleTxHash ?? fromDetails;
5160
+ return {
5161
+ ...typeof error?.retryable === "boolean" && {
5162
+ retryable: error.retryable
5163
+ },
5164
+ ...typeof hash === "string" && hash !== "" && { possibleTxHash: hash }
5165
+ };
5166
+ }
4649
5167
  var TalkenApiClient = class _TalkenApiClient {
4650
5168
  constructor(config2) {
4651
5169
  this.accessToken = null;
@@ -4905,11 +5423,13 @@ var TalkenApiClient = class _TalkenApiClient {
4905
5423
  if (this.config.debug) {
4906
5424
  logger3.error(`Error: ${errCode} - ${errMsg}`);
4907
5425
  }
5426
+ const details = data.error?.details || data.details;
4908
5427
  throw new TalkenApiError(
4909
5428
  errCode,
4910
5429
  errMsg,
4911
5430
  response.status,
4912
- data.error?.details || data.details
5431
+ details,
5432
+ errorOutcome(data.error, details)
4913
5433
  );
4914
5434
  }
4915
5435
  return data.data ?? data;
@@ -5956,6 +6476,21 @@ function setupVisibilityRefresh() {
5956
6476
  return () => document.removeEventListener("visibilitychange", handler);
5957
6477
  }
5958
6478
 
6479
+ // src/wallets/walletConnectors/abcWallet/sendFailure.ts
6480
+ function sendFailure(create, message, cause) {
6481
+ const { retryable, possibleTxHash } = cause ?? {};
6482
+ const hash = typeof possibleTxHash === "string" && possibleTxHash !== "" ? possibleTxHash : void 0;
6483
+ const error = create(
6484
+ hash ? `${message} (possible transaction hash: ${hash})` : message,
6485
+ cause
6486
+ );
6487
+ if (typeof retryable === "boolean")
6488
+ error.retryable = retryable;
6489
+ if (hash !== void 0)
6490
+ error.possibleTxHash = hash;
6491
+ return error;
6492
+ }
6493
+
5959
6494
  // src/wallets/walletConnectors/abcWallet/abcBitcoinProvider.ts
5960
6495
  var logger8 = createLogger("BitcoinProvider");
5961
6496
  function isTalkenApiClient(client) {
@@ -6218,32 +6753,14 @@ var AbcBitcoinProvider = class extends AbstractChainProvider {
6218
6753
  }
6219
6754
  const pinHash = getCredentialManager().getPinHash() || "";
6220
6755
  const email = this.getRecoveryEmail();
6221
- let signstr = "";
6222
- try {
6223
- const result = await api.bitcoin.execute({
6224
- action: "signHash",
6756
+ const signstr = this.extractHashSignature(
6757
+ await api.bitcoin.signHash({
6225
6758
  hash: hashHex,
6226
6759
  pin: pinHash || void 0,
6227
6760
  network: this.network.type,
6228
6761
  ...email && { email }
6229
- });
6230
- signstr = this.extractHashSignature(result);
6231
- } catch (error) {
6232
- logger8.warn(
6233
- "BTC signHash endpoint failed, falling back to generic sign/hash:",
6234
- error
6235
- );
6236
- }
6237
- if (!signstr) {
6238
- signstr = this.extractHashSignature(
6239
- await api.bitcoin.signHash({
6240
- hash: hashHex,
6241
- pin: pinHash || void 0,
6242
- network: this.network.type,
6243
- ...email && { email }
6244
- })
6245
- );
6246
- }
6762
+ })
6763
+ );
6247
6764
  if (!signstr) {
6248
6765
  throw new BitcoinProviderError(
6249
6766
  ProviderErrorCode.INTERNAL_ERROR,
@@ -6288,6 +6805,10 @@ var AbcBitcoinProvider = class extends AbstractChainProvider {
6288
6805
  "Wallet not connected"
6289
6806
  );
6290
6807
  }
6808
+ const amountSats = toBaseUnits(
6809
+ params.amount,
6810
+ NATIVE_DECIMALS.bitcoin
6811
+ ).toString();
6291
6812
  try {
6292
6813
  const INPUT_PER_BYTE = 141;
6293
6814
  const BUFFER = 500;
@@ -6320,10 +6841,10 @@ var AbcBitcoinProvider = class extends AbstractChainProvider {
6320
6841
  );
6321
6842
  }
6322
6843
  const email = this.getRecoveryEmail();
6323
- const satoshis = Math.floor(params.amount * 1e8);
6324
6844
  const result = await api.bitcoin.sendTransaction({
6325
6845
  toAddress: params.toAddress,
6326
- amountSats: satoshis.toString(),
6846
+ amountSats,
6847
+ network: this.network.type,
6327
6848
  pin: pinHash || void 0,
6328
6849
  ...email && { email }
6329
6850
  });
@@ -6348,15 +6869,23 @@ var AbcBitcoinProvider = class extends AbstractChainProvider {
6348
6869
  }
6349
6870
  logger8.error("Transaction failed:", error.message);
6350
6871
  if (error.message?.includes("insufficient")) {
6351
- throw new BitcoinProviderError(
6352
- ProviderErrorCode.INSUFFICIENT_FUNDS,
6872
+ throw sendFailure(
6873
+ (message, cause) => new BitcoinProviderError(
6874
+ ProviderErrorCode.INSUFFICIENT_FUNDS,
6875
+ message,
6876
+ cause
6877
+ ),
6353
6878
  "Insufficient BTC balance",
6354
6879
  error
6355
6880
  );
6356
6881
  }
6357
6882
  this.emit("error", error);
6358
- throw new BitcoinProviderError(
6359
- ProviderErrorCode.INTERNAL_ERROR,
6883
+ throw sendFailure(
6884
+ (message, cause) => new BitcoinProviderError(
6885
+ ProviderErrorCode.INTERNAL_ERROR,
6886
+ message,
6887
+ cause
6888
+ ),
6360
6889
  "Failed to send transaction",
6361
6890
  error
6362
6891
  );
@@ -6398,8 +6927,12 @@ var AbcBitcoinProvider = class extends AbstractChainProvider {
6398
6927
  } catch (error) {
6399
6928
  logger8.error("Transaction broadcast failed:", error.message);
6400
6929
  this.emit("error", error);
6401
- throw new BitcoinProviderError(
6402
- ProviderErrorCode.INTERNAL_ERROR,
6930
+ throw sendFailure(
6931
+ (message, cause) => new BitcoinProviderError(
6932
+ ProviderErrorCode.INTERNAL_ERROR,
6933
+ message,
6934
+ cause
6935
+ ),
6403
6936
  "Failed to broadcast transaction",
6404
6937
  error
6405
6938
  );
@@ -6887,6 +7420,20 @@ var AbcSolanaProvider = class extends AbstractChainProvider {
6887
7420
  "Wallet not connected"
6888
7421
  );
6889
7422
  }
7423
+ validateAmount(params.amount);
7424
+ const apiNetwork = this.getSigningNetwork();
7425
+ let decimals = NATIVE_DECIMALS.solana;
7426
+ if (params.mintAddress) {
7427
+ const walletscanApi = createWalletscanApi();
7428
+ const tokenMeta = await walletscanApi.getContractTokenWithTimeout({
7429
+ contractAddress: params.mintAddress,
7430
+ networks: apiNetwork
7431
+ });
7432
+ if (tokenMeta?.decimals == null)
7433
+ throw new Error("SPL token decimals are missing or invalid");
7434
+ decimals = tokenMeta.decimals;
7435
+ }
7436
+ const rawAmount = toSplRawAmount(params.amount, decimals);
6890
7437
  try {
6891
7438
  const symbol = params.mintAddress ? "SPL" : "SOL";
6892
7439
  await this.callInterceptor({
@@ -6918,16 +7465,8 @@ var AbcSolanaProvider = class extends AbstractChainProvider {
6918
7465
  network: this.wallet.network,
6919
7466
  hasPinHash: !!pinHash
6920
7467
  });
6921
- const apiNetwork = this.wallet.network === "solana" ? "solana" : "solana_devnet";
6922
7468
  this.showPendingTx({ network: apiNetwork, chain: "solana" });
6923
7469
  if (params.mintAddress) {
6924
- const walletscanApi = createWalletscanApi();
6925
- const tokenMeta = await walletscanApi.getContractTokenWithTimeout({
6926
- contractAddress: params.mintAddress,
6927
- networks: apiNetwork
6928
- });
6929
- const decimals = tokenMeta?.decimals ?? 9;
6930
- const rawAmount = Math.floor(params.amount * 10 ** decimals);
6931
7470
  const result2 = await api.solana.transfer({
6932
7471
  kind: "spl",
6933
7472
  toAddress: params.toAddress,
@@ -6942,8 +7481,7 @@ var AbcSolanaProvider = class extends AbstractChainProvider {
6942
7481
  this.updateSolanaTransactionResult(result2, apiNetwork);
6943
7482
  return { signature: result2.txHash };
6944
7483
  }
6945
- const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
6946
- const amountLamports = params.amount * LAMPORTS_PER_SOL;
7484
+ const amountLamports = rawAmount.toString();
6947
7485
  logger10.info("native transfer request:", {
6948
7486
  toAddress: params.toAddress,
6949
7487
  amountLamports: String(amountLamports),
@@ -6976,8 +7514,12 @@ var AbcSolanaProvider = class extends AbstractChainProvider {
6976
7514
  throw error;
6977
7515
  }
6978
7516
  this.emit("error", error);
6979
- throw new SolanaProviderError(
6980
- ProviderErrorCode.INTERNAL_ERROR,
7517
+ throw sendFailure(
7518
+ (message, cause) => new SolanaProviderError(
7519
+ ProviderErrorCode.INTERNAL_ERROR,
7520
+ message,
7521
+ cause
7522
+ ),
6981
7523
  "Failed to transfer",
6982
7524
  error
6983
7525
  );
@@ -7234,6 +7776,11 @@ ${msgBytes.length}`
7234
7776
  "Wallet not connected"
7235
7777
  );
7236
7778
  }
7779
+ const txType = params.contractAddress ? "TRC20" : "NATIVE";
7780
+ const amountRaw = toBaseUnits(
7781
+ params.amount,
7782
+ txType === "NATIVE" ? NATIVE_DECIMALS.tron : params.decimals
7783
+ ).toString();
7237
7784
  try {
7238
7785
  const tokenMetadata = await this.fetchTokenMetadata(
7239
7786
  params.contractAddress
@@ -7260,22 +7807,7 @@ ${msgBytes.length}`
7260
7807
  "PIN hash not found. Please login again."
7261
7808
  );
7262
7809
  }
7263
- const txType = params.contractAddress ? "TRC20" : "NATIVE";
7264
- let amountRaw;
7265
- if (txType === "NATIVE") {
7266
- amountRaw = Math.floor(
7267
- Number.parseFloat(params.amount) * 1e6
7268
- ).toString();
7269
- logger11.debug(`Converting ${params.amount} TRX -> ${amountRaw} SUN`);
7270
- } else {
7271
- const decimals = params.decimals ?? 6;
7272
- amountRaw = Math.floor(
7273
- Number.parseFloat(params.amount) * 10 ** decimals
7274
- ).toString();
7275
- logger11.debug(
7276
- `Converting ${params.amount} -> ${amountRaw} (decimals: ${decimals})`
7277
- );
7278
- }
7810
+ logger11.debug(`Converted ${params.amount} -> ${amountRaw} base units`);
7279
7811
  const email = getCredentialManager().getEmail() || void 0;
7280
7812
  const request = txType === "NATIVE" ? {
7281
7813
  kind: "native",
@@ -7291,6 +7823,7 @@ ${msgBytes.length}`
7291
7823
  toAddress: params.toAddress,
7292
7824
  contractAddress: params.contractAddress,
7293
7825
  amount: amountRaw,
7826
+ decimals: params.decimals,
7294
7827
  feeLimit: params.feeLimit,
7295
7828
  pin: pinHash || void 0,
7296
7829
  waitForConfirmation: true,
@@ -7325,15 +7858,19 @@ ${msgBytes.length}`
7325
7858
  errorMessage: error.message
7326
7859
  });
7327
7860
  if (error.message?.includes("insufficient")) {
7328
- throw new TronProviderError(
7329
- ProviderErrorCode.INSUFFICIENT_FUNDS,
7861
+ throw sendFailure(
7862
+ (message, cause) => new TronProviderError(
7863
+ ProviderErrorCode.INSUFFICIENT_FUNDS,
7864
+ message,
7865
+ cause
7866
+ ),
7330
7867
  "Insufficient TRX balance",
7331
7868
  error
7332
7869
  );
7333
7870
  }
7334
7871
  this.emit("error", error);
7335
- throw new TronProviderError(
7336
- ProviderErrorCode.INTERNAL_ERROR,
7872
+ throw sendFailure(
7873
+ (message, cause) => new TronProviderError(ProviderErrorCode.INTERNAL_ERROR, message, cause),
7337
7874
  error.message || "Failed to send TRON transaction",
7338
7875
  error
7339
7876
  );
@@ -7360,7 +7897,7 @@ ${msgBytes.length}`
7360
7897
  const blockNumber = info?.blockNumber ?? info?.result?.blockNumber ?? null;
7361
7898
  const rcpt = info?.receipt ?? info?.result?.receipt;
7362
7899
  const ret = tx?.ret ?? tx?.result?.ret;
7363
- const contractRet = Array.isArray(ret) ? ret[0]?.contractRet : void 0;
7900
+ const contractRet = (Array.isArray(ret) ? ret[0]?.contractRet : void 0) ?? rcpt?.result;
7364
7901
  receipt = {
7365
7902
  status: contractRet === "SUCCESS" ? 1 : contractRet ? 0 : null,
7366
7903
  blockNumber,
@@ -7382,8 +7919,15 @@ var logger12 = createLogger("XrplProvider");
7382
7919
  function isTalkenApiClient3(client) {
7383
7920
  return typeof client?.xrp?.transferXrp === "function";
7384
7921
  }
7385
- var XRP_DECIMALS = 6;
7386
- var XRP_DROPS_PER_UNIT = 10 ** XRP_DECIMALS;
7922
+ var XRP_DECIMALS = NATIVE_DECIMALS.xrpl;
7923
+ function classifyXrplSubmission(result) {
7924
+ const { engineResult } = result;
7925
+ if (engineResult === "terQUEUED" || result.submissionStatus === "queued")
7926
+ return "pending";
7927
+ if (!engineResult || engineResult === "tesSUCCESS")
7928
+ return "applied";
7929
+ return "rejected";
7930
+ }
7387
7931
  var XRPL_NETWORKS = {
7388
7932
  mainnet: {
7389
7933
  name: "XRP",
@@ -7454,8 +7998,15 @@ var AbcXrplProvider = class extends AbstractChainProvider {
7454
7998
  "Wallet not connected"
7455
7999
  );
7456
8000
  }
8001
+ const isNative = !params.currency;
8002
+ let amountRaw;
8003
+ if (isNative) {
8004
+ amountRaw = toBaseUnits(params.amount, XRP_DECIMALS).toString();
8005
+ } else {
8006
+ validateAmount(params.amount);
8007
+ amountRaw = params.amount;
8008
+ }
7457
8009
  try {
7458
- const isNative = !params.currency;
7459
8010
  const symbol = isNative ? "XRP" : params.currency;
7460
8011
  await this.callInterceptor({
7461
8012
  chain: "xrpl",
@@ -7478,15 +8029,7 @@ var AbcXrplProvider = class extends AbstractChainProvider {
7478
8029
  );
7479
8030
  }
7480
8031
  const email = getCredentialManager().getEmail() || void 0;
7481
- let amountRaw;
7482
- if (isNative) {
7483
- amountRaw = Math.floor(
7484
- Number.parseFloat(params.amount) * XRP_DROPS_PER_UNIT
7485
- ).toString();
7486
- logger12.debug(`Converting ${params.amount} XRP -> ${amountRaw} drops`);
7487
- } else {
7488
- amountRaw = params.amount;
7489
- }
8032
+ logger12.debug(`Converted ${params.amount} -> ${amountRaw}`);
7490
8033
  const request = {
7491
8034
  kind: isNative ? "native" : "fungible",
7492
8035
  network: this.network.type,
@@ -7504,19 +8047,19 @@ var AbcXrplProvider = class extends AbstractChainProvider {
7504
8047
  const result = await api.xrp.transferXrp(request);
7505
8048
  const txHash = result.txHash;
7506
8049
  const engineResult = result.engineResult;
7507
- const isSuccess = !engineResult || engineResult === "tesSUCCESS";
8050
+ const outcome = classifyXrplSubmission(result);
7508
8051
  this.updateTxResult({
7509
8052
  txHash,
7510
8053
  network: this.network.type,
7511
8054
  chain: "xrpl",
7512
8055
  receipt: {
7513
- status: isSuccess ? 1 : 0,
8056
+ status: { applied: 1, pending: null, rejected: 0 }[outcome],
7514
8057
  blockNumber: null,
7515
8058
  gasUsed: null
7516
8059
  },
7517
8060
  explorerUrl: `${this.network.explorer}/tx/${txHash}`
7518
8061
  });
7519
- if (!isSuccess) {
8062
+ if (outcome === "rejected") {
7520
8063
  logger12.error(`XRPL transaction failed on-ledger: ${engineResult}`);
7521
8064
  throw new XrplProviderError(
7522
8065
  ProviderErrorCode.INTERNAL_ERROR,
@@ -7548,8 +8091,8 @@ var AbcXrplProvider = class extends AbstractChainProvider {
7548
8091
  errorMessage: error.message
7549
8092
  });
7550
8093
  this.emit("error", error);
7551
- throw new XrplProviderError(
7552
- ProviderErrorCode.INTERNAL_ERROR,
8094
+ throw sendFailure(
8095
+ (message, cause) => new XrplProviderError(ProviderErrorCode.INTERNAL_ERROR, message, cause),
7553
8096
  error.message || "Failed to send XRPL transaction",
7554
8097
  error
7555
8098
  );
@@ -8025,6 +8568,8 @@ export {
8025
8568
  getGaslessConfig,
8026
8569
  resolveFeeTokensFromConfig,
8027
8570
  getSharedGaslessFeeService,
8571
+ validateAmount,
8572
+ toSplRawAmount,
8028
8573
  checkDelegation,
8029
8574
  ensureDelegationCleared,
8030
8575
  GaslessTransferService,