@cowprotocol/cow-sdk 5.8.0 → 5.9.0

package/dist/common/consts.d.ts

@@ -1,5 +1,5 @@
 import { SupportedChainId } from './chains';
-export declare const BUY_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 export declare const EXTENSIBLE_FALLBACK_HANDLER = "0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5";
 export declare const COMPOSABLE_COW = "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74";
 export declare const COW_SHED_FACTORY = "0x00E989b87700514118Fa55326CD1cCE82faebEF6";
@@ -27,3 +27,13 @@ export declare const EXTENSIBLE_FALLBACK_HANDLER_CONTRACT_ADDRESS: Record<Suppor
  * An object containing the addresses of the `ComposableCow` contracts for each supported chain.
  */
 export declare const COMPOSABLE_COW_CONTRACT_ADDRESS: Record<SupportedChainId, string>;
+/**
+ * An object containing the addresses of wrapped native currencies for each supported chain.
+ */
+export declare const WRAPPED_NATIVE_CURRENCIES: Record<SupportedChainId, string>;
+/**
+ * An object containing the addresses of ETH flow contracts for each supported chain.
+ */
+export declare const ETH_FLOW_ADDRESSES: Record<SupportedChainId, string>;
+export declare const BARN_ETH_FLOW_ADDRESSES: Record<SupportedChainId, string>;
+export declare const MAX_VALID_TO_EPOCH = 4294967295;

package/dist/common/generated/EthFlow.d.ts

@@ -0,0 +1,117 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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 declare namespace EthFlowOrder {
+    type DataStruct = {
+        buyToken: string;
+        receiver: string;
+        sellAmount: BigNumberish;
+        buyAmount: BigNumberish;
+        appData: BytesLike;
+        feeAmount: BigNumberish;
+        validTo: BigNumberish;
+        partiallyFillable: boolean;
+        quoteId: BigNumberish;
+    };
+    type DataStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        string,
+        BigNumber,
+        number,
+        boolean,
+        BigNumber
+    ] & {
+        buyToken: string;
+        receiver: string;
+        sellAmount: BigNumber;
+        buyAmount: BigNumber;
+        appData: string;
+        feeAmount: BigNumber;
+        validTo: number;
+        partiallyFillable: boolean;
+        quoteId: BigNumber;
+    };
+}
+export interface EthFlowInterface extends utils.Interface {
+    functions: {
+        "createOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))": FunctionFragment;
+        "invalidateOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))": FunctionFragment;
+        "orders(bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "createOrder" | "invalidateOrder" | "orders"): FunctionFragment;
+    encodeFunctionData(functionFragment: "createOrder", values: [EthFlowOrder.DataStruct]): string;
+    encodeFunctionData(functionFragment: "invalidateOrder", values: [EthFlowOrder.DataStruct]): string;
+    encodeFunctionData(functionFragment: "orders", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "createOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "invalidateOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "orders", data: BytesLike): Result;
+    events: {};
+}
+export interface EthFlow extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: EthFlowInterface;
+    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: {
+        createOrder(order: EthFlowOrder.DataStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        invalidateOrder(order: EthFlowOrder.DataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        orders(arg0: BytesLike, overrides?: CallOverrides): Promise<[string, number] & {
+            owner: string;
+            validTo: number;
+        }>;
+    };
+    createOrder(order: EthFlowOrder.DataStruct, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    invalidateOrder(order: EthFlowOrder.DataStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    orders(arg0: BytesLike, overrides?: CallOverrides): Promise<[string, number] & {
+        owner: string;
+        validTo: number;
+    }>;
+    callStatic: {
+        createOrder(order: EthFlowOrder.DataStruct, overrides?: CallOverrides): Promise<string>;
+        invalidateOrder(order: EthFlowOrder.DataStruct, overrides?: CallOverrides): Promise<void>;
+        orders(arg0: BytesLike, overrides?: CallOverrides): Promise<[string, number] & {
+            owner: string;
+            validTo: number;
+        }>;
+    };
+    filters: {};
+    estimateGas: {
+        createOrder(order: EthFlowOrder.DataStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        invalidateOrder(order: EthFlowOrder.DataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        orders(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        createOrder(order: EthFlowOrder.DataStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        invalidateOrder(order: EthFlowOrder.DataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        orders(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/common/generated/GPv2Settlement.d.ts

@@ -0,0 +1,107 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface GPv2SettlementInterface extends utils.Interface {
+    functions: {
+        "setPreSignature(bytes,bool)": FunctionFragment;
+        "invalidateOrder(bytes)": FunctionFragment;
+        "domainSeparator()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "setPreSignature" | "invalidateOrder" | "domainSeparator"): FunctionFragment;
+    encodeFunctionData(functionFragment: "setPreSignature", values: [BytesLike, boolean]): string;
+    encodeFunctionData(functionFragment: "invalidateOrder", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "domainSeparator", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "setPreSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "invalidateOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "domainSeparator", data: BytesLike): Result;
+    events: {
+        "Trade(address,address,address,uint256,uint256,uint256,bytes)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Trade"): EventFragment;
+}
+export interface TradeEventObject {
+    owner: string;
+    sellToken: string;
+    buyToken: string;
+    sellAmount: BigNumber;
+    buyAmount: BigNumber;
+    feeAmount: BigNumber;
+    orderUid: string;
+}
+export type TradeEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    string
+], TradeEventObject>;
+export type TradeEventFilter = TypedEventFilter<TradeEvent>;
+export interface GPv2Settlement extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: GPv2SettlementInterface;
+    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: {
+        setPreSignature(orderUid: BytesLike, signed: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        invalidateOrder(orderUid: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        domainSeparator(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    setPreSignature(orderUid: BytesLike, signed: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    invalidateOrder(orderUid: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    domainSeparator(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        setPreSignature(orderUid: BytesLike, signed: boolean, overrides?: CallOverrides): Promise<void>;
+        invalidateOrder(orderUid: BytesLike, overrides?: CallOverrides): Promise<void>;
+        domainSeparator(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "Trade(address,address,address,uint256,uint256,uint256,bytes)"(owner?: string | null, sellToken?: null, buyToken?: null, sellAmount?: null, buyAmount?: null, feeAmount?: null, orderUid?: null): TradeEventFilter;
+        Trade(owner?: string | null, sellToken?: null, buyToken?: null, sellAmount?: null, buyAmount?: null, feeAmount?: null, orderUid?: null): TradeEventFilter;
+    };
+    estimateGas: {
+        setPreSignature(orderUid: BytesLike, signed: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        invalidateOrder(orderUid: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        domainSeparator(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        setPreSignature(orderUid: BytesLike, signed: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        invalidateOrder(orderUid: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        domainSeparator(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/common/generated/factories/EthFlow__factory.d.ts

@@ -0,0 +1,124 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { EthFlow, EthFlowInterface } from "../EthFlow";
+export declare class EthFlow__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "buyToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "receiver";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "sellAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "buyAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "appData";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "feeAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint32";
+                readonly name: "validTo";
+                readonly type: "uint32";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "partiallyFillable";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "int64";
+                readonly name: "quoteId";
+                readonly type: "int64";
+            }];
+            readonly internalType: "struct EthFlowOrder.Data";
+            readonly name: "order";
+            readonly type: "tuple";
+        }];
+        readonly name: "createOrder";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "orderHash";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "buyToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "receiver";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "sellAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "buyAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "appData";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "feeAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint32";
+                readonly name: "validTo";
+                readonly type: "uint32";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "partiallyFillable";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "int64";
+                readonly name: "quoteId";
+                readonly type: "int64";
+            }];
+            readonly internalType: "struct EthFlowOrder.Data";
+            readonly name: "order";
+            readonly type: "tuple";
+        }];
+        readonly name: "invalidateOrder";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "orders";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint32";
+            readonly name: "validTo";
+            readonly type: "uint32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): EthFlowInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): EthFlow;
+}

package/dist/common/generated/factories/GPv2Settlement__factory.d.ts

@@ -0,0 +1,81 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { GPv2Settlement, GPv2SettlementInterface } from "../GPv2Settlement";
+export declare class GPv2Settlement__factory {
+    static readonly abi: readonly [{
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "contract IERC20";
+            readonly name: "sellToken";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "contract IERC20";
+            readonly name: "buyToken";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "sellAmount";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "buyAmount";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "feeAmount";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bytes";
+            readonly name: "orderUid";
+            readonly type: "bytes";
+        }];
+        readonly name: "Trade";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "orderUid";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "signed";
+            readonly type: "bool";
+        }];
+        readonly name: "setPreSignature";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "orderUid";
+            readonly type: "bytes";
+        }];
+        readonly name: "invalidateOrder";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "domainSeparator";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }];
+    static createInterface(): GPv2SettlementInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): GPv2Settlement;
+}

package/dist/common/generated/factories/index.d.ts

@@ -1,5 +1,7 @@
 export { CoWShed__factory } from "./CoWShed__factory";
 export { CoWShedFactory__factory } from "./CoWShedFactory__factory";
 export { ComposableCoW__factory } from "./ComposableCoW__factory";
+export { EthFlow__factory } from "./EthFlow__factory";
 export { ExtensibleFallbackHandler__factory } from "./ExtensibleFallbackHandler__factory";
+export { GPv2Settlement__factory } from "./GPv2Settlement__factory";
 export { TWAP__factory } from "./TWAP__factory";

package/dist/common/generated/index.d.ts

@@ -1,11 +1,15 @@
 export type { CoWShed } from "./CoWShed";
 export type { CoWShedFactory } from "./CoWShedFactory";
 export type { ComposableCoW } from "./ComposableCoW";
+export type { EthFlow } from "./EthFlow";
 export type { ExtensibleFallbackHandler } from "./ExtensibleFallbackHandler";
+export type { GPv2Settlement } from "./GPv2Settlement";
 export type { TWAP } from "./TWAP";
 export * as factories from "./factories";
 export { ComposableCoW__factory } from "./factories/ComposableCoW__factory";
 export { CoWShed__factory } from "./factories/CoWShed__factory";
 export { CoWShedFactory__factory } from "./factories/CoWShedFactory__factory";
+export { EthFlow__factory } from "./factories/EthFlow__factory";
 export { ExtensibleFallbackHandler__factory } from "./factories/ExtensibleFallbackHandler__factory";
+export { GPv2Settlement__factory } from "./factories/GPv2Settlement__factory";
 export { TWAP__factory } from "./factories/TWAP__factory";