@cowprotocol/cow-sdk 5.10.2 → 5.11.0-RC.0

package/dist/bridging/providers/mock/MockBridgeProvider.d.ts

@@ -0,0 +1,21 @@
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, QuoteBridgeRequest } from '../../types';
+import { EvmCall, TokenInfo } from '../../../common';
+import { ChainInfo, SupportedChainId, TargetChainId } from '../../../chains';
+import { Signer } from '@ethersproject/abstract-signer';
+export declare class MockBridgeProvider implements BridgeProvider<BridgeQuoteResult> {
+    info: BridgeProviderInfo;
+    getNetworks(): Promise<ChainInfo[]>;
+    getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
+    getIntermediateTokens({ sellTokenChainId }: QuoteBridgeRequest): Promise<string[]>;
+    getQuote(_request: QuoteBridgeRequest): Promise<BridgeQuoteResult>;
+    getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
+    getUnsignedBridgeCall(_request: QuoteBridgeRequest, _quote: BridgeQuoteResult): Promise<EvmCall>;
+    getSignedHook(_chainId: SupportedChainId, _unsignedCall: EvmCall, _signer: Signer): Promise<BridgeHook>;
+    decodeBridgeHook(_hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
+    getBridgingId(_orderUid: string, _settlementTx: string, _logIndex: number): Promise<string>;
+    getExplorerUrl(bridgingId: string): string;
+    getStatus(_bridgingId: string): Promise<BridgeStatusResult>;
+    getCancelBridgingTx(_bridgingId: string): Promise<EvmCall>;
+    getRefundBridgingTx(_bridgingId: string): Promise<EvmCall>;
+}

package/dist/bridging/types.d.ts

@@ -0,0 +1,287 @@
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { ChainInfo, SupportedChainId, TargetChainId } from '../chains';
+import { TokenInfo } from '../common/types/tokens';
+import { Address, Amounts, EnrichedOrder, OrderKind } from '../order-book';
+import { EvmCall } from '../common/types/ethereum';
+import type { AccountAddress } from '../common/types/wallets';
+import { OrderPostingResult, QuoteAndPost, QuoteResults, QuoterParameters, TradeOptionalParameters, TraderParameters } from '../trading';
+import { Signer } from '@ethersproject/abstract-signer';
+export interface BridgeProviderInfo {
+    name: string;
+    logoUrl: string;
+}
+interface WithSellToken {
+    sellTokenChainId: SupportedChainId;
+    sellTokenAddress: Address;
+    sellTokenDecimals: number;
+}
+interface WithBuyToken {
+    buyTokenChainId: TargetChainId;
+    buyTokenAddress: Address;
+    buyTokenDecimals: number;
+}
+type WithQuoter = Omit<QuoterParameters, 'chainId'>;
+type WithTrader = Pick<TraderParameters, 'signer'>;
+/**
+ * Parameters for getting a bridge quote
+ */
+export type QuoteBridgeRequest = {
+    kind: OrderKind;
+    amount: bigint;
+    owner?: AccountAddress;
+} & WithSellToken & WithBuyToken & WithQuoter & WithTrader & TradeOptionalParameters;
+export type QuoteBridgeRequestWithoutAmount = Omit<QuoteBridgeRequest, 'amount'>;
+export interface BridgeQuoteResult {
+    /**
+     * Whether the quote is a sell or buy order.
+     */
+    isSell: boolean;
+    /**
+     * Costs and amounts of the bridging.
+     */
+    amountsAndCosts: BridgeQuoteAmountsAndCosts;
+    /**
+     * The estimated time in seconds it takes to fill the order.
+     */
+    expectedFillTimeSeconds?: number;
+    /**
+     * The timestamp of the quote.
+     */
+    quoteTimestamp: number;
+    fees: {
+        /**
+         * The amount that should go to the relayer as a fee to cover relayer capital costs.
+         * In token atoms.
+         */
+        bridgeFee: bigint;
+        /**
+         * The amount that should go to the relayer as a fee to cover relayer gas costs.
+         * In token atoms.
+         */
+        destinationGasFee: bigint;
+    };
+    limits: {
+        /**
+         * The minimum amount that should be deposited in the source chain.
+         * In token atoms.
+         */
+        minDeposit: bigint;
+        /**
+         * The maximum amount that can be deposited in the source chain.
+         * In token atoms.
+         */
+        maxDeposit: bigint;
+    };
+}
+export interface BridgeHook {
+    postHook: latestAppData.CoWHook;
+    recipient: string;
+}
+export declare enum BridgeStatus {
+    NOT_INITIATED = "not_initiated",
+    IN_PROGRESS = "in_progress",
+    EXECUTED = "executed",
+    FAILED = "failed",
+    EXPIRED = "expired"
+}
+export interface BridgeStatusResult {
+    status: BridgeStatus;
+    fillTimeInSeconds?: number;
+}
+/**
+ * A bridge deposit. It includes the provideer information, sell amount and the minimum buy amount.
+ *
+ * It models the minimal information for a bridging order.
+ *
+ */
+export interface BridgeDeposit extends Omit<QuoteBridgeRequest, 'amount'> {
+    readonly provider: BridgeProviderInfo;
+    sellTokenAmount: string;
+    minBuyAmount: string;
+}
+export interface BridgeProvider<Q extends BridgeQuoteResult> {
+    info: BridgeProviderInfo;
+    /**
+     * Get basic supported chains
+     */
+    getNetworks(): Promise<ChainInfo[]>;
+    /**
+     * Get supported tokens for a chain
+     */
+    getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
+    /**
+     * Get intermediate tokens given a quote request.
+     *
+     * An intermediate token, is a token in the source chain, that could be used to bridge the tokens to the destination chain.
+     * This method returns a sorted list of tokens, they are sorted by priority, so first tokens are more likely to be more liquid.
+     *
+     * @param request - The quote request
+     */
+    getIntermediateTokens(request: QuoteBridgeRequest): Promise<string[]>;
+    /**
+     * Get a quote for a bridge request.
+     *
+     * @param request - The quote request
+     */
+    getQuote(request: QuoteBridgeRequest): Promise<Q>;
+    /**
+     * Get an unsigned bridge call for a quote.
+     *
+     * The transaction details should be executed in the context of cow-shed account.
+     *
+     * @param request - The quote request
+     * @param quote - The quote
+     * @returns The unsigned transaction details that cow-shed needs to sign
+     */
+    getUnsignedBridgeCall(request: QuoteBridgeRequest, quote: Q): Promise<EvmCall>;
+    /**
+     * Returns the estimated gas cost for executing the bridge hook.
+     *
+     * This method helps calculate the final amount of tokens the user will receive more accurately.
+     * The estimation is done without the amount parameter to break a circular dependency:
+     * 1. Hook gas costs affect the final amount
+     * 2. The final amount could affect hook gas costs
+     *
+     * By estimating gas costs independently, we can resolve this dependency cycle.
+     */
+    getGasLimitEstimationForHook(request: Omit<QuoteBridgeRequest, 'amount'>): number;
+    /**
+     * Get a pre-authorized hook for initiating a bridge.
+     *
+     * The hook contains the ethereum call that the trampoline contract will need to execute during the settlement to initate the bridge.
+     *
+     * Typically, this hook will:
+     *  - Get the balance of cow-shed account
+     *  - Ensure the approval for the bridge lock contract is set
+     *  - Deposit into  the bridge contract
+     *
+     * This hook will include the pre-authorization (signature) of the owner of the cow-shed account (the trader).
+     *
+     * @param unsignedCall
+     * @param signer
+     */
+    getSignedHook(chainId: SupportedChainId, unsignedCall: EvmCall, signer: Signer): Promise<BridgeHook>;
+    /**
+     * Decode a bridge hook into a bridge deposit information.
+     *
+     * This method is used to recover the information about the limit order placed into the bridge locking contract.
+     * This allows to load an order from the orderbook and decode the bridging hook and understand what was the minimum buy amount the user signed to receive in the destination chain.
+     *
+     * @param hook - The bridge hook
+     */
+    decodeBridgeHook(hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
+    /**
+     * Get the identifier of the bridging transaction from the settlement transaction.
+     * @param orderUid - The unique identifier of the order
+     * @param settlementTx - The settlement transaction in which the bridging post-hook was executed
+     * @param logIndex - The log index of the trade within the settlement transaction
+     */
+    getBridgingId(orderUid: string, settlementTx: string, logIndex: number): Promise<string>;
+    /**
+     * Get the explorer url for a bridging id.
+     *
+     * @param bridgingId - The bridging id
+     */
+    getExplorerUrl(bridgingId: string): string;
+    /**
+     * Get the status of a bridging transaction.
+     *
+     * @param bridgingId - The bridging id
+     */
+    getStatus(bridgingId: string): Promise<BridgeStatusResult>;
+    getCancelBridgingTx(bridgingId: string): Promise<EvmCall>;
+    getRefundBridgingTx(bridgingId: string): Promise<EvmCall>;
+}
+/**
+ * A quote and post for a cross-chain swap.
+ *
+ * If the order happens in a single chain, it returns the quote and post details for CoW Protocol.
+ * If the order happens in multiple chains, it returns the quote and post details for CoW Protocol, the bridging
+ * details, and a summary of the overall multi-step order.
+ */
+export type CrossChainQuoteAndPost = QuoteAndPost | BridgeQuoteAndPost;
+export interface BridgeQuoteAndPost {
+    /**
+     * The quote results for the CoW Protocol order.
+     */
+    swap: QuoteResults;
+    /**
+     * The quote results for the bridging.
+     *
+     * Includes the bridging details.
+     */
+    bridge: BridgeQuoteResults;
+    /**
+     * Callback to post the swap order.
+     */
+    postSwapOrderFromQuote(): Promise<OrderPostingResult>;
+}
+export interface BridgeCosts<T = bigint> {
+    bridgingFee: {
+        feeBps: number;
+        amountInSellCurrency: T;
+        amountInBuyCurrency: T;
+    };
+}
+export interface BridgeQuoteAmountsAndCosts<T = bigint> {
+    /**
+     * Costs of the bridging.
+     */
+    costs: BridgeCosts<T>;
+    /**
+     * Amounts before fees
+     */
+    beforeFee: Amounts<T>;
+    /**
+     * Amounts after fees.
+     */
+    afterFee: Amounts<T>;
+    /**
+     * Amounts after slippage tolerance.
+     *
+     * It includes the fees and the slippage tolerance, so its the minimum amount that the user will receive.
+     */
+    afterSlippage: Amounts<T>;
+    /**
+     * The slippage tolerance in basis points.
+     */
+    slippageBps: number;
+}
+/**
+ * Details about the bridge call.
+ */
+export interface BridgeCallDetails {
+    /**
+     * Unsigned call to initiate the bridge. This call should be executed in the context of user's cow-shed account.
+     */
+    unsignedBridgeCall: EvmCall;
+    /**
+     * Pre-authorized hook to initiate the bridge. This hook has been signed, and is ready to be executed by the
+     * CoW Protocol Trampoline contract after settling the swap order that buys the intermediate token.
+     */
+    preAuthorizedBridgingHook: BridgeHook;
+}
+export interface BridgeQuoteResults extends BridgeQuoteResult {
+    /**
+     * Bridge provider information
+     */
+    providerInfo: BridgeProviderInfo;
+    /**
+     * Trade parameters
+     */
+    tradeParameters: QuoteBridgeRequest;
+    /**
+     * Bridge call details
+     */
+    bridgeCallDetails: BridgeCallDetails;
+}
+export type GetErc20Decimals = (chainId: TargetChainId, tokenAddress: string) => Promise<number>;
+export interface CrossChainOrder {
+    chainId: SupportedChainId;
+    order: EnrichedOrder;
+    status: BridgeStatus;
+    bridgingId?: string;
+    explorerUrl?: string;
+    fillTimeInSeconds?: number;
+}
+export {};

package/dist/bridging/utils.d.ts

@@ -0,0 +1,9 @@
+import { QuoteAndPost } from '../trading';
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { BridgeQuoteAndPost, CrossChainQuoteAndPost } from './types';
+export declare function isBridgeQuoteAndPost(quote: CrossChainQuoteAndPost): quote is BridgeQuoteAndPost;
+export declare function isQuoteAndPost(quote: CrossChainQuoteAndPost): quote is QuoteAndPost;
+export declare function assertIsBridgeQuoteAndPost(quote: CrossChainQuoteAndPost): asserts quote is BridgeQuoteAndPost;
+export declare function assertIsQuoteAndPost(quote: CrossChainQuoteAndPost): asserts quote is QuoteAndPost;
+export declare function getPostHooks(fullAppData?: string): latestAppData.CoWHook[];
+export declare function isAppDoc(appData: unknown): appData is latestAppData.AppDataRootSchema;

package/dist/chains/const/index.d.ts

@@ -0,0 +1,25 @@
+import { AdditionalTargetChainId, ChainInfo, SupportedChainId } from '../types';
+/**
+ * Details of all supported chains.
+ */
+export declare const ALL_SUPPORTED_CHAINS_MAP: Record<SupportedChainId, ChainInfo>;
+/**
+ * All supported chains.
+ */
+export declare const ALL_SUPPORTED_CHAINS: ChainInfo[];
+/**
+ * The list of supported chains.
+ */
+export declare const ALL_SUPPORTED_CHAIN_IDS: SupportedChainId[];
+/**
+ * Maps a chain where you can bridge to, but not sell tokens from (not supported by CoW Protocol)
+ */
+export declare const ADDITIONAL_TARGET_CHAINS_MAP: Record<AdditionalTargetChainId, ChainInfo>;
+/**
+ * All chains (both supported by CoW Protocol, or chains where you can bridge to)
+ */
+export declare const ALL_CHAINS: ChainInfo[];
+/**
+ * All chain ids (both supported by CoW Protocol, or chains where you can bridge to)
+ */
+export declare const ALL_CHAINS_IDS: number[];

package/dist/chains/const/path.d.ts

@@ -0,0 +1 @@
+export declare const RAW_CHAINS_FILES_PATH: string;

package/dist/chains/details/arbitrum.d.ts

@@ -0,0 +1,7 @@
+import { ChainInfo } from '../types';
+/**
+ * Arbitrum chain info.
+ *
+ * See also https://github.com/wevm/viem/blob/main/src/chains/definitions/arbitrum.ts
+ */
+export declare const arbitrumOne: ChainInfo;

package/dist/chains/details/avalanche.d.ts

@@ -0,0 +1,2 @@
+import { ChainInfo } from '../types';
+export declare const avalanche: ChainInfo;

package/dist/chains/details/base.d.ts

@@ -0,0 +1,7 @@
+import { ChainInfo } from '../types';
+/**
+ * Base chain info.
+ *
+ * See also https://github.com/wevm/viem/blob/main/src/chains/definitions/base.ts
+ */
+export declare const base: ChainInfo;

package/dist/chains/details/gnosis.d.ts

@@ -0,0 +1,7 @@
+import { ChainInfo } from '../types';
+/**
+ * Gnosis chain chain info.
+ *
+ * See also https://github.com/wevm/viem/blob/main/src/chains/definitions/gnosis.ts
+ */
+export declare const gnosisChain: ChainInfo;

package/dist/chains/details/mainnet.d.ts

@@ -0,0 +1,7 @@
+import { ChainInfo } from '../types';
+/**
+ * Mainnet chain info.
+ *
+ * See also https://github.com/wevm/viem/blob/main/src/chains/definitions/mainnet.ts
+ */
+export declare const mainnet: ChainInfo;

package/dist/chains/details/optimism.d.ts

@@ -0,0 +1,2 @@
+import { ChainInfo } from '../types';
+export declare const optimism: ChainInfo;

package/dist/chains/details/polygon.d.ts

@@ -0,0 +1,2 @@
+import { ChainInfo } from '../types';
+export declare const polygon: ChainInfo;

package/dist/chains/details/sepolia.d.ts

@@ -0,0 +1,7 @@
+import { ChainInfo } from '../types';
+/**
+ * Sepolia chain info.
+ *
+ * See also https://github.com/wevm/viem/blob/main/src/chains/definitions/sepolia.ts
+ */
+export declare const sepolia: ChainInfo;

package/dist/chains/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './const';
+export * from './utils';

package/dist/chains/types.d.ts

@@ -0,0 +1,123 @@
+import { TokenInfo } from '../common/types/tokens';
+/**
+ * Supported chains and their `chainId` for the SDK.
+ *
+ * A supported chain, is a chain where CoW Protocol is deployed, so you can sell tokens from there.
+ *
+ * @enum
+ */
+export declare enum SupportedChainId {
+    MAINNET = 1,
+    GNOSIS_CHAIN = 100,
+    ARBITRUM_ONE = 42161,
+    BASE = 8453,
+    POLYGON = 137,
+    AVALANCHE = 43114,
+    SEPOLIA = 11155111
+}
+/**
+ * Chains where you can buy tokens using the bridge functionality. This enum contains chains that are not already included in the SupportedChainId enum.
+ */
+export declare enum AdditionalTargetChainId {
+    OPTIMISM = 10
+}
+/**
+ * Chains where you can buy tokens using the bridge functionality.
+ *
+ * This enum contains all the supported chains and some additional ones supported by the different bridges.
+ */
+export type TargetChainId = SupportedChainId | AdditionalTargetChainId;
+/**
+ * The chain id of the chain.
+ *
+ * TODO: Should we generalize it even more to allow non-EVM chains? We should probably revisit also the chain interface, and some other types.
+ */
+export type ChainId = number;
+export interface ThemedImage {
+    light: string;
+    dark: string;
+}
+export interface WebUrl {
+    url: string;
+    name: string;
+}
+export type ChainRpcUrls = {
+    http: readonly string[];
+    webSocket?: readonly string[];
+};
+export type ChainContract = {
+    address: string;
+    blockCreated?: number | undefined;
+};
+export type ChainContracts = {
+    multicall3?: ChainContract;
+    ensRegistry?: ChainContract;
+    ensUniversalResolver?: ChainContract;
+    universalSignatureVerifier?: ChainContract;
+};
+/**
+ * A chain on the network.
+ *
+ * Probably we could use the viem chain definition, I think multicall3, and ensRegistry and the types defined there can be handy. But for now we are using a simplified version.
+ *
+ * For a list of chains, see: https://github.com/wevm/viem/tree/main/src/chains/definitions
+ */
+export interface ChainInfo {
+    /**
+     * The chain id.
+     */
+    readonly id: ChainId;
+    /**
+     * Label of the chain. Field used for display purposes.
+     */
+    readonly label: string;
+    /**
+     * Native currency of the chain.
+     */
+    readonly nativeCurrency: TokenInfo;
+    /**
+     * ERC-3770 address prefix
+     *
+     * See https://eips.ethereum.org/EIPS/eip-3770
+     */
+    readonly addressPrefix: string;
+    /**
+     * Whether the chain is a testnet.
+     */
+    readonly isTestnet: boolean;
+    /**
+     * Contracts of the chain.
+     */
+    readonly contracts: ChainContracts;
+    /**
+     * Main color of the chain, used for presentation purposes.
+     */
+    readonly color: string;
+    /**
+     * Logo of the chain.
+     */
+    readonly logo: ThemedImage;
+    /**
+     * Documentation of the chain.
+     */
+    readonly docs: WebUrl;
+    /**
+     * Website of the chain.
+     */
+    readonly website: WebUrl;
+    /**
+     * Block explorer of the chain.
+     */
+    readonly blockExplorer: WebUrl;
+    /**
+     * Bridges of the chain.
+     */
+    readonly bridges?: WebUrl[];
+    /**
+     * RPC URLs of the chain.
+     */
+    readonly rpcUrls: {
+        [key: string]: ChainRpcUrls;
+        default: ChainRpcUrls;
+    };
+}

package/dist/chains/utils.d.ts

@@ -0,0 +1,18 @@
+import { AdditionalTargetChainId, ChainId, ChainInfo, SupportedChainId, TargetChainId } from './types';
+/**
+ * Return the chain info for a given chain id or undefined if the chain is not known (not supported by CoW Protocol or the bridge providers).
+ * @param chainId
+ */
+export declare function getChainInfo(chainId: ChainId): ChainInfo | undefined;
+/**
+ * Check if the chain is supported by CoW Protocol.
+ */
+export declare function isSupportedChain(chainId: ChainId): chainId is SupportedChainId;
+/**
+ * Check if the chain is supported by the bridge providers.
+ */
+export declare function isAdditionalTargetChain(chainId: ChainId): chainId is AdditionalTargetChainId;
+/**
+ * Check if the chain is supported by CoW Swap or the bridge providers.
+ */
+export declare function isTargetChainId(chainId: ChainId): chainId is TargetChainId;

package/dist/common/consts/config.d.ts

@@ -0,0 +1,9 @@
+import { ApiContext, CowEnv } from '../types/config';
+/**
+ * The list of available environments.
+ */
+export declare const ENVS_LIST: CowEnv[];
+/**
+ * The default CoW Protocol API context.
+ */
+export declare const DEFAULT_COW_API_CONTEXT: ApiContext;

package/dist/common/{consts.d.ts → consts/contracts.d.ts}

@@ -1,16 +1,9 @@
-import { SupportedChainId } from './chains';
+import { SupportedChainId } from '../../chains/types';
 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";
 export declare const COW_SHED_IMPLEMENTATION = "0x2CFFA8cf11B90C9F437567b86352169dF4009F73";
-/**
- * The list of supported chains.
- */
-export declare const ALL_SUPPORTED_CHAIN_IDS: SupportedChainId[];
-export declare function mapSupportedNetworks<T>(value: (chainId: SupportedChainId) => T): Record<SupportedChainId, T>;
-export declare function mapSupportedNetworks<T>(value: T): Record<SupportedChainId, T>;
-export declare function mapAddressToSupportedNetworks(address: string): Record<SupportedChainId, string>;
 /**
  * An object containing the addresses of the CoW Protocol settlement contracts for each supported chain.
  */
@@ -27,10 +20,6 @@ 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>;
 export declare const ETH_FLOW_ADDRESS = "0xba3cb449bd2b4adddbc894d8697f5170800eadec";
 export declare const BARN_ETH_FLOW_ADDRESS = "0x04501b9b1d52e67f6862d157e00d13419d2d6e95";
 /**

package/dist/common/consts/path.d.ts

@@ -0,0 +1 @@
+export declare const RAW_FILES_PATH = "https://raw.githubusercontent.com/cowprotocol/cow-sdk/refs/heads/main";

package/dist/common/consts/tokens.d.ts

@@ -0,0 +1,9 @@
+import { SupportedChainId } from '../../chains/types';
+import { TokenInfo } from '../types/tokens';
+export declare const NATIVE_CURRENCY_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const TOKEN_LIST_IMAGES_PATH = "https://raw.githubusercontent.com/cowprotocol/token-lists/main/src/public/images";
+export declare const WRAPPED_NATIVE_CURRENCIES: Record<SupportedChainId, TokenInfo>;
+/**
+ * Just a base template for the native currency, handy to define new networks.
+ */
+export declare const nativeCurrencyTemplate: Omit<TokenInfo, 'chainId'>;

package/dist/common/index.d.ts

@@ -1,5 +1,12 @@
-export * from './chains';
-export * from './configs';
-export * from './cow-error';
-export * from './ipfs';
-export * from './consts';
+export * from './types/config';
+export * from './types/cow-error';
+export * from './types/ethereum';
+export * from './types/tokens';
+export * from './types/wallets';
+export { enableLogging } from './utils/log';
+export * from '../chains/const';
+export * from './consts/config';
+export * from './consts/contracts';
+export * from './consts/ipfs';
+export * from './consts/tokens';
+export * from './utils/config';

package/dist/common/{configs.d.ts → types/config.d.ts}

@@ -1,6 +1,6 @@
 import { BackoffOptions } from 'exponential-backoff';
 import { RateLimiterOpts } from 'limiter/dist/esm';
-import { SupportedChainId } from './chains';
+import { SupportedChainId } from '../../chains/types';
 /**
  * IPFS configuration.
  *
@@ -68,11 +68,3 @@ export interface ApiContext {
     limiterOpts?: RateLimiterOpts;
     backoffOpts?: BackoffOptions;
 }
-/**
- * The list of available environments.
- */
-export declare const ENVS_LIST: CowEnv[];
-/**
- * The default CoW Protocol API context.
- */
-export declare const DEFAULT_COW_API_CONTEXT: ApiContext;

package/dist/common/{cow-error.d.ts → types/cow-error.d.ts}

@@ -2,4 +2,3 @@ export declare class CowError extends Error {
     error_code?: string;
     constructor(message: string, error_code?: string);
 }
-export declare const logPrefix = "cow-sdk:";

package/dist/common/types/ethereum.d.ts

@@ -0,0 +1,5 @@
+export interface EvmCall {
+    to: string;
+    data: string;
+    value: bigint;
+}

package/dist/common/types/tokens.d.ts

@@ -0,0 +1,12 @@
+import { ChainId } from '../../chains/types';
+/**
+ * Token on a chain.
+ */
+export interface TokenInfo {
+    chainId: ChainId;
+    address: string;
+    decimals: number;
+    name?: string;
+    symbol?: string;
+    logoUrl?: string;
+}