@cowprotocol/sdk-contracts-ts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1317 @@
+import { Bytes, TypedDataDomain, SignerLike, TypedDataTypes, BigIntish, AbstractProviderAdapter, SignatureLike, Abi, Address, Provider, Signer, AbstractSigner } from '@cowprotocol/sdk-common';
+
+/**
+ * Value returned by a call to `isValidSignature` if the signature was verified
+ * successfully. The value is defined in the EIP-1271 standard as:
+ * bytes4(keccak256("isValidSignature(bytes32,bytes)"))
+ */
+declare const EIP1271_MAGICVALUE = "0x1626ba7e";
+/**
+ * Marker value indicating a presignature is set.
+ * const PRE_SIGNED = ethersV5.utils.id("GPv2Signing.Scheme.PreSign");
+ */
+declare const PRE_SIGNED = "0xf59c009283ff87aa78203fc4d9c2df025ee851130fb69cc3e068941f6b5e2d6f";
+/**
+ * EIP-1271 signature data.
+ */
+interface Eip1271SignatureData {
+    /**
+     * The verifying contract address.
+     */
+    verifier: string;
+    /**
+     * The arbitrary signature data used for verification.
+     */
+    signature: Bytes;
+}
+/**
+ * EIP-1271 signature of an order.
+ */
+interface Eip1271Signature {
+    /**
+     * The signing scheme used in the signature.
+     */
+    scheme: SigningScheme.EIP1271;
+    /**
+     * The signature data.
+     */
+    data: Eip1271SignatureData;
+}
+/**
+ * Signature data for a pre-signed order.
+ */
+interface PreSignSignature {
+    /**
+     * The signing scheme used in the signature.
+     */
+    scheme: SigningScheme.PRESIGN;
+    /**
+     * The address of the signer.
+     */
+    data: string;
+}
+declare function ecdsaSignTypedData(scheme: EcdsaSigningScheme, domain: TypedDataDomain, types: TypedDataTypes, data: Record<string, unknown>, owner?: SignerLike): Promise<string>;
+/**
+ * Returns the signature for the specified order with the signing scheme encoded
+ * into the signature.
+ *
+ * @param domain The domain to sign the order for. This is used by the smart
+ * contract to ensure orders can't be replayed across different applications,
+ * but also different deployments (as the contract chain ID and address are
+ * mixed into to the domain value).
+ * @param owner The owner for the order used to sign.
+ * @param scheme The signing scheme to use. See {@link SigningScheme} for more
+ * details.
+ * @param order The order to sign.
+ *
+ * @return Encoded signature including signing scheme for the order.
+ */
+declare function signOrder(domain: TypedDataDomain, order: Order, scheme: EcdsaSigningScheme, owner?: SignerLike): Promise<EcdsaSignature>;
+/**
+ * Encodes the necessary data required for the Gnosis Protocol contracts to
+ * verify an EIP-1271 signature.
+ *
+ * @param signature The EIP-1271 signature data to encode.
+ */
+declare function encodeEip1271SignatureData({ verifier, signature }: Eip1271SignatureData): string;
+/**
+ * Decodes a GPv2 EIP-1271-type signature into the actual EIP-1271 signature
+ * and the verifier contract.
+ *
+ * @param signature The EIP-1271 signature data to decode.
+ * @returns decodedSignature The decoded signature object, composed of an
+ * EIP-1271 signature and a verifier.
+ */
+declare function decodeEip1271SignatureData(signature: Bytes): Eip1271SignatureData;
+/**
+ * Returns the signature for cancelling a single order with the specified
+ * signing scheme.
+ *
+ * @param domain The domain to sign the cancellation.
+ * @param orderUid The unique identifier of the order being cancelled.
+ * @param scheme The signing scheme to use. See {@link SigningScheme} for more
+ * details.
+ * @param owner The owner for the order used to sign.
+ *
+ * @return Encoded signature including signing scheme for the cancellation.
+ */
+declare function signOrderCancellation(domain: TypedDataDomain, orderUid: Bytes, scheme: EcdsaSigningScheme, owner?: SignerLike): Promise<EcdsaSignature>;
+/**
+ * Returns the signature for cancelling multiple orders by UID with the
+ * specified signing scheme.
+ *
+ * @param domain The domain to sign the cancellation.
+ * @param orderUids The unique identifiers of the orders to cancel.
+ * @param scheme The signing scheme to use. See {@link SigningScheme} for more
+ * details.
+ * @param owner The owner for the order used to sign.
+ *
+ * @return Encoded signature including signing scheme for the cancellation.
+ */
+declare function signOrderCancellations(domain: TypedDataDomain, orderUids: Bytes[], scheme: EcdsaSigningScheme, owner?: SignerLike): Promise<EcdsaSignature>;
+
+/**
+ * Gnosis Protocol v2 interaction data.
+ */
+interface Interaction {
+    /**
+     * Address of the smart contract to be called in this interaction.
+     */
+    target: string;
+    /**
+     * Call value in wei for the interaction, allowing Ether to be sent.
+     */
+    value: BigIntish;
+    /**
+     * Call data used in the interaction with a smart contract.
+     */
+    callData: Bytes;
+}
+type InteractionLike = Pick<Interaction, 'target'> & Partial<Interaction>;
+/**
+ * Normalizes interaction data so that it is ready to be be ABI encoded.
+ *
+ * @param interaction The interaction to normalize.
+ * @return The normalized interaction.
+ */
+declare function normalizeInteraction(interaction: InteractionLike): Interaction;
+/**
+ * Normalizes data for many interactions so that they can be ABI encoded. This
+ * calls [`normalizeInteraction`] for each interaction.
+ *
+ * @param interactions The interactions to normalize.
+ * @return The normalized interactions.
+ */
+declare function normalizeInteractions(interactions: InteractionLike[]): Interaction[];
+
+/**
+ * The stage an interaction should be executed in.
+ */
+declare enum InteractionStage {
+    /**
+     * A pre-settlement intraction.
+     *
+     * The interaction will be executed before any trading occurs. This can be
+     * used, for example, to perform as EIP-2612 `permit` call for a user trading
+     * in the current settlement.
+     */
+    PRE = 0,
+    /**
+     * An intra-settlement interaction.
+     *
+     * The interaction will be executed after all trade sell amounts are
+     * transferred into the settlement contract, but before the buy amounts are
+     * transferred out to the traders. This can be used, for example, to interact
+     * with on-chain AMMs.
+     */
+    INTRA = 1,
+    /**
+     * A post-settlement interaction.
+     *
+     * The interaction will be executed after all trading has completed.
+     */
+    POST = 2
+}
+/**
+ * Gnosis Protocol v2 trade flags.
+ */
+interface TradeFlags extends OrderFlags {
+    /**
+     * The signing scheme used to encode the signature.
+     */
+    signingScheme: SigningScheme;
+}
+/**
+ * Details representing how an order was executed.
+ */
+interface TradeExecution {
+    /**
+     * The executed trade amount.
+     *
+     * How this amount is used by the settlement contract depends on the order
+     * flags:
+     * - Partially fillable sell orders: the amount of sell tokens to trade.
+     * - Partially fillable buy orders: the amount of buy tokens to trade.
+     * - Fill-or-kill orders: this value is ignored.
+     */
+    executedAmount: BigIntish;
+}
+/**
+ * Order refund data.
+ *
+ * Note: after the London hardfork (specifically the introduction of EIP-3529)
+ * order refunds have become meaningless as the refunded amount is less than the
+ * gas cost of triggering the refund. The logic surrounding this feature is kept
+ * in order to keep full test coverage and in case the value of a refund will be
+ * increased again in the future. However, order refunds should not be used in
+ * an actual settlement.
+ */
+interface OrderRefunds {
+    /** Refund storage used for order filled amount */
+    filledAmounts: Bytes[];
+    /** Refund storage used for order pre-signature */
+    preSignatures: Bytes[];
+}
+/**
+ * Table mapping token addresses to their respective clearing prices.
+ */
+type Prices = Record<string, BigIntish | undefined>;
+/**
+ * Encoded settlement parameters.
+ */
+type EncodedSettlement = [
+    /** Tokens. */
+    string[],
+    /** Clearing prices. */
+    BigIntish[],
+    /** Encoded trades. */
+    Trade[],
+    /** Encoded interactions. */
+    [
+        Interaction[],
+        Interaction[],
+        Interaction[]
+    ]
+];
+/**
+ * An object listing all flag options in order along with their bit offset.
+ */
+declare const FLAG_MASKS: {
+    readonly kind: {
+        readonly offset: 0;
+        readonly options: readonly [OrderKind.SELL, OrderKind.BUY];
+    };
+    readonly partiallyFillable: {
+        readonly offset: 1;
+        readonly options: readonly [false, true];
+    };
+    readonly sellTokenBalance: {
+        readonly offset: 2;
+        readonly options: readonly [OrderBalance.ERC20, undefined, OrderBalance.EXTERNAL, OrderBalance.INTERNAL];
+    };
+    readonly buyTokenBalance: {
+        readonly offset: 4;
+        readonly options: readonly [OrderBalance.ERC20, OrderBalance.INTERNAL];
+    };
+    readonly signingScheme: {
+        readonly offset: 5;
+        readonly options: readonly [SigningScheme.EIP712, SigningScheme.ETHSIGN, SigningScheme.EIP1271, SigningScheme.PRESIGN];
+    };
+};
+type FlagKey = keyof typeof FLAG_MASKS;
+type FlagOptions<K extends FlagKey> = (typeof FLAG_MASKS)[K]['options'];
+type FlagValue<K extends FlagKey> = Exclude<FlagOptions<K>[number], undefined>;
+/**
+ * Encodes signing scheme as a bitfield.
+ *
+ * @param scheme The signing scheme to encode.
+ * @return The bitfield result.
+ */
+declare function encodeSigningScheme(scheme: SigningScheme): number;
+/**
+ * Decodes signing scheme from a bitfield.
+ *
+ * @param flag The encoded order flag.
+ * @return The decoded signing scheme.
+ */
+declare function decodeSigningScheme(flags: BigIntish): SigningScheme;
+/**
+ * Encodes order flags as a bitfield.
+ *
+ * @param flags The order flags to encode.
+ * @return The bitfield result.
+ */
+declare function encodeOrderFlags(flags: OrderFlags): number;
+/**
+ * Decode order flags from a bitfield.
+ *
+ * @param flags The order flags encoded as a bitfield.
+ * @return The decoded order flags.
+ */
+declare function decodeOrderFlags(flags: BigIntish): OrderFlags;
+/**
+ * Encodes trade flags as a bitfield.
+ *
+ * @param flags The trade flags to encode.
+ * @return The bitfield result.
+ */
+declare function encodeTradeFlags(flags: TradeFlags): number;
+/**
+ * Decode trade flags from a bitfield.
+ *
+ * @param flags The trade flags encoded as a bitfield.
+ * @return The bitfield result.
+ */
+declare function decodeTradeFlags(flags: BigIntish): TradeFlags;
+declare function encodeSignatureData(sig: Signature): string;
+declare function decodeSignatureOwner(domain: TypedDataDomain, order: Order, scheme: SigningScheme, sig: Bytes): string;
+/**
+ * Encodes a trade to be used with the settlement contract.
+ */
+declare function encodeTrade(tokens: TokenRegistry, order: Order, signature: Signature, { executedAmount }: TradeExecution): Trade;
+/**
+ * A class used for tracking tokens when encoding settlements.
+ *
+ * This is used as settlement trades reference tokens by index instead of
+ * directly by address for multiple reasons:
+ * - Reduce encoding size of orders to save on `calldata` gas.
+ * - Direct access to a token's clearing price on settlement instead of
+ *   requiring a search.
+ */
+declare class TokenRegistry {
+    /**
+     * Creates a new TokenRegistry instance
+     *
+     * @param adapter Provider adapter implementation
+     */
+    constructor(adapter?: AbstractProviderAdapter);
+    private readonly _tokens;
+    private readonly _tokenMap;
+    /**
+     * Gets the array of token addresses currently stored in the registry.
+     */
+    get addresses(): string[];
+    /**
+     * Retrieves the token index for the specified token address. If the token is
+     * not in the registry, it will be added.
+     *
+     * @param token The token address to add to the registry.
+     * @return The token index.
+     */
+    index(token: string): number;
+}
+/**
+ * Encoder for CoW Protocol settlement transactions.
+ *
+ * This class provides methods to encode trades, interactions, and order refunds
+ * for CoW Protocol settlements. It maintains state for tokens, trades, and
+ * interactions across different execution stages.
+ *
+ * @example
+ * ```typescript
+ * const encoder = new SettlementEncoder(domain, adapter)
+ * encoder.encodeTrade(order, signature)
+ * const settlement = encoder.encodedSettlement(prices)
+ * ```
+ */
+declare class SettlementEncoder {
+    readonly domain: TypedDataDomain;
+    private readonly _tokens;
+    private readonly _trades;
+    private readonly _interactions;
+    private readonly _orderRefunds;
+    /**
+     * Creates a new settlement encoder instance.
+     * @param domain Domain used for signing orders. See {@link signOrder} for
+     * more details.
+     */
+    constructor(domain: TypedDataDomain, adapter?: AbstractProviderAdapter);
+    /**
+     * Gets the array of token addresses used by the currently encoded orders.
+     */
+    get tokens(): string[];
+    /**
+     * Gets the encoded trades.
+     */
+    get trades(): Trade[];
+    /**
+     * Gets all encoded interactions for all stages.
+     *
+     * Note that order refund interactions are included as post-interactions.
+     */
+    get interactions(): [Interaction[], Interaction[], Interaction[]];
+    /**
+     * Gets the order refunds encoded as interactions.
+     */
+    get encodedOrderRefunds(): Interaction[];
+    /**
+     * Returns a clearing price vector for the current settlement tokens from the
+     * provided price map.
+     *
+     * @param prices The price map from token address to price.
+     * @return The price vector.
+     */
+    clearingPrices(prices: Prices): BigIntish[];
+    /**
+     * Encodes a trade from a signed order and executed amount, appending it to
+     * the `calldata` bytes that are being built.
+     *
+     * Additionally, if the order references new tokens that the encoder has not
+     * yet seen, they are added to the tokens array.
+     *
+     * @param order The order of the trade to encode.
+     * @param signature The signature for the order data.
+     * @param tradeExecution The execution details for the trade.
+     */
+    encodeTrade(order: Order, signature: Signature, { executedAmount }?: Partial<TradeExecution>): void;
+    /**
+     * Signs an order and encodes a trade with that order.
+     *
+     * @param order The order to sign for the trade.
+     * @param scheme The signing scheme to use. See {@link SigningScheme} for more
+     * details.
+     * @param tradeExecution The execution details for the trade.
+     * @param owner The externally owned account that should sign the order.
+     */
+    signEncodeTrade(order: Order, scheme: EcdsaSigningScheme, tradeExecution?: Partial<TradeExecution>, owner?: SignerLike): Promise<void>;
+    /**
+     * Encodes the input interaction in the packed format accepted by the smart
+     * contract and adds it to the interactions encoded so far.
+     *
+     * @param stage The stage the interaction should be executed.
+     * @param interaction The interaction to encode.
+     */
+    encodeInteraction(interaction: InteractionLike, stage?: InteractionStage): void;
+    /**
+     * Encodes order UIDs for gas refunds.
+     *
+     * @param settlement The address of the settlement contract.
+     * @param orderRefunds The order refunds to encode.
+     */
+    encodeOrderRefunds(orderRefunds: Partial<OrderRefunds>): void;
+    /**
+     * Returns the encoded settlement parameters.
+     */
+    encodedSettlement(prices: Prices): EncodedSettlement;
+    /**
+     * Returns an encoded settlement that exclusively performs setup interactions.
+     * This method can be used, for example, to set the settlement contract's
+     * allowances to other protocols it may interact with.
+     *
+     * @param interactions The list of setup interactions to encode.
+     */
+    static encodedSetup(...interactions: InteractionLike[]): EncodedSettlement;
+}
+/**
+ * Decodes an order from a settlement trade.
+ *
+ * @param trade The trade to decode into an order.
+ * @param tokens The list of token addresses as they appear in the settlement.
+ * @returns The decoded order.
+ */
+declare function decodeOrder(trade: Trade, tokens: string[]): Order;
+
+/**
+ * The signing scheme used to sign the order.
+ */
+declare enum SigningScheme {
+    /**
+     * The EIP-712 typed data signing scheme. This is the preferred scheme as it
+     * provides more infomation to wallets performing the signature on the data
+     * being signed.
+     *
+     * <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#definition-of-domainseparator>
+     */
+    EIP712 = 0,
+    /**
+     * Message signed using eth_sign RPC call.
+     */
+    ETHSIGN = 1,
+    /**
+     * Smart contract signatures as defined in EIP-1271.
+     *
+     * <https://eips.ethereum.org/EIPS/eip-1271>
+     */
+    EIP1271 = 2,
+    /**
+     * Pre-signed order.
+     */
+    PRESIGN = 3
+}
+type EcdsaSigningScheme = SigningScheme.EIP712 | SigningScheme.ETHSIGN;
+/**
+ * The signature of an order.
+ */
+type Signature = EcdsaSignature | Eip1271Signature | PreSignSignature;
+/**
+ * ECDSA signature of an order.
+ */
+interface EcdsaSignature {
+    /**
+     * The signing scheme used in the signature.
+     */
+    scheme: EcdsaSigningScheme;
+    /**
+     * The ECDSA signature.
+     */
+    data: SignatureLike;
+}
+/**
+ * Trade parameters used in a settlement.
+ */
+type Trade = TradeExecution & Omit<NormalizedOrder, 'sellToken' | 'buyToken' | 'kind' | 'partiallyFillable' | 'sellTokenBalance' | 'buyTokenBalance'> & {
+    /**
+     * The index of the sell token in the settlement.
+     */
+    sellTokenIndex: BigIntish;
+    /**
+     * The index of the buy token in the settlement.
+     */
+    buyTokenIndex: BigIntish;
+    /**
+     * Encoded order flags.
+     */
+    flags: BigIntish;
+    /**
+     * Signature data.
+     */
+    signature: Bytes;
+};
+/**
+ * Gnosis Protocol v2 order data.
+ */
+interface Order {
+    /**
+     * Sell token address.
+     */
+    sellToken: string;
+    /**
+     * Buy token address.
+     */
+    buyToken: string;
+    /**
+     * An optional address to receive the proceeds of the trade instead of the
+     * owner (i.e. the order signer).
+     */
+    receiver?: string;
+    /**
+     * The order sell amount.
+     *
+     * For fill or kill sell orders, this amount represents the exact sell amount
+     * that will be executed in the trade. For fill or kill buy orders, this
+     * amount represents the maximum sell amount that can be executed. For partial
+     * fill orders, this represents a component of the limit price fraction.
+     */
+    sellAmount: BigIntish;
+    /**
+     * The order buy amount.
+     *
+     * For fill or kill sell orders, this amount represents the minimum buy amount
+     * that can be executed in the trade. For fill or kill buy orders, this amount
+     * represents the exact buy amount that will be executed. For partial fill
+     * orders, this represents a component of the limit price fraction.
+     */
+    buyAmount: BigIntish;
+    /**
+     * The timestamp this order is valid until
+     */
+    validTo: Timestamp;
+    /**
+     * Arbitrary application specific data that can be added to an order. This can
+     * also be used to ensure uniqueness between two orders with otherwise the
+     * exact same parameters.
+     */
+    appData: HashLike;
+    /**
+     * Fee to give to the protocol.
+     */
+    feeAmount: BigIntish;
+    /**
+     * The order kind.
+     */
+    kind: OrderKind;
+    /**
+     * Specifies whether or not the order is partially fillable.
+     */
+    partiallyFillable: boolean;
+    /**
+     * Specifies how the sell token balance will be withdrawn. It can either be
+     * taken using ERC20 token allowances made directly to the Vault relayer
+     * (default) or using Balancer Vault internal or external balances.
+     */
+    sellTokenBalance?: OrderBalance;
+    /**
+     * Specifies how the buy token balance will be paid. It can either be paid
+     * directly in ERC20 tokens (default) in Balancer Vault internal balances.
+     */
+    buyTokenBalance?: OrderBalance;
+}
+/**
+ * Gnosis Protocol v2 order cancellation data.
+ */
+interface OrderCancellations {
+    /**
+     * The unique identifier of the order to be cancelled.
+     */
+    orderUids: Bytes[];
+}
+/**
+ * Order kind.
+ */
+declare enum OrderKind {
+    /**
+     * A sell order.
+     */
+    SELL = "sell",
+    /**
+     * A buy order.
+     */
+    BUY = "buy"
+}
+
+/**
+ * Marker address to indicate that an order is buying Ether.
+ *
+ * Note that this address is only has special meaning in the `buyToken` and will
+ * be treated as a ERC20 token address in the `sellToken` position, causing the
+ * settlement to revert.
+ */
+declare const BUY_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/**
+ * Gnosis Protocol v2 order flags.
+ */
+type OrderFlags = Pick<Order, 'kind' | 'partiallyFillable' | 'sellTokenBalance' | 'buyTokenBalance'>;
+/**
+ * A timestamp value.
+ */
+type Timestamp = number | Date;
+/**
+ * A hash-like app data value.
+ */
+type HashLike = Bytes | number;
+/**
+ * Order balance configuration.
+ */
+declare enum OrderBalance {
+    /**
+     * Use ERC20 token balances.
+     */
+    ERC20 = "erc20",
+    /**
+     * Use Balancer Vault external balances.
+     *
+     * This can only be specified specified for the sell balance and allows orders
+     * to re-use Vault ERC20 allowances. When specified for the buy balance, it
+     * will be treated as {@link OrderBalance.ERC20}.
+     */
+    EXTERNAL = "external",
+    /**
+     * Use Balancer Vault internal balances.
+     */
+    INTERNAL = "internal"
+}
+/**
+ * The EIP-712 type fields definition for a Gnosis Protocol v2 order.
+ */
+declare const ORDER_TYPE_FIELDS: {
+    name: string;
+    type: string;
+}[];
+/**
+ * The EIP-712 type hash for a Gnosis Protocol v2 order.
+ * ethersV5.utils.id(
+  `Order(${ORDER_TYPE_FIELDS.map(({ name, type }) => `${type} ${name}`).join(
+    ",",
+  )})`,
+);
+ */
+declare const ORDER_TYPE_HASH = "0xd5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489";
+/**
+ * The EIP-712 type fields definition for a Gnosis Protocol v2 order.
+ */
+declare const CANCELLATIONS_TYPE_FIELDS: {
+    name: string;
+    type: string;
+}[];
+/**
+ * Normalizes a timestamp value to a Unix timestamp.
+ * @param time The timestamp value to normalize.
+ * @return Unix timestamp or number of seconds since the Unix Epoch.
+ */
+declare function timestamp(t: Timestamp): number;
+/**
+ * Normalizes an app data value to a 32-byte hash.
+ * @param hashLike A hash-like value to normalize.
+ * @returns A 32-byte hash encoded as a hex-string.
+ */
+declare function hashify(h: HashLike): string;
+/**
+ * Normalizes the balance configuration for a buy token. Specifically, this
+ * function ensures that {@link OrderBalance.EXTERNAL} gets normalized to
+ * {@link OrderBalance.ERC20}.
+ *
+ * @param balance The balance configuration.
+ * @returns The normalized balance configuration.
+ */
+declare function normalizeBuyTokenBalance(balance: OrderBalance | undefined): OrderBalance.ERC20 | OrderBalance.INTERNAL;
+/**
+ * Normalized representation of an {@link Order} for EIP-712 operations.
+ */
+type NormalizedOrder = Omit<Order, 'validTo' | 'appData' | 'kind' | 'sellTokenBalance' | 'buyTokenBalance'> & {
+    receiver: string;
+    validTo: number;
+    appData: string;
+    kind: 'sell' | 'buy';
+    sellTokenBalance: 'erc20' | 'external' | 'internal';
+    buyTokenBalance: 'erc20' | 'internal';
+};
+/**
+ * Normalizes an order for hashing and signing, so that it can be used with
+ * Ethers.js for EIP-712 operations.
+ * @param hashLike A hash-like value to normalize.
+ * @returns A 32-byte hash encoded as a hex-string.
+ */
+declare function normalizeOrder(order: Order): NormalizedOrder;
+/**
+ * Compute the 32-byte signing hash for the specified order.
+ *
+ * @param domain The EIP-712 domain separator to compute the hash for.
+ * @param types The order to compute the digest for.
+ * @return Hex-encoded 32-byte order digest.
+ */
+declare function hashTypedData(domain: TypedDataDomain, types: TypedDataTypes, data: Record<string, unknown>): string;
+/**
+ * Compute the 32-byte signing hash for the specified order.
+ *
+ * @param domain The EIP-712 domain separator to compute the hash for.
+ * @param order The order to compute the digest for.
+ * @return Hex-encoded 32-byte order digest.
+ */
+declare function hashOrder(domain: TypedDataDomain, order: Order): string;
+/**
+ * The byte length of an order UID.
+ */
+declare const ORDER_UID_LENGTH = 56;
+/**
+ * Order unique identifier parameters.
+ */
+interface OrderUidParams {
+    /**
+     * The EIP-712 order struct hash.
+     */
+    orderDigest: string;
+    /**
+     * The owner of the order.
+     */
+    owner: string;
+    /**
+     * The timestamp this order is valid until.
+     */
+    validTo: number | Date;
+}
+/**
+ * Computes the order UID for an order and the given owner.
+ */
+declare function computeOrderUid(domain: TypedDataDomain, order: Order, owner: string): string;
+/**
+ * Compute the unique identifier describing a user order in the settlement
+ * contract.
+ *
+ * @param OrderUidParams The parameters used for computing the order's unique
+ * identifier.
+ * @returns A string that unequivocally identifies the order of the user.
+ */
+declare function packOrderUidParams({ orderDigest, owner, validTo }: OrderUidParams): string;
+/**
+ * Extracts the order unique identifier parameters from the specified bytes.
+ *
+ * @param orderUid The order UID encoded as a hexadecimal string.
+ * @returns The extracted order UID parameters.
+ */
+declare function extractOrderUidParams(orderUid: string): OrderUidParams;
+/**
+ * Compute the 32-byte signing hash for the specified cancellation.
+ *
+ * @param domain The EIP-712 domain separator to compute the hash for.
+ * @param orderUid The unique identifier of the order to cancel.
+ * @return Hex-encoded 32-byte order digest.
+ */
+declare function hashOrderCancellation(domain: TypedDataDomain, orderUid: Bytes): string;
+/**
+ * Compute the 32-byte signing hash for the specified order cancellations.
+ *
+ * @param domain The EIP-712 domain separator to compute the hash for.
+ * @param orderUids The unique identifiers of the orders to cancel.
+ * @return Hex-encoded 32-byte order digest.
+ */
+declare function hashOrderCancellations(domain: TypedDataDomain, orderUids: Bytes[]): string;
+
+/**
+ * The salt used when deterministically deploying smart contracts.
+ * SALT = ethers.utils.formatBytes32String("Mattresses in Berlin!");
+ */
+declare const SALT = "0x4d61747472657373657320696e204265726c696e210000000000000000000000";
+/**
+ * The contract used to deploy contracts deterministically with CREATE2.
+ * The address is chosen by the hardhat-deploy library.
+ * It is the same in any EVM-based network.
+ *
+ * https://github.com/Arachnid/deterministic-deployment-proxy
+ */
+declare const DEPLOYER_CONTRACT = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
+/**
+ * Dictionary containing all deployed contract names.
+ */
+declare enum CONTRACT_NAMES {
+    authenticator = "GPv2AllowListAuthentication",
+    settlement = "GPv2Settlement",
+    tradeSimulator = "GPv2TradeSimulator"
+}
+/**
+ * The name of a deployed contract.
+ */
+type ContractName = (typeof CONTRACT_NAMES)[keyof typeof CONTRACT_NAMES];
+/**
+ * The deployment args for a contract.
+ */
+type DeploymentArguments<T> = T extends typeof CONTRACT_NAMES.authenticator ? never : T extends typeof CONTRACT_NAMES.settlement ? [string, string] : T extends typeof CONTRACT_NAMES.tradeSimulator ? [] : unknown[];
+/**
+ * Artifact information important for computing deterministic deployments.
+ */
+interface ArtifactDeployment {
+    abi: Abi;
+    bytecode: string;
+}
+/**
+ * An artifact with a contract name matching one of the deterministically
+ * deployed contracts.
+ */
+interface NamedArtifactDeployment<C extends ContractName> extends ArtifactDeployment {
+    contractName: C;
+}
+type MaybeNamedArtifactArtifactDeployment<C> = C extends ContractName ? NamedArtifactDeployment<C> : ArtifactDeployment;
+/**
+ * Computes the deterministic address at which the contract will be deployed.
+ * This address does not depend on which network the contract is deployed to.
+ *
+ * @param contractName Name of the contract for which to find the address.
+ * @param deploymentArguments Extra arguments that are necessary to deploy.
+ * @returns The address that is expected to store the deployed code.
+ */
+declare function deterministicDeploymentAddress<C>({ bytecode }: MaybeNamedArtifactArtifactDeployment<C>, deploymentArguments: DeploymentArguments<C>): Address;
+
+/**
+ * Returns the address of the implementation of an EIP-1967-compatible proxy
+ * from its address.
+ *
+ * @param proxy Address of the proxy contract.
+ * @returns The address of the contract storing the proxy implementation.
+ */
+declare function implementationAddress(_provider: Provider, proxy: string): Promise<string>;
+/**
+ * Returns the address of the implementation of an EIP-1967-compatible proxy
+ * from its address.
+ *
+ * @param proxy Address of the proxy contract.
+ * @returns The address of the administrator of the proxy.
+ */
+declare function ownerAddress(provider: Provider, proxy: string): Promise<string>;
+/**
+ * EIP-173 proxy ABI in "human-readable ABI" format. The proxy used by the
+ * deployment plugin implements this interface, and copying it here avoids
+ * pulling in `hardhat` as a dependency for just this ABI.
+ *
+ * <https://eips.ethereum.org/EIPS/eip-173#specification>
+ */
+declare const EIP173_PROXY_ABI: string[];
+
+/**
+ * Grants the required roles to the specified Vault relayer.
+ *
+ * This method is intended to be called by the Balancer Vault admin, and **not**
+ * traders. It is included in the exported TypeScript library for completeness
+ * and "documentation".
+ *
+ * @param authorizerAddress The address of the Vault authorizer contract that manages access.
+ * @param authorizerAbi The ABI of the authorizer contract.
+ * @param vaultAddress The address to the Vault.
+ * @param vaultRelayerAddress The address to the GPv2 Vault relayer contract.
+ * @param contractCall Function to execute the contract call (provided by the adapter).
+ */
+declare function grantRequiredRoles(authorizerAddress: string, authorizerAbi: Abi, vaultAddress: string, vaultRelayerAddress: string, contractCall: (address: string, abi: Abi, functionName: string, args: unknown[]) => Promise<void>): Promise<void>;
+
+/**
+ * A Balancer swap used for settling a single order against Balancer pools.
+ */
+interface Swap {
+    /**
+     * The ID of the pool for the swap.
+     */
+    poolId: Bytes;
+    /**
+     * The swap input token address.
+     */
+    assetIn: string;
+    /**
+     * The swap output token address.
+     */
+    assetOut: string;
+    /**
+     * The amount to swap. This will ether be a fixed input amount when swapping
+     * a sell order, or a fixed output amount when swapping a buy order.
+     */
+    amount: BigIntish;
+    /**
+     * Optional additional pool user data required for the swap.
+     *
+     * This additional user data is pool implementation specific, and allows pools
+     * to extend the Vault pool interface.
+     */
+    userData?: Bytes;
+}
+/**
+ * An encoded Balancer swap request that can be used as input to the settlement
+ * contract.
+ */
+interface BatchSwapStep {
+    /**
+     * The ID of the pool for the swap.
+     */
+    poolId: Bytes;
+    /**
+     * The index of the input token.
+     *
+     * Settlement swap calls encode tokens as an array, this number represents an
+     * index into that array.
+     */
+    assetInIndex: number;
+    /**
+     * The index of the output token.
+     */
+    assetOutIndex: number;
+    /**
+     * The amount to swap.
+     */
+    amount: BigIntish;
+    /**
+     * Additional pool user data required for the swap.
+     */
+    userData: Bytes;
+}
+/**
+ * Swap execution parameters.
+ */
+interface SwapExecution {
+    /**
+     * The limit amount for the swap.
+     *
+     * This allows settlement submission to define a tighter slippage than what
+     * was specified by the order in order to reduce MEV opportunity.
+     */
+    limitAmount: BigIntish;
+}
+/**
+ * Encoded swap parameters.
+ */
+type EncodedSwap = [
+    /** Swap requests. */
+    BatchSwapStep[],
+    /** Tokens. */
+    string[],
+    /** Encoded trade. */
+    Trade
+];
+/**
+ * Encodes a swap as a {@link BatchSwapStep} to be used with the settlement
+ * contract.
+ */
+declare function encodeSwapStep(tokens: TokenRegistry, swap: Swap): BatchSwapStep;
+/**
+ * Encoder for CoW Protocol swap transactions.
+ *
+ * This class provides methods to encode swaps and trades for CoW Protocol
+ * settlements that involve Balancer Vault swaps. It maintains state for tokens,
+ * swaps, and the associated trade.
+ *
+ * @example
+ * ```typescript
+ * const encoder = new SwapEncoder(domain, adapter)
+ * encoder.encodeSwapStep(swap)
+ * encoder.encodeTrade(order, signature)
+ * const swapData = encoder.encodedSwap()
+ * ```
+ */
+declare class SwapEncoder {
+    readonly domain: TypedDataDomain;
+    private readonly _tokens;
+    private readonly _swaps;
+    private _trade;
+    /**
+     * Creates a new settlement encoder instance.
+     *
+     * @param domain Domain used for signing orders. See {@link signOrder} for
+     * more details.
+     */
+    constructor(domain: TypedDataDomain, adapter?: AbstractProviderAdapter);
+    /**
+     * Gets the array of token addresses used by the currently encoded swaps.
+     */
+    get tokens(): string[];
+    /**
+     * Gets the encoded swaps.
+     */
+    get swaps(): BatchSwapStep[];
+    /**
+     * Gets the encoded trade.
+     */
+    get trade(): Trade;
+    /**
+     * Encodes the swap as a swap request and appends it to the swaps encoded so
+     * far.
+     *
+     * @param swap The Balancer swap to encode.
+     */
+    encodeSwapStep(...swaps: Swap[]): void;
+    /**
+     * Encodes a trade from a signed order.
+     *
+     * Additionally, if the order references new tokens that the encoder has not
+     * yet seen, they are added to the tokens array.
+     *
+     * @param order The order of the trade to encode.
+     * @param signature The signature for the order data.
+     */
+    encodeTrade(order: Order, signature: Signature, swapExecution?: Partial<SwapExecution>): void;
+    /**
+     * Signs an order and encodes a trade with that order.
+     *
+     * @param order The order to sign for the trade.
+     * @param scheme The signing scheme to use. See {@link SigningScheme} for more
+     * details.
+     * @param owner The externally owned account that should sign the order.
+     */
+    signEncodeTrade(order: Order, scheme: EcdsaSigningScheme, swapExecution?: Partial<SwapExecution>, owner?: SignerLike): Promise<void>;
+    /**
+     * Returns the encoded swap parameters for the current state of the encoder.
+     *
+     * This method with raise an exception if a trade has not been encoded.
+     */
+    encodedSwap(): EncodedSwap;
+    static encodeSwap(swaps: Swap[], order: Order, signature: Signature): EncodedSwap;
+    static encodeSwap(swaps: Swap[], order: Order, signature: Signature, swapExecution: Partial<SwapExecution> | undefined): EncodedSwap;
+    static encodeSwap(domain: TypedDataDomain, swaps: Swap[], order: Order, owner: Signer, scheme: EcdsaSigningScheme): Promise<EncodedSwap>;
+    static encodeSwap(domain: TypedDataDomain, swaps: Swap[], order: Order, owner: Signer, scheme: EcdsaSigningScheme, swapExecution: Partial<SwapExecution> | undefined): Promise<EncodedSwap>;
+}
+
+declare class ContractsTs {
+    ORDER_TYPE_FIELDS: {
+        name: string;
+        type: string;
+    }[];
+    ORDER_UID_LENGTH: number;
+    /**
+     * Creates a new ContractsTs instance
+     *
+     * @param adapter Provider adapter implementation
+     */
+    constructor(adapter: AbstractProviderAdapter);
+    deterministicDeploymentAddress: typeof deterministicDeploymentAddress;
+    normalizeInteraction: typeof normalizeInteraction;
+    normalizeInteractions: typeof normalizeInteractions;
+    timestamp: typeof timestamp;
+    hashify: typeof hashify;
+    normalizeBuyTokenBalance: typeof normalizeBuyTokenBalance;
+    normalizeOrder: typeof normalizeOrder;
+    hashTypedData: typeof hashTypedData;
+    hashOrder: typeof hashOrder;
+    computeOrderUid: typeof computeOrderUid;
+    packOrderUidParams: typeof packOrderUidParams;
+    extractOrderUidParams: typeof extractOrderUidParams;
+    implementationAddress: typeof implementationAddress;
+    ownerAddress: typeof ownerAddress;
+    signOrder: typeof signOrder;
+    encodeEip1271SignatureData: typeof encodeEip1271SignatureData;
+    decodeEip1271SignatureData: typeof decodeEip1271SignatureData;
+    grantRequiredRoles: typeof grantRequiredRoles;
+    encodeSigningScheme: typeof encodeSigningScheme;
+    decodeSigningScheme: typeof decodeSigningScheme;
+    encodeOrderFlags: typeof encodeOrderFlags;
+    decodeOrderFlags: typeof decodeOrderFlags;
+    encodeTradeFlags: typeof encodeTradeFlags;
+    decodeTradeFlags: typeof decodeTradeFlags;
+    encodeSignatureData: typeof encodeSignatureData;
+    decodeSignatureOwner: typeof decodeSignatureOwner;
+    encodeTrade: typeof encodeTrade;
+    decodeOrder: typeof decodeOrder;
+    TokenRegistry: typeof TokenRegistry;
+    SettlementEncoder: typeof SettlementEncoder;
+    InteractionStage: typeof InteractionStage;
+    FLAG_MASKS: {
+        readonly kind: {
+            readonly offset: 0;
+            readonly options: readonly [OrderKind.SELL, OrderKind.BUY];
+        };
+        readonly partiallyFillable: {
+            readonly offset: 1;
+            readonly options: readonly [false, true];
+        };
+        readonly sellTokenBalance: {
+            readonly offset: 2;
+            readonly options: readonly [OrderBalance.ERC20, undefined, OrderBalance.EXTERNAL, OrderBalance.INTERNAL];
+        };
+        readonly buyTokenBalance: {
+            readonly offset: 4;
+            readonly options: readonly [OrderBalance.ERC20, OrderBalance.INTERNAL];
+        };
+        readonly signingScheme: {
+            readonly offset: 5;
+            readonly options: readonly [SigningScheme.EIP712, SigningScheme.ETHSIGN, SigningScheme.EIP1271, SigningScheme.PRESIGN];
+        };
+    };
+    encodeSwapStep: typeof encodeSwapStep;
+    SwapEncoder: typeof SwapEncoder;
+    /**
+     * Return the Gnosis Protocol v2 domain used for signing.
+     * @param chainId The EIP-155 chain ID.
+     * @param verifyingContract The address of the contract that will verify the
+     * signature.
+     * @return An EIP-712 compatible typed domain data.
+     */
+    static domain(chainId: number, verifyingContract: string): {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+}
+
+declare enum Environment {
+    Dev = 0,
+    Prod = 1
+}
+declare const LIMIT_CONCURRENT_REQUESTS = 5;
+declare function apiUrl(environment: Environment, network: string): string;
+interface ApiCall {
+    baseUrl: string;
+}
+interface EstimateTradeAmountQuery {
+    sellToken: string;
+    buyToken: string;
+    kind: OrderKind;
+    amount: BigIntish;
+}
+interface PlaceOrderQuery {
+    order: Order;
+    signature: Signature;
+    from?: string;
+}
+interface GetExecutedSellAmountQuery {
+    uid: string;
+}
+type SellAmountBeforeFee = {
+    kind: OrderKind.SELL;
+    sellAmountBeforeFee: BigIntish;
+};
+type SellAmountAfterFee = {
+    kind: OrderKind.SELL;
+    sellAmountAfterFee: BigIntish;
+};
+type BuyAmountAfterFee = {
+    kind: OrderKind.BUY;
+    buyAmountAfterFee: BigIntish;
+};
+type QuoteQuery = CommonQuoteQuery & (SellAmountBeforeFee | SellAmountAfterFee | BuyAmountAfterFee);
+interface CommonQuoteQuery {
+    sellToken: string;
+    buyToken: string;
+    receiver?: string;
+    validTo?: Timestamp;
+    appData?: HashLike;
+    partiallyFillable?: boolean;
+    sellTokenBalance?: OrderBalance;
+    buyTokenBalance?: OrderBalance;
+    from: string;
+    priceQuality?: QuotePriceQuality;
+}
+declare enum QuotePriceQuality {
+    FAST = "fast",
+    OPTIMAL = "optimal"
+}
+interface OrderDetailResponse {
+    executedSellAmount: string;
+}
+interface GetQuoteResponse {
+    quote: Order;
+    from: string;
+    expiration: Timestamp;
+    id?: number;
+}
+interface ApiError {
+    errorType: string;
+    description: string;
+}
+interface CallError extends Error {
+    apiError?: ApiError;
+}
+declare enum GetQuoteErrorType {
+    SellAmountDoesNotCoverFee = "SellAmountDoesNotCoverFee",
+    NoLiquidity = "NoLiquidity"
+}
+declare class Api {
+    network: string;
+    baseUrl: string;
+    constructor(network: string, baseUrlOrEnv: string | Environment);
+    private apiCallParams;
+    estimateTradeAmount(query: EstimateTradeAmountQuery): Promise<BigIntish>;
+    placeOrder(query: PlaceOrderQuery): Promise<string>;
+    getExecutedSellAmount(query: GetExecutedSellAmountQuery): Promise<BigIntish>;
+    getQuote(query: QuoteQuery): Promise<GetQuoteResponse>;
+}
+
+/**
+ * A class for attaching the storage reader contract to a solver allow list for
+ * providing additional storage reading methods.
+ */
+declare class AllowListReader {
+    readonly allowListAddress: Address;
+    readonly allowListAbi: Abi;
+    readonly readerAddress: Address;
+    readonly readerAbi: Abi;
+    readonly provider: Provider;
+    constructor(allowListAddress: Address, allowListAbi: Abi, readerAddress: Address, readerAbi: Abi, provider: Provider);
+    /**
+     * Returns true if all the specified addresses are allowed solvers.
+     */
+    areSolvers(solvers: Bytes[]): Promise<string>;
+}
+/**
+ * A class for attaching the storage reader contract to the GPv2Settlement contract
+ * for providing additional storage reading methods.
+ */
+declare class SettlementReader {
+    readonly settlementAddress: Address;
+    readonly settlementAbi: Abi;
+    readonly readerAddress: Address;
+    readonly readerAbi: Abi;
+    readonly provider: Provider;
+    constructor(settlementAddress: Address, settlementAbi: Abi, readerAddress: Address, readerAbi: Abi, provider: Provider);
+    /**
+     * Read and return filled amounts for a list of orders
+     */
+    filledAmountsForOrders(orderUids: Bytes[]): Promise<BigIntish[]>;
+}
+/**
+ * A simulated trade.
+ */
+type TradeSimulation = Pick<Order, 'sellToken' | 'buyToken' | 'receiver' | 'sellAmount' | 'buyAmount' | 'sellTokenBalance' | 'buyTokenBalance'> & {
+    /**
+     * The address of the owner of the trade. For an actual settlement, this would
+     * usually this would be determinied by recovering an order signature.
+     */
+    owner: string;
+};
+/**
+ * Account balance changes in a trade simulation
+ */
+interface TradeSimulationBalanceDelta {
+    sellTokenDelta: BigIntish;
+    buyTokenDelta: BigIntish;
+}
+/**
+ * The result of a trade simulation.
+ */
+interface TradeSimulationResult {
+    gasUsed: BigIntish;
+    executedBuyAmount: BigIntish;
+    contractBalance: TradeSimulationBalanceDelta;
+    ownerBalance: TradeSimulationBalanceDelta;
+}
+/**
+ * Trade simulation storage reader contract allowing the simulation of trades.
+ */
+declare class TradeSimulator {
+    readonly settlementAddress: Address;
+    readonly settlementAbi: Abi;
+    readonly simulatorAddress: Address;
+    readonly simulatorAbi: Abi;
+    readonly provider: Provider;
+    constructor(settlementAddress: Address, settlementAbi: Abi, simulatorAddress: Address, simulatorAbi: Abi, provider: Provider);
+    /**
+     * Simulates the single order settlement for an executed trade and a set of
+     * interactions.
+     */
+    simulateTrade(trade: TradeSimulation, interactions: Partial<Record<InteractionStage, InteractionLike[]>>): Promise<TradeSimulationResult>;
+}
+
+/**
+ * Wrapper around a TypedDataSigner Signer object that implements `_signTypedData`. It allows to specify the version of
+ * EIP-712 used.
+ *
+ * Takes a Signer instance on creation.
+ * All other Signer methods are proxied to initial instance.
+ */
+declare function getTypedDataVersionedSigner(signer: Signer, version: 'v3' | 'v4'): AbstractSigner<unknown>;
+/**
+ * Wrapper around a TypedDataSigner Signer object that implements `_signTypedData` using
+ * `eth_signTypedData_v3` instead of `eth_signTypedData_v4`.
+ *
+ * Takes a Signer instance on creation.
+ * All other Signer methods are proxied to initial instance.
+ */
+declare function getTypedDataV3Signer(signer: Signer): AbstractSigner<unknown>;
+/**
+ * Wrapper around a TypedDataSigner Signer object that implements `_signTypedData` using
+ * `eth_signTypedData_v4` as usual.
+ * The difference here is that the domain `chainId` is transformed to a `number`.
+ * That's done to circumvent a bug introduced in the latest Metamask version (9.6.0)
+ * that no longer accepts a string for domain `chainId`.
+ * See for more details https://github.com/MetaMask/metamask-extension/issues/11308.
+ *
+ * Takes a Signer instance on creation.
+ * All other Signer methods are proxied to initial instance.
+ */
+declare function getIntChainIdTypedDataV4Signer(signer: Signer): AbstractSigner<unknown>;
+
+declare const CONTRACTS_PKG_VERSION = "0.1.0";
+
+export { AllowListReader, Api, type ApiCall, type ApiError, type ArtifactDeployment, BUY_ETH_ADDRESS, type BatchSwapStep, type BuyAmountAfterFee, CANCELLATIONS_TYPE_FIELDS, CONTRACTS_PKG_VERSION, CONTRACT_NAMES, type CallError, type CommonQuoteQuery, type ContractName, type EcdsaSignature as ContractsEcdsaSignature, type EcdsaSigningScheme as ContractsEcdsaSigningScheme, type Order as ContractsOrder, type OrderCancellations as ContractsOrderCancellations, OrderKind as ContractsOrderKind, type Signature as ContractsSignature, SigningScheme as ContractsSigningScheme, type Trade as ContractsTrade, ContractsTs, DEPLOYER_CONTRACT, type DeploymentArguments, EIP1271_MAGICVALUE, EIP173_PROXY_ABI, type Eip1271Signature, type Eip1271SignatureData, type EncodedSettlement, type EncodedSwap, Environment, type EstimateTradeAmountQuery, FLAG_MASKS, type FlagKey, type FlagOptions, type FlagValue, type GetExecutedSellAmountQuery, GetQuoteErrorType, type GetQuoteResponse, type HashLike, type Interaction, type InteractionLike, InteractionStage, LIMIT_CONCURRENT_REQUESTS, type MaybeNamedArtifactArtifactDeployment, type NamedArtifactDeployment, type NormalizedOrder, ORDER_TYPE_FIELDS, ORDER_TYPE_HASH, ORDER_UID_LENGTH, OrderBalance, type OrderDetailResponse, type OrderFlags, type OrderRefunds, type OrderUidParams, PRE_SIGNED, type PlaceOrderQuery, type PreSignSignature, type Prices, QuotePriceQuality, type QuoteQuery, SALT, type SellAmountAfterFee, type SellAmountBeforeFee, SettlementEncoder, SettlementReader, type Swap, SwapEncoder, type SwapExecution, type Timestamp, TokenRegistry, type TradeExecution, type TradeFlags, type TradeSimulation, type TradeSimulationBalanceDelta, type TradeSimulationResult, TradeSimulator, apiUrl, computeOrderUid, decodeEip1271SignatureData, decodeOrder, decodeOrderFlags, decodeSignatureOwner, decodeSigningScheme, decodeTradeFlags, deterministicDeploymentAddress, ecdsaSignTypedData, encodeEip1271SignatureData, encodeOrderFlags, encodeSignatureData, encodeSigningScheme, encodeSwapStep, encodeTrade, encodeTradeFlags, extractOrderUidParams, getIntChainIdTypedDataV4Signer, getTypedDataV3Signer, getTypedDataVersionedSigner, grantRequiredRoles, hashOrder, hashOrderCancellation, hashOrderCancellations, hashTypedData, hashify, implementationAddress, normalizeBuyTokenBalance, normalizeInteraction, normalizeInteractions, normalizeOrder, ownerAddress, packOrderUidParams, signOrder, signOrderCancellation, signOrderCancellations, timestamp };