@across-protocol/sdk 4.2.16 → 4.3.1

package/src/interfaces/HubPool.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from "../utils";
+import { Address, BigNumber, EvmAddress } from "../utils";
 import { SortableEvent } from "./Common";
 
 export interface PoolRebalanceLeaf {
@@ -8,7 +8,7 @@ export interface PoolRebalanceLeaf {
   netSendAmounts: BigNumber[];
   runningBalances: BigNumber[];
   leafId: number;
-  l1Tokens: string[];
+  l1Tokens: EvmAddress[];
 }
 
 export interface RelayerRefundLeaf {
@@ -16,8 +16,8 @@ export interface RelayerRefundLeaf {
   chainId: number;
   refundAmounts: BigNumber[];
   leafId: number;
-  l2TokenAddress: string;
-  refundAddresses: string[];
+  l2TokenAddress: Address;
+  refundAddresses: Address[];
 }
 
 export interface ProposedRootBundle extends SortableEvent {
@@ -27,7 +27,7 @@ export interface ProposedRootBundle extends SortableEvent {
   poolRebalanceRoot: string;
   relayerRefundRoot: string;
   slowRelayRoot: string;
-  proposer: string;
+  proposer: EvmAddress;
 }
 
 export type RealizedLpFee = {
@@ -55,7 +55,7 @@ export interface ExecutedRootBundle extends SortableEvent {
   netSendAmounts: BigNumber[];
   runningBalances: BigNumber[];
   leafId: number;
-  l1Tokens: string[];
+  l1Tokens: EvmAddress[];
   proof: string[];
 }
 
@@ -76,8 +76,14 @@ export interface RelayerRefundLeafWithGroup extends RelayerRefundLeaf {
   groupIndex: number;
 }
 
-export interface L1Token {
-  address: string;
+export interface L1TokenInfo {
+  address: EvmAddress;
+  symbol: string;
+  decimals: number;
+}
+
+export interface TokenInfo {
+  address: Address;
   symbol: string;
   decimals: number;
 }
@@ -89,25 +95,25 @@ export interface LpToken {
 
 export interface CrossChainContractsSet extends SortableEvent {
   l2ChainId: number;
-  spokePool: string;
+  spokePool: Address;
 }
 
 export interface DestinationTokenWithBlock extends SortableEvent {
-  l2Token: string;
-  l1Token: string;
+  l2Token: Address;
+  l1Token: EvmAddress;
 }
 
 export interface SetPoolRebalanceRoot extends SortableEvent {
   destinationChainId: number;
-  l1Token: string;
-  destinationToken: string;
+  l1Token: EvmAddress;
+  destinationToken: Address;
 }
 
 export interface PendingRootBundle {
   poolRebalanceRoot: string;
   relayerRefundRoot: string;
   slowRelayRoot: string;
-  proposer: string;
+  proposer: EvmAddress;
   unclaimedPoolRebalanceLeafCount: number;
   challengePeriodEndTimestamp: number;
   bundleEvaluationBlockNumbers: number[];

package/src/interfaces/SpokePool.ts

@@ -1,31 +1,34 @@
 import { SortableEvent } from "./Common";
 import { SpokePoolClient } from "../clients";
-import { BigNumber } from "../utils";
+import { BigNumber, Address, EvmAddress } from "../utils";
 import { RelayerRefundLeaf } from "./HubPool";
 
 export interface RelayData {
   originChainId: number;
-  depositor: string;
-  recipient: string;
+  depositor: Address;
+  recipient: Address;
   depositId: BigNumber;
-  inputToken: string;
+  inputToken: Address;
   inputAmount: BigNumber;
-  outputToken: string;
+  outputToken: Address;
   outputAmount: BigNumber;
   message: string;
   fillDeadline: number;
-  exclusiveRelayer: string;
+  exclusiveRelayer: Address;
   exclusivityDeadline: number;
 }
 
-export interface Deposit extends RelayData {
+export interface SpeedUpCommon {
+  updatedRecipient: Address;
+  updatedOutputAmount: BigNumber;
+  updatedMessage: string;
+}
+
+export interface Deposit extends RelayData, Partial<SpeedUpCommon> {
   messageHash: string;
   destinationChainId: number;
   quoteTimestamp: number;
   speedUpSignature?: string;
-  updatedRecipient?: string;
-  updatedOutputAmount?: BigNumber;
-  updatedMessage?: string;
   fromLiteChain: boolean;
   toLiteChain: boolean;
 }
@@ -51,7 +54,7 @@ export enum FillType {
 }
 
 export interface RelayExecutionEventInfo {
-  updatedRecipient: string;
+  updatedRecipient: Address;
   updatedOutputAmount: BigNumber;
   updatedMessage?: string;
   updatedMessageHash: string;
@@ -61,7 +64,7 @@ export interface RelayExecutionEventInfo {
 export interface Fill extends Omit<RelayData, "message"> {
   messageHash: string;
   destinationChainId: number;
-  relayer: string;
+  relayer: Address;
   repaymentChainId: number;
   relayExecutionInfo: RelayExecutionEventInfo;
 }
@@ -72,20 +75,17 @@ export interface FillWithTime extends Fill, SortableEvent {
 }
 
 export interface EnabledDepositRoute {
-  originToken: string;
+  originToken: Address;
   destinationChainId: number;
   enabled: boolean;
 }
 
 export interface EnabledDepositRouteWithBlock extends EnabledDepositRoute, SortableEvent {}
-export interface SpeedUp {
-  depositor: string;
+export interface SpeedUp extends SpeedUpCommon {
+  depositor: EvmAddress;
   depositorSignature: string;
   depositId: BigNumber;
   originChainId: number;
-  updatedRecipient: string;
-  updatedOutputAmount: BigNumber;
-  updatedMessage: string;
 }
 
 export interface SpeedUpWithBlock extends SpeedUp, SortableEvent {}
@@ -130,7 +130,7 @@ export interface TokensBridged extends SortableEvent {
   amountToReturn: BigNumber;
   chainId: number;
   leafId: number;
-  l2TokenAddress: string;
+  l2TokenAddress: Address;
 }
 
 export interface ClaimedRelayerRefundWithBlock extends SortableEvent {

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

@@ -1,23 +1,24 @@
 import { L2Provider } from "@eth-optimism/sdk/dist/interfaces/l2-provider";
 import { isL2Provider as isOptimismL2Provider } from "@eth-optimism/sdk/dist/l2-provider";
-
 import { PopulatedTransaction, providers, VoidSigner } from "ethers";
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
-import { Deposit } from "../../interfaces";
+import { RelayData } from "../../interfaces";
 import { SpokePool, SpokePool__factory } from "../../typechain";
 import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
+  EvmAddress,
   TransactionCostEstimate,
   BigNumber,
   toBNWei,
   bnZero,
   chainIsOPStack,
   fixedPointAdjustment,
+  Address,
 } from "../../utils";
 import assert from "assert";
-import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { Transport } from "viem";
 import { getGasPriceEstimate } from "../../gasPriceOracle";
 import { EvmProvider } from "../../arch/evm/types";
@@ -51,7 +52,7 @@ export class QueryBase implements QueryInterface {
     readonly provider: EvmProvider,
     readonly symbolMapping: SymbolMappingType,
     readonly spokePoolAddress: string,
-    readonly simulatedRelayerAddress: string,
+    readonly simulatedRelayerAddress: EvmAddress,
     readonly logger: Logger,
     readonly coingeckoProApiKey?: string,
     readonly fixedGasPrice?: BigNumberish,
@@ -62,7 +63,7 @@ export class QueryBase implements QueryInterface {
 
   /**
    * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
-   * @param deposit V3 deposit instance.
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayerAddress Relayer address to simulate with.
    * @param options
    * @param options.gasPrice Optional gas price to use for the simulation.
@@ -71,8 +72,8 @@ export class QueryBase implements QueryInterface {
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayData: RelayData & { destinationChainId: number },
+    relayer = getDefaultRelayer(relayData.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -91,7 +92,12 @@ export class QueryBase implements QueryInterface {
       transport,
     } = options;
 
-    const tx = await this.getUnsignedTxFromDeposit(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isEVM(), `getGasCosts: recipient not an EVM address (${recipient})`);
+    assert(outputToken.isEVM(), `getGasCosts: outputToken not an EVM address (${outputToken})`);
+    assert(exclusiveRelayer.isEVM(), `getGasCosts: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+
+    const tx = await this.getUnsignedTxFromDeposit({ ...relayData, recipient, outputToken, exclusiveRelayer }, relayer);
     const {
       nativeGasCost,
       tokenGasCost,
@@ -116,29 +122,41 @@ export class QueryBase implements QueryInterface {
 
   /**
    * @notice Return ethers.PopulatedTransaction for a fill based on input deposit args
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer Sender of PopulatedTransaction
    * @returns PopulatedTransaction
    */
   getUnsignedTxFromDeposit(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayData: Omit<RelayData, "recipient" | "outputToken"> & {
+      destinationChainId: number;
+      recipient: EvmAddress;
+      outputToken: EvmAddress;
+    },
+    relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<PopulatedTransaction> {
-    return populateV3Relay(this.spokePool, deposit, relayer);
+    return populateV3Relay(this.spokePool, relayData, relayer);
   }
 
   /**
    * @notice Return the gas cost of a simulated transaction
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer Sender of PopulatedTransaction
    * @returns Estimated gas cost based on ethers.VoidSigner's gas estimation
    */
   async getNativeGasCost(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayData: RelayData & { destinationChainId: number },
+    relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<BigNumber> {
-    const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
-    const voidSigner = new VoidSigner(relayer, this.provider);
+    const { recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isEVM(), `getNativeGasCost: recipient not an EVM address (${recipient})`);
+    assert(outputToken.isEVM(), `getNativeGasCost: outputToken not an EVM address (${outputToken})`);
+    assert(exclusiveRelayer.isEVM(), `getNativeGasCost: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+
+    const unsignedTx = await this.getUnsignedTxFromDeposit(
+      { ...relayData, recipient, outputToken, exclusiveRelayer },
+      relayer
+    );
+    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     return voidSigner.estimateGas(unsignedTx);
   }
 
@@ -152,7 +170,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = getDefaultSimulatedRelayerAddress(unsignedTx.chainId),
+    relayer = getDefaultRelayer(unsignedTx.chainId),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;
@@ -161,7 +179,7 @@ export class QueryBase implements QueryInterface {
     const { opStackL2GasUnits, opStackL1DataFeeMultiplier = toBNWei("1") } = options || {};
     const { chainId } = await this.provider.getNetwork();
     assert(isOptimismL2Provider(this.provider), `Unexpected provider for chain ID ${chainId}.`);
-    const voidSigner = new VoidSigner(relayer, this.provider);
+    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     const populatedTransaction = await voidSigner.populateTransaction({
       ...unsignedTx,
       gasLimit: opStackL2GasUnits, // prevents additional gas estimation call
@@ -183,7 +201,7 @@ export class QueryBase implements QueryInterface {
    */
   async estimateGas(
     unsignedTx: PopulatedTransaction,
-    senderAddress: string,
+    senderAddress: Address,
     provider: providers.Provider | L2Provider<providers.Provider>,
     options: Partial<{
       gasPrice: BigNumberish;
@@ -204,7 +222,7 @@ export class QueryBase implements QueryInterface {
     } = options || {};
 
     const { chainId } = await provider.getNetwork();
-    const voidSigner = new VoidSigner(senderAddress, provider);
+    const voidSigner = new VoidSigner(senderAddress.toEvmAddress(), provider);
 
     // Estimate the Gas units required to submit this transaction.
     const queries = [

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

@@ -7,7 +7,7 @@ import { CUSTOM_GAS_TOKENS } from "../../constants";
 import { chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
 import { SVMProvider as svmProvider } from "../../arch/svm";
-import { DEFAULT_LOGGER, getDefaultSimulatedRelayerAddress, Logger } from "../relayFeeCalculator";
+import { DEFAULT_LOGGER, getDefaultRelayer, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
 import { SvmQuery } from "./svmQuery";
 
@@ -25,7 +25,7 @@ export class QueryBase__factory {
     provider: providers.Provider | svmProvider,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
-    simulatedRelayerAddress = getDefaultSimulatedRelayerAddress(chainId),
+    relayerAddress = getDefaultRelayer(chainId),
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"
@@ -34,12 +34,13 @@ export class QueryBase__factory {
 
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
     if (customGasTokenSymbol) {
+      assert(relayerAddress.isEVM());
       return new CustomGasTokenQueries({
         queryBaseArgs: [
           provider as providers.Provider,
           symbolMapping,
           spokePoolAddress,
-          simulatedRelayerAddress,
+          relayerAddress,
           logger,
           coingeckoProApiKey,
           fixedGasPrice[chainId],
@@ -49,11 +50,12 @@ export class QueryBase__factory {
       });
     }
     if (chainIsSvm(chainId)) {
+      assert(relayerAddress.isSVM());
       return new SvmQuery(
         provider as svmProvider,
         symbolMapping,
         SvmAddress.from(spokePoolAddress),
-        SvmAddress.from(simulatedRelayerAddress),
+        relayerAddress,
         logger,
         coingeckoProApiKey,
         fixedGasPrice[chainId],
@@ -66,11 +68,12 @@ export class QueryBase__factory {
       ? asL2Provider(provider as providers.Provider)
       : (provider as providers.Provider);
 
+    assert(relayerAddress.isEVM());
     return new QueryBase(
       provider,
       symbolMapping,
       spokePoolAddress,
-      simulatedRelayerAddress,
+      relayerAddress,
       logger,
       coingeckoProApiKey,
       fixedGasPrice[chainId],

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

@@ -1,3 +1,4 @@
+import assert from "assert";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
@@ -17,17 +18,17 @@ import {
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
 import { getGasPriceEstimate } from "../../gasPriceOracle";
-import { Deposit } from "../../interfaces";
+import { RelayData } from "../../interfaces";
 import {
+  Address,
   BigNumber,
   BigNumberish,
   SvmAddress,
   TransactionCostEstimate,
   getRelayDataHash,
-  toAddressType,
   toBN,
 } from "../../utils";
-import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { SymbolMappingType } from "./";
 
 /**
@@ -65,7 +66,7 @@ export class SvmQuery implements QueryInterface {
 
   /**
    * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
-   * @param deposit V3 deposit instance.
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param _relayer Relayer address to simulate with.
    * @param options
    * @param options.gasPrice Optional gas price to use for the simulation.
@@ -74,8 +75,8 @@ export class SvmQuery implements QueryInterface {
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
-    deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayData: RelayData & { destinationChainId: number },
+    relayer = getDefaultRelayer(relayData.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -83,10 +84,19 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
-    const relayer = _relayer
-      ? toAddressType(_relayer, deposit.destinationChainId).forceSvmAddress()
-      : this.simulatedRelayerAddress;
-    const fillRelayTx = await this.getFillRelayTx(deposit, relayer.toBase58());
+    const { destinationChainId, recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isSVM(), `getGasCosts: recipient not an SVM address (${recipient})`);
+    assert(outputToken.isSVM(), `getGasCosts: outputToken not an SVM address (${outputToken})`);
+    assert(exclusiveRelayer.isSVM(), `getGasCosts: exclusiveRelayer not an SVM address (${exclusiveRelayer})`);
+    assert(relayer.isSVM());
+
+    const [repaymentChainId, repaymentAddress] = [destinationChainId, relayer]; // These are not important for gas cost simulation.
+    const fillRelayTx = await this.getFillRelayTx(
+      { ...relayData, recipient, outputToken, exclusiveRelayer },
+      relayer,
+      repaymentChainId,
+      repaymentAddress
+    );
 
     const [computeUnitsConsumed, gasPriceEstimate] = await Promise.all([
       toBN(await this.computeUnitEstimator(fillRelayTx)),
@@ -117,77 +127,82 @@ export class SvmQuery implements QueryInterface {
    * @returns Estimated gas cost in compute units
    */
   async getNativeGasCost(
-    deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    deposit: RelayData & { destinationChainId: number },
+    relayer = getDefaultRelayer(deposit.destinationChainId)
   ): Promise<BigNumber> {
-    const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
+    const { destinationChainId, recipient, outputToken, exclusiveRelayer } = deposit;
+    assert(recipient.isSVM(), `getNativeGasCost: recipient not an SVM address (${recipient})`);
+    assert(outputToken.isSVM(), `getNativeGasCost: outputToken not an SVM address (${outputToken})`);
+    assert(exclusiveRelayer.isSVM(), `getNativeGasCost: exclusiveRelayer not an SVM address (${exclusiveRelayer})`);
+    assert(relayer.isSVM());
+
+    const [repaymentChainId, repaymentAddress] = [destinationChainId, relayer]; // These are not important for gas cost simulation.
+    const fillRelayTx = await this.getFillRelayTx(
+      { ...deposit, recipient, outputToken, exclusiveRelayer },
+      relayer,
+      repaymentChainId,
+      repaymentAddress
+    );
     return toBN(await this.computeUnitEstimator(fillRelayTx));
   }
 
   /**
    * @notice Return the fillRelay transaction for a given deposit
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer SVM address of the relayer
    * @returns FillRelay transaction
    */
-  async getFillRelayTx(
-    deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-    repaymentChainId = deposit.destinationChainId,
-    repaymentAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+  protected async getFillRelayTx(
+    relayData: Omit<RelayData, "recipent" | "outputToken"> & {
+      destinationChainId: number;
+      recipient: SvmAddress;
+      outputToken: SvmAddress;
+    },
+    relayer: SvmAddress,
+    repaymentChainId: number,
+    repaymentAddress: Address
   ) {
-    const toSvmAddress = (address: string, chainId: number) =>
-      toAddress(toAddressType(address, chainId).forceSvmAddress());
+    const { depositor, recipient, inputToken, outputToken, exclusiveRelayer, destinationChainId } = relayData;
 
-    const { depositor, recipient, inputToken, outputToken, exclusiveRelayer, originChainId, destinationChainId } =
-      deposit;
+    // tsc appeasement...should be unnecessary, but isn't. @todo Identify why.
+    assert(recipient.isSVM(), `getFillRelayTx: recipient not an SVM address (${recipient})`);
+    assert(
+      repaymentAddress.isValidOn(repaymentChainId),
+      `getFillRelayTx: repayment address ${repaymentAddress} not valid on chain ${repaymentChainId})`
+    );
 
     const program = toAddress(this.spokePool);
-    const relayer = _relayer
-      ? toAddressType(_relayer, deposit.destinationChainId).forceSvmAddress()
-      : this.simulatedRelayerAddress;
-
-    const _relayDataHash = getRelayDataHash(deposit, destinationChainId);
+    const _relayDataHash = getRelayDataHash(relayData, destinationChainId);
     const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
     const [state, delegate] = await Promise.all([
       getStatePda(program),
-      getFillRelayDelegatePda(
-        relayDataHash,
-        BigInt(repaymentChainId),
-        toSvmAddress(repaymentAddress, repaymentChainId),
-        program
-      ),
+      getFillRelayDelegatePda(relayDataHash, BigInt(repaymentChainId), toAddress(repaymentAddress), program),
     ]);
 
-    const _mint = toAddressType(outputToken, destinationChainId).forceSvmAddress();
-    const mint = toAddress(_mint);
+    const mint = toAddress(outputToken);
     const mintInfo = await fetchMint(this.provider, mint);
 
     const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
-      getAssociatedTokenAddress(
-        toAddressType(deposit.recipient, destinationChainId).forceSvmAddress(),
-        _mint,
-        mintInfo.programAddress
-      ),
-      getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), _mint, mintInfo.programAddress),
-      getFillStatusPda(program, deposit, destinationChainId),
-      getEventAuthority(),
+      getAssociatedTokenAddress(recipient, outputToken, mintInfo.programAddress),
+      getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), outputToken, mintInfo.programAddress),
+      getFillStatusPda(program, relayData, destinationChainId),
+      getEventAuthority(program),
     ]);
 
-    const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
-      depositor: toSvmAddress(depositor, originChainId),
-      recipient: toSvmAddress(recipient, destinationChainId),
-      exclusiveRelayer: toSvmAddress(exclusiveRelayer, destinationChainId),
-      inputToken: toSvmAddress(inputToken, originChainId),
+    const svmRelayData: SvmSpokeClient.FillRelayInput["relayData"] = {
+      depositor: toAddress(depositor),
+      recipient: toAddress(recipient),
+      exclusiveRelayer: toAddress(exclusiveRelayer),
+      inputToken: toAddress(inputToken),
       outputToken: mint,
-      inputAmount: deposit.inputAmount.toBigInt(),
-      outputAmount: deposit.outputAmount.toBigInt(),
-      originChainId: deposit.originChainId,
-      depositId: new Uint8Array(intToU8Array32(deposit.depositId.toNumber())),
-      fillDeadline: deposit.fillDeadline,
-      exclusivityDeadline: deposit.exclusivityDeadline,
-      message: new Uint8Array(Buffer.from(deposit.message, "hex")),
+      inputAmount: relayData.inputAmount.toBigInt(),
+      outputAmount: relayData.outputAmount.toBigInt(),
+      originChainId: relayData.originChainId,
+      depositId: new Uint8Array(intToU8Array32(relayData.depositId.toNumber())),
+      fillDeadline: relayData.fillDeadline,
+      exclusivityDeadline: relayData.exclusivityDeadline,
+      message: new Uint8Array(Buffer.from(relayData.message, "hex")),
     };
 
     const simulatedSigner = SolanaVoidSigner(relayer.toBase58());
@@ -205,9 +220,9 @@ export class SvmQuery implements QueryInterface {
       eventAuthority,
       program,
       relayHash: relayDataHash,
-      relayData,
+      relayData: svmRelayData,
       repaymentChainId: BigInt(repaymentChainId),
-      repaymentAddress: toSvmAddress(repaymentAddress, repaymentChainId),
+      repaymentAddress: toAddress(repaymentAddress),
     };
     // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
     // if it doesn't exist.