@across-protocol/sdk 4.3.165-beta.1 → 4.3.166-alpha.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.165-beta.1",
+  "version": "4.3.166-alpha.0",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "repository": {
@@ -81,7 +81,7 @@
   },
   "dependencies": {
     "@across-protocol/constants": "^3.1.110",
-    "@across-protocol/contracts": "5.0.12-alpha.2",
+    "@across-protocol/contracts": "5.0.15",
     "@coral-xyz/anchor": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",

package/src/arch/tvm/MessageUtils.ts

@@ -0,0 +1,72 @@
+import { RelayData, SpeedUpCommon } from "../../interfaces";
+import { BigNumber, bnZero, isDefined, isMessageEmpty, toBN } from "../../utils";
+
+// Tron prices each byte of a transaction's serialized raw_data + signature at this many
+// SUN of bandwidth when the relayer's free bandwidth allowance has been exhausted. The
+// rate is set by Tron governance; refresh from `wallet/getchainparameters` if it drifts.
+const TVM_BANDWIDTH_SUN_PER_BYTE = 1000;
+
+// Tron raw_data envelope (contract type, ref_block, timestamp, expiration, fee_limit)
+// plus a single ECDSA signature. Measured empirically against `fillRelay` transactions
+// emitted by the production relayer; varies by ~10 bytes between calls.
+const TVM_RAW_DATA_OVERHEAD_BYTES = 290;
+
+// `fillRelay(V3RelayData, uint256 repaymentChainId, bytes32 repaymentAddress)` ABI
+// encoding, excluding the `message` payload (which is dynamic).
+//   4   selector
+//  96   top-level head: offset(V3RelayData) + repaymentChainId + repaymentAddress
+// 384   V3RelayData struct head: 11 static fields inline + 1 offset(message)
+//  32   message length header
+const TVM_FILL_RELAY_FIXED_CALLDATA_BYTES = 4 + 96 + 384 + 32;
+
+// Extra ABI footprint when a speed-up signature is present and the relayer must call
+// `fillRelayWithUpdatedDeposit(V3RelayData, ..., uint256 updatedOutputAmount, bytes32
+// updatedRecipient, bytes updatedMessage, bytes speedUpSignature)`. The original
+// `message` still lives inside V3RelayData and is already counted above; this constant
+// captures only what's *additional* to the plain `fillRelay` encoding.
+//  128   4 extra head slots: updatedOutputAmount + updatedRecipient + offset(updatedMessage) + offset(speedUpSignature)
+//   32   updatedMessage length header (the padded body is added per-call below)
+//   32   speedUpSignature length header
+//   96   65-byte ECDSA signature padded to 3 EVM words
+const TVM_SPEED_UP_FIXED_CALLDATA_EXTRA_BYTES = 128 + 32 + 32 + 96;
+
+function paddedMessageByteLength(message: string | undefined): number {
+  if (!isDefined(message) || isMessageEmpty(message)) return 0;
+  const bytes = Math.max(0, Math.floor((message.length - 2) / 2));
+  return Math.ceil(bytes / 32) * 32;
+}
+
+/**
+ * Estimate the bandwidth cost (in SUN) of a Tron fill for `deposit`.
+ *
+ * On Tron, transaction bytes consume bandwidth — distinct from energy (paid via the tx
+ * fee limit and modeled in `nativeGasCost`). When the relayer has no free bandwidth
+ * staked, every byte burns 1,000 SUN. For message-bearing fills this is non-trivial:
+ * the message dominates calldata size, so the cost scales linearly with message length.
+ *
+ * Sped-up deposits (those carrying a `speedUpSignature`) are filled via
+ * `fillRelayWithUpdatedDeposit`, which carries the original `V3RelayData` *and*
+ * `updatedMessage`/`speedUpSignature` as additional ABI args. Both messages are charged.
+ *
+ * The estimate is conservative — it assumes zero free bandwidth (worst case). Relayers
+ * that stake TRX for bandwidth pay 0 onchain; this still represents the true marginal
+ * cost of consuming that staked allowance.
+ */
+export function getAuxiliaryNativeTokenCost(
+  deposit: RelayData & Partial<SpeedUpCommon> & { speedUpSignature?: string }
+): BigNumber {
+  const paddedMessageBytes = paddedMessageByteLength(deposit.message);
+
+  let speedUpExtraBytes = 0;
+  if (isDefined(deposit.speedUpSignature) && deposit.speedUpSignature !== "0x") {
+    speedUpExtraBytes = TVM_SPEED_UP_FIXED_CALLDATA_EXTRA_BYTES + paddedMessageByteLength(deposit.updatedMessage);
+  }
+
+  const calldataBytes = TVM_FILL_RELAY_FIXED_CALLDATA_BYTES + paddedMessageBytes + speedUpExtraBytes;
+  const txBytes = TVM_RAW_DATA_OVERHEAD_BYTES + calldataBytes;
+
+  return toBN(txBytes).mul(TVM_BANDWIDTH_SUN_PER_BYTE);
+}
+
+// Re-export so other arches can reference the zero default if needed.
+export const tvmBandwidthCostZero = bnZero;

package/src/arch/tvm/index.ts

@@ -1,2 +1,3 @@
 export * from "./SpokeUtils";
 export * from "./TransactionUtils";
+export * from "./MessageUtils";

package/src/relayFeeCalculator/chain-queries/factory.ts

@@ -4,12 +4,13 @@ import { getDeployedAddress } from "@across-protocol/contracts";
 import { asL2Provider } from "@eth-optimism/sdk";
 import { providers } from "ethers";
 import { CUSTOM_GAS_TOKENS } from "../../constants";
-import { chainIsEvm, chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
+import { chainIsEvm, chainIsOPStack, isDefined, chainIsSvm, chainIsTvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
 import { SVMProvider as svmProvider } from "../../arch/svm";
 import { DEFAULT_LOGGER, getDefaultRelayer, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
 import { SvmQuery } from "./svmQuery";
+import { TvmQuery } from "./tvmQuery";
 
 /**
  * Some chains have a fixed gas price that is applied to the gas estimates. We should override
@@ -35,7 +36,12 @@ export class QueryBase__factory {
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
     if (chainIsEvm(chainId) && isDefined(customGasTokenSymbol)) {
       assert(relayerAddress.isEVM());
-      return new CustomGasTokenQueries({
+      // TVM chains route through TvmQuery so that bandwidth — a Tron-native cost the
+      // EVM compatibility layer's `eth_estimateGas` does not surface — is included in
+      // `auxiliaryNativeTokenCost`. Otherwise fall back to the EVM-flavoured custom gas
+      // token query.
+      const QueryCtor = chainIsTvm(chainId) ? TvmQuery : CustomGasTokenQueries;
+      return new QueryCtor({
         queryBaseArgs: [
           provider as providers.Provider,
           symbolMapping,

package/src/relayFeeCalculator/chain-queries/index.ts

@@ -2,3 +2,4 @@ export * from "./baseQuery";
 export * from "./factory";
 export * from "./customGasToken";
 export * from "./svmQuery";
+export * from "./tvmQuery";

package/src/relayFeeCalculator/chain-queries/tvmQuery.ts

@@ -0,0 +1,20 @@
+import { arch } from "../..";
+import { RelayData } from "../../interfaces";
+import { BigNumber } from "../../utils";
+import { CustomGasTokenQueries } from "./customGasToken";
+
+/**
+ * TVM (TRON) query implementation. Extends `CustomGasTokenQueries` to add bandwidth
+ * accounting via `getAuxiliaryNativeTokenCost`, which the base EVM path returns 0 for.
+ *
+ * Energy (Tron's analogue of gas) is already estimated by `voidSigner.estimateGas`
+ * against the EVM-compat RPC and surfaces in `tokenGasCost`. Bandwidth is a separate
+ * Tron-native resource that the EVM compatibility layer does not surface, so we
+ * estimate it here from the deposit's `message` length and a fixed `fillRelay`
+ * calldata footprint.
+ */
+export class TvmQuery extends CustomGasTokenQueries {
+  override getAuxiliaryNativeTokenCost(deposit: RelayData): BigNumber {
+    return arch.tvm.getAuxiliaryNativeTokenCost(deposit);
+  }
+}

package/src/utils/abi/contracts/TronMulticallHandler.json

@@ -0,0 +1,291 @@
+[
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "attemptCalls",
+    "inputs": [
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct MulticallHandler.Call[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "drainLeftoverTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "destination",
+        "type": "address",
+        "internalType": "address payable"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "handleV3AcrossMessage",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "message",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "makeCallWithBalance",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "callData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "replacement",
+        "type": "tuple[]",
+        "internalType": "struct MulticallHandler.Replacement[]",
+        "components": [
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "offset",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "CallsFailed",
+    "inputs": [
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct MulticallHandler.Call[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "fallbackRecipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "DrainedTokens",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "CallReverted",
+    "inputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct MulticallHandler.Call[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "CalldataTooShort",
+    "inputs": [
+      {
+        "name": "callDataLength",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "offset",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidCall",
+    "inputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct MulticallHandler.Call[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotSelf",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReplacementCallFailed",
+    "inputs": [
+      {
+        "name": "callData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "TronTransferBalanceMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TronTransferCallReverted",
+    "inputs": []
+  }
+]