@across-protocol/sdk 4.3.124 → 4.3.125

package/src/utils/abi/typechain/ICoreDepositWallet.ts

@@ -25,16 +25,24 @@ import type {
 export interface ICoreDepositWalletInterface extends utils.Interface {
   functions: {
     "deposit(uint256,uint32)": FunctionFragment;
+    "depositFor(address,uint256,uint32)": FunctionFragment;
   };
 
-  getFunction(nameOrSignatureOrTopic: "deposit"): FunctionFragment;
+  getFunction(
+    nameOrSignatureOrTopic: "deposit" | "depositFor"
+  ): FunctionFragment;
 
   encodeFunctionData(
     functionFragment: "deposit",
     values: [BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "depositFor",
+    values: [string, BigNumberish, BigNumberish]
+  ): string;
 
   decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "depositFor", data: BytesLike): Result;
 
   events: {};
 }
@@ -71,6 +79,13 @@ export interface ICoreDepositWallet extends BaseContract {
       destinationDex: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<ContractTransaction>;
+
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
   };
 
   deposit(
@@ -79,12 +94,26 @@ export interface ICoreDepositWallet extends BaseContract {
     overrides?: Overrides & { from?: string }
   ): Promise<ContractTransaction>;
 
+  depositFor(
+    recipient: string,
+    amount: BigNumberish,
+    destinationId: BigNumberish,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
   callStatic: {
     deposit(
       amount: BigNumberish,
       destinationDex: BigNumberish,
       overrides?: CallOverrides
     ): Promise<void>;
+
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
   };
 
   filters: {};
@@ -95,6 +124,13 @@ export interface ICoreDepositWallet extends BaseContract {
       destinationDex: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<BigNumber>;
+
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -103,5 +139,12 @@ export interface ICoreDepositWallet extends BaseContract {
       destinationDex: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<PopulatedTransaction>;
+
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
   };
 }

package/src/utils/abi/typechain/{ITelepathyBroadcaster.ts → IForwardDepositReceiver.ts}

@@ -22,29 +22,29 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface ITelepathyBroadcasterInterface extends utils.Interface {
+export interface IForwardDepositReceiverInterface extends utils.Interface {
   functions: {
-    "send(uint16,address,bytes)": FunctionFragment;
+    "depositFor(address,uint256,uint32)": FunctionFragment;
   };
 
-  getFunction(nameOrSignatureOrTopic: "send"): FunctionFragment;
+  getFunction(nameOrSignatureOrTopic: "depositFor"): FunctionFragment;
 
   encodeFunctionData(
-    functionFragment: "send",
-    values: [BigNumberish, string, BytesLike]
+    functionFragment: "depositFor",
+    values: [string, BigNumberish, BigNumberish]
   ): string;
 
-  decodeFunctionResult(functionFragment: "send", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "depositFor", data: BytesLike): Result;
 
   events: {};
 }
 
-export interface ITelepathyBroadcaster extends BaseContract {
+export interface IForwardDepositReceiver extends BaseContract {
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: ITelepathyBroadcasterInterface;
+  interface: IForwardDepositReceiverInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -66,46 +66,46 @@ export interface ITelepathyBroadcaster extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    send(
-      _recipientChainId: BigNumberish,
-      _recipientAddress: string,
-      _data: BytesLike,
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<ContractTransaction>;
   };
 
-  send(
-    _recipientChainId: BigNumberish,
-    _recipientAddress: string,
-    _data: BytesLike,
+  depositFor(
+    recipient: string,
+    amount: BigNumberish,
+    destinationId: BigNumberish,
     overrides?: Overrides & { from?: string }
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    send(
-      _recipientChainId: BigNumberish,
-      _recipientAddress: string,
-      _data: BytesLike,
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<string>;
+    ): Promise<void>;
   };
 
   filters: {};
 
   estimateGas: {
-    send(
-      _recipientChainId: BigNumberish,
-      _recipientAddress: string,
-      _data: BytesLike,
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    send(
-      _recipientChainId: BigNumberish,
-      _recipientAddress: string,
-      _data: BytesLike,
+    depositFor(
+      recipient: string,
+      amount: BigNumberish,
+      destinationId: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<PopulatedTransaction>;
   };

package/src/utils/abi/typechain/IHyperCoreFlowExecutor.ts

@@ -27,6 +27,8 @@ export type CommonFlowParamsStruct = {
   quoteNonce: BytesLike;
   finalRecipient: string;
   finalToken: string;
+  destinationDex: BigNumberish;
+  accountCreationMode: BigNumberish;
   maxBpsToSponsor: BigNumberish;
   extraFeesIncurred: BigNumberish;
 };
@@ -36,6 +38,8 @@ export type CommonFlowParamsStructOutput = [
   string,
   string,
   string,
+  number,
+  number,
   BigNumber,
   BigNumber
 ] & {
@@ -43,6 +47,8 @@ export type CommonFlowParamsStructOutput = [
   quoteNonce: string;
   finalRecipient: string;
   finalToken: string;
+  destinationDex: number;
+  accountCreationMode: number;
   maxBpsToSponsor: BigNumber;
   extraFeesIncurred: BigNumber;
 };
@@ -57,9 +63,9 @@ export interface IHyperCoreFlowExecutorInterface extends utils.Interface {
     "baseToken()": FunctionFragment;
     "cancelLimitOrderByCloid(address,uint128)": FunctionFragment;
     "donationBox()": FunctionFragment;
-    "executeFlow((uint256,bytes32,address,address,uint256,uint256),uint256)": FunctionFragment;
-    "executeSimpleTransferFlow((uint256,bytes32,address,address,uint256,uint256))": FunctionFragment;
-    "fallbackHyperEVMFlow((uint256,bytes32,address,address,uint256,uint256))": FunctionFragment;
+    "executeFlow((uint256,bytes32,address,address,uint32,uint8,uint256,uint256),uint256)": FunctionFragment;
+    "executeSimpleTransferFlow((uint256,bytes32,address,address,uint32,uint8,uint256,uint256))": FunctionFragment;
+    "fallbackHyperEVMFlow((uint256,bytes32,address,address,uint32,uint8,uint256,uint256))": FunctionFragment;
     "finalizeSwapFlows(address,bytes32[],uint64[])": FunctionFragment;
     "predictSwapHandler(address)": FunctionFragment;
     "sendSponsorshipFundsToSwapHandler(address,uint256)": FunctionFragment;

package/src/utils/abi/typechain/IOFT.ts

@@ -86,11 +86,12 @@ export interface IOFTInterface extends utils.Interface {
   functions: {
     "quoteSend((uint32,bytes32,uint256,uint256,bytes,bytes,bytes),bool)": FunctionFragment;
     "send((uint32,bytes32,uint256,uint256,bytes,bytes,bytes),(uint256,uint256),address)": FunctionFragment;
+    "sharedDecimals()": FunctionFragment;
     "token()": FunctionFragment;
   };
 
   getFunction(
-    nameOrSignatureOrTopic: "quoteSend" | "send" | "token"
+    nameOrSignatureOrTopic: "quoteSend" | "send" | "sharedDecimals" | "token"
   ): FunctionFragment;
 
   encodeFunctionData(
@@ -101,10 +102,18 @@ export interface IOFTInterface extends utils.Interface {
     functionFragment: "send",
     values: [SendParamStruct, MessagingFeeStruct, string]
   ): string;
+  encodeFunctionData(
+    functionFragment: "sharedDecimals",
+    values?: undefined
+  ): string;
   encodeFunctionData(functionFragment: "token", values?: undefined): string;
 
   decodeFunctionResult(functionFragment: "quoteSend", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "send", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "sharedDecimals",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
 
   events: {};
@@ -150,6 +159,8 @@ export interface IOFT extends BaseContract {
       overrides?: PayableOverrides & { from?: string }
     ): Promise<ContractTransaction>;
 
+    sharedDecimals(overrides?: CallOverrides): Promise<[number]>;
+
     token(overrides?: CallOverrides): Promise<[string]>;
   };
 
@@ -166,6 +177,8 @@ export interface IOFT extends BaseContract {
     overrides?: PayableOverrides & { from?: string }
   ): Promise<ContractTransaction>;
 
+  sharedDecimals(overrides?: CallOverrides): Promise<number>;
+
   token(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
@@ -182,6 +195,8 @@ export interface IOFT extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[MessagingReceiptStructOutput, OFTReceiptStructOutput]>;
 
+    sharedDecimals(overrides?: CallOverrides): Promise<number>;
+
     token(overrides?: CallOverrides): Promise<string>;
   };
 
@@ -201,6 +216,8 @@ export interface IOFT extends BaseContract {
       overrides?: PayableOverrides & { from?: string }
     ): Promise<BigNumber>;
 
+    sharedDecimals(overrides?: CallOverrides): Promise<BigNumber>;
+
     token(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
@@ -218,6 +235,8 @@ export interface IOFT extends BaseContract {
       overrides?: PayableOverrides & { from?: string }
     ): Promise<PopulatedTransaction>;
 
+    sharedDecimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/src/utils/abi/typechain/Merkle.ts

@@ -0,0 +1,268 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface MerkleInterface extends utils.Interface {
+  functions: {
+    "getProof(bytes32[],uint256)": FunctionFragment;
+    "getRoot(bytes32[])": FunctionFragment;
+    "hashLeafPairs(bytes32,bytes32)": FunctionFragment;
+    "log2ceil(uint256)": FunctionFragment;
+    "log2ceilBitMagic(uint256)": FunctionFragment;
+    "verifyProof(bytes32,bytes32[],bytes32)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getProof"
+      | "getRoot"
+      | "hashLeafPairs"
+      | "log2ceil"
+      | "log2ceilBitMagic"
+      | "verifyProof"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getProof",
+    values: [BytesLike[], BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoot",
+    values: [BytesLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hashLeafPairs",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "log2ceil",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "log2ceilBitMagic",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "verifyProof",
+    values: [BytesLike, BytesLike[], BytesLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "getProof", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getRoot", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "hashLeafPairs",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "log2ceil", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "log2ceilBitMagic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "verifyProof",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface Merkle extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: MerkleInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getProof(
+      data: BytesLike[],
+      node: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    getRoot(data: BytesLike[], overrides?: CallOverrides): Promise<[string]>;
+
+    hashLeafPairs(
+      left: BytesLike,
+      right: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _hash: string }>;
+
+    log2ceil(x: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    log2ceilBitMagic(
+      x: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    verifyProof(
+      root: BytesLike,
+      proof: BytesLike[],
+      valueToProve: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  getProof(
+    data: BytesLike[],
+    node: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getRoot(data: BytesLike[], overrides?: CallOverrides): Promise<string>;
+
+  hashLeafPairs(
+    left: BytesLike,
+    right: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  log2ceil(x: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+
+  log2ceilBitMagic(
+    x: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  verifyProof(
+    root: BytesLike,
+    proof: BytesLike[],
+    valueToProve: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    getProof(
+      data: BytesLike[],
+      node: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getRoot(data: BytesLike[], overrides?: CallOverrides): Promise<string>;
+
+    hashLeafPairs(
+      left: BytesLike,
+      right: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    log2ceil(x: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+
+    log2ceilBitMagic(
+      x: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    verifyProof(
+      root: BytesLike,
+      proof: BytesLike[],
+      valueToProve: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getProof(
+      data: BytesLike[],
+      node: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRoot(data: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+
+    hashLeafPairs(
+      left: BytesLike,
+      right: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    log2ceil(x: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+
+    log2ceilBitMagic(
+      x: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    verifyProof(
+      root: BytesLike,
+      proof: BytesLike[],
+      valueToProve: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getProof(
+      data: BytesLike[],
+      node: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRoot(
+      data: BytesLike[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    hashLeafPairs(
+      left: BytesLike,
+      right: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    log2ceil(
+      x: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    log2ceilBitMagic(
+      x: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    verifyProof(
+      root: BytesLike,
+      proof: BytesLike[],
+      valueToProve: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}