@cowprotocol/sdk-contracts-ts 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1162 @@
+// src/ContractsTs.ts
+import { setGlobalAdapter as setGlobalAdapter3 } from "@cowprotocol/sdk-common";
+
+// src/order.ts
+import { getGlobalAdapter } from "@cowprotocol/sdk-common";
+var BUY_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var OrderBalance = /* @__PURE__ */ ((OrderBalance3) => {
+  OrderBalance3["ERC20"] = "erc20";
+  OrderBalance3["EXTERNAL"] = "external";
+  OrderBalance3["INTERNAL"] = "internal";
+  return OrderBalance3;
+})(OrderBalance || {});
+var ORDER_TYPE_FIELDS = [
+  { name: "sellToken", type: "address" },
+  { name: "buyToken", type: "address" },
+  { name: "receiver", type: "address" },
+  { name: "sellAmount", type: "uint256" },
+  { name: "buyAmount", type: "uint256" },
+  { name: "validTo", type: "uint32" },
+  { name: "appData", type: "bytes32" },
+  { name: "feeAmount", type: "uint256" },
+  { name: "kind", type: "string" },
+  { name: "partiallyFillable", type: "bool" },
+  { name: "sellTokenBalance", type: "string" },
+  { name: "buyTokenBalance", type: "string" }
+];
+var ORDER_TYPE_HASH = "0xd5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489";
+var CANCELLATIONS_TYPE_FIELDS = [{ name: "orderUids", type: "bytes[]" }];
+function timestamp(t) {
+  return typeof t === "number" ? t : ~~(t.getTime() / 1e3);
+}
+function hashify(h) {
+  return typeof h === "number" ? `0x${h.toString(16).padStart(64, "0")}` : getGlobalAdapter().utils.hexZeroPad(h, 32);
+}
+function normalizeBuyTokenBalance(balance) {
+  switch (balance) {
+    case void 0:
+    case "erc20" /* ERC20 */:
+    case "external" /* EXTERNAL */:
+      return "erc20" /* ERC20 */;
+    case "internal" /* INTERNAL */:
+      return "internal" /* INTERNAL */;
+    default:
+      throw new Error(`invalid order balance ${balance}`);
+  }
+}
+function normalizeOrder(order) {
+  const adapter = getGlobalAdapter();
+  if (order.receiver === adapter.ZERO_ADDRESS) {
+    throw new Error("receiver cannot be address(0)");
+  }
+  const normalizedOrder = {
+    ...order,
+    sellTokenBalance: order.sellTokenBalance ?? "erc20" /* ERC20 */,
+    receiver: order.receiver ?? adapter.ZERO_ADDRESS,
+    validTo: timestamp(order.validTo),
+    appData: hashify(order.appData),
+    buyTokenBalance: normalizeBuyTokenBalance(order.buyTokenBalance)
+  };
+  return normalizedOrder;
+}
+function hashTypedData(domain, types, data) {
+  return getGlobalAdapter().utils.hashTypedData(domain, types, data);
+}
+function hashOrder(domain, order) {
+  return hashTypedData(domain, { Order: ORDER_TYPE_FIELDS }, normalizeOrder(order));
+}
+var ORDER_UID_LENGTH = 56;
+function computeOrderUid(domain, order, owner) {
+  return packOrderUidParams({
+    orderDigest: hashOrder(domain, order),
+    owner,
+    validTo: order.validTo
+  });
+}
+function packOrderUidParams({ orderDigest, owner, validTo }) {
+  return getGlobalAdapter().utils.solidityPack(
+    ["bytes32", "address", "uint32"],
+    [orderDigest, owner, timestamp(validTo)]
+  );
+}
+function extractOrderUidParams(orderUid) {
+  const adapter = getGlobalAdapter();
+  const bytes = adapter.utils.arrayify(orderUid);
+  if (bytes.length != ORDER_UID_LENGTH) {
+    throw new Error("invalid order UID length");
+  }
+  const view = new DataView(bytes.buffer);
+  return {
+    orderDigest: adapter.utils.hexlify(bytes.subarray(0, 32)),
+    owner: adapter.utils.getChecksumAddress(adapter.utils.hexlify(bytes.subarray(32, 52))),
+    validTo: view.getUint32(52)
+  };
+}
+function hashOrderCancellation(domain, orderUid) {
+  return hashOrderCancellations(domain, [orderUid]);
+}
+function hashOrderCancellations(domain, orderUids) {
+  return hashTypedData(domain, { OrderCancellations: CANCELLATIONS_TYPE_FIELDS }, { orderUids });
+}
+
+// src/deploy.ts
+import { getGlobalAdapter as getGlobalAdapter2 } from "@cowprotocol/sdk-common";
+var SALT = "0x4d61747472657373657320696e204265726c696e210000000000000000000000";
+var DEPLOYER_CONTRACT = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
+var CONTRACT_NAMES = /* @__PURE__ */ ((CONTRACT_NAMES2) => {
+  CONTRACT_NAMES2["authenticator"] = "GPv2AllowListAuthentication";
+  CONTRACT_NAMES2["settlement"] = "GPv2Settlement";
+  CONTRACT_NAMES2["tradeSimulator"] = "GPv2TradeSimulator";
+  return CONTRACT_NAMES2;
+})(CONTRACT_NAMES || {});
+function deterministicDeploymentAddress({ bytecode }, deploymentArguments) {
+  const adapter = getGlobalAdapter2();
+  const bytecodeHash = adapter.utils.keccak256(adapter.utils.hexConcat([bytecode, ...deploymentArguments]));
+  return adapter.utils.getCreate2Address(DEPLOYER_CONTRACT, SALT, bytecodeHash);
+}
+
+// src/interaction.ts
+function normalizeInteraction(interaction) {
+  return {
+    value: 0,
+    callData: "0x",
+    ...interaction
+  };
+}
+function normalizeInteractions(interactions) {
+  return interactions.map(normalizeInteraction);
+}
+
+// src/proxy.ts
+import { getGlobalAdapter as getGlobalAdapter3 } from "@cowprotocol/sdk-common";
+var IMPLEMENTATION_STORAGE_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var OWNER_STORAGE_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+async function implementationAddress(_provider, proxy) {
+  const adapter = getGlobalAdapter3();
+  const [implementation] = adapter.utils.decodeAbi(
+    ["address"],
+    await adapter.getStorageAt(proxy, IMPLEMENTATION_STORAGE_SLOT)
+  );
+  return implementation;
+}
+async function ownerAddress(provider, proxy) {
+  const data = provider?.getStorageAt ? await provider.getStorageAt(proxy, OWNER_STORAGE_SLOT) : provider?.getStorage ? provider.getStorage(proxy, OWNER_STORAGE_SLOT) : null;
+  if (data === null)
+    throw new Error("getStorage is not implemented");
+  const [owner] = getGlobalAdapter3().utils.decodeAbi(["address"], data);
+  return owner;
+}
+var EIP173_PROXY_ABI = [
+  "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+  "function owner() view external returns(address)",
+  "function transferOwnership(address newOwner) external",
+  "function supportsInterface(bytes4 interfaceID) external view returns (bool)"
+];
+
+// src/sign.ts
+import { getGlobalAdapter as getGlobalAdapter4 } from "@cowprotocol/sdk-common";
+
+// src/types.ts
+var SigningScheme = /* @__PURE__ */ ((SigningScheme2) => {
+  SigningScheme2[SigningScheme2["EIP712"] = 0] = "EIP712";
+  SigningScheme2[SigningScheme2["ETHSIGN"] = 1] = "ETHSIGN";
+  SigningScheme2[SigningScheme2["EIP1271"] = 2] = "EIP1271";
+  SigningScheme2[SigningScheme2["PRESIGN"] = 3] = "PRESIGN";
+  return SigningScheme2;
+})(SigningScheme || {});
+var OrderKind = /* @__PURE__ */ ((OrderKind2) => {
+  OrderKind2["SELL"] = "sell";
+  OrderKind2["BUY"] = "buy";
+  return OrderKind2;
+})(OrderKind || {});
+
+// src/sign.ts
+var EIP1271_MAGICVALUE = "0x1626ba7e";
+var PRE_SIGNED = "0xf59c009283ff87aa78203fc4d9c2df025ee851130fb69cc3e068941f6b5e2d6f";
+async function ecdsaSignTypedData(scheme, domain, types, data, owner) {
+  let signature = null;
+  const adapter = getGlobalAdapter4();
+  const signer = owner ? adapter.createSigner(owner) : adapter.signer;
+  switch (scheme) {
+    case 0 /* EIP712 */:
+      signature = await signer.signTypedData(domain, types, data);
+      break;
+    case 1 /* ETHSIGN */:
+      signature = await signer.signMessage(adapter.utils.arrayify(adapter.utils.hashTypedData(domain, types, data)));
+      break;
+    default:
+      throw new Error("invalid signing scheme");
+  }
+  return adapter.utils.joinSignature(adapter.utils.splitSignature(signature));
+}
+async function signOrder(domain, order, scheme, owner) {
+  return {
+    scheme,
+    data: await ecdsaSignTypedData(scheme, domain, { Order: ORDER_TYPE_FIELDS }, normalizeOrder(order), owner)
+  };
+}
+function encodeEip1271SignatureData({ verifier, signature }) {
+  const adapter = getGlobalAdapter4();
+  return adapter.utils.solidityPack(["address", "bytes"], [adapter.utils.getChecksumAddress(verifier), signature]);
+}
+function decodeEip1271SignatureData(signature) {
+  const adapter = getGlobalAdapter4();
+  const arrayifiedSignature = adapter.utils.arrayify(signature);
+  const verifier = adapter.utils.getChecksumAddress(adapter.utils.hexlify(arrayifiedSignature.slice(0, 20)));
+  return {
+    verifier,
+    signature: adapter.utils.hexlify(arrayifiedSignature.slice(20))
+  };
+}
+async function signOrderCancellation(domain, orderUid, scheme, owner) {
+  return signOrderCancellations(domain, [orderUid], scheme, owner);
+}
+async function signOrderCancellations(domain, orderUids, scheme, owner) {
+  return {
+    scheme,
+    data: await ecdsaSignTypedData(
+      scheme,
+      domain,
+      { OrderCancellations: CANCELLATIONS_TYPE_FIELDS },
+      { orderUids },
+      owner
+    )
+  };
+}
+
+// src/vault.ts
+import { getGlobalAdapter as getGlobalAdapter5 } from "@cowprotocol/sdk-common";
+async function grantRequiredRoles(authorizerAddress, authorizerAbi, vaultAddress, vaultRelayerAddress, contractCall) {
+  return getGlobalAdapter5().utils.grantRequiredRoles(
+    authorizerAddress,
+    authorizerAbi,
+    vaultAddress,
+    vaultRelayerAddress,
+    contractCall
+  );
+}
+
+// src/settlement.ts
+import {
+  getGlobalAdapter as getGlobalAdapter6,
+  setGlobalAdapter
+} from "@cowprotocol/sdk-common";
+var InteractionStage = /* @__PURE__ */ ((InteractionStage2) => {
+  InteractionStage2[InteractionStage2["PRE"] = 0] = "PRE";
+  InteractionStage2[InteractionStage2["INTRA"] = 1] = "INTRA";
+  InteractionStage2[InteractionStage2["POST"] = 2] = "POST";
+  return InteractionStage2;
+})(InteractionStage || {});
+var FLAG_MASKS = {
+  kind: {
+    offset: 0,
+    options: ["sell" /* SELL */, "buy" /* BUY */]
+  },
+  partiallyFillable: {
+    offset: 1,
+    options: [false, true]
+  },
+  sellTokenBalance: {
+    offset: 2,
+    options: [
+      "erc20" /* ERC20 */,
+      void 0,
+      // unused
+      "external" /* EXTERNAL */,
+      "internal" /* INTERNAL */
+    ]
+  },
+  buyTokenBalance: {
+    offset: 4,
+    options: ["erc20" /* ERC20 */, "internal" /* INTERNAL */]
+  },
+  signingScheme: {
+    offset: 5,
+    options: [0 /* EIP712 */, 1 /* ETHSIGN */, 2 /* EIP1271 */, 3 /* PRESIGN */]
+  }
+};
+function encodeFlag(key, flag) {
+  const index = FLAG_MASKS[key].options.findIndex((search) => search === flag);
+  if (index === void 0) {
+    throw new Error(`Bad key/value pair to encode: ${key}/${flag}`);
+  }
+  return index << FLAG_MASKS[key].offset;
+}
+function mask(options) {
+  const num = options.length;
+  const bitCount = 32 - Math.clz32(num - 1);
+  return (1 << bitCount) - 1;
+}
+function decodeFlag(key, flag) {
+  const { offset, options } = FLAG_MASKS[key];
+  const numberFlags = getGlobalAdapter6().utils.toNumber(flag);
+  const index = numberFlags >> offset & mask(options);
+  const decoded = options[index];
+  if (decoded === void 0 || index < 0) {
+    throw new Error(`Invalid input flag for ${key}: 0b${numberFlags.toString(2)}`);
+  }
+  return decoded;
+}
+function encodeSigningScheme(scheme) {
+  return encodeFlag("signingScheme", scheme);
+}
+function decodeSigningScheme(flags) {
+  return decodeFlag("signingScheme", flags);
+}
+function encodeOrderFlags(flags) {
+  return encodeFlag("kind", flags.kind) | encodeFlag("partiallyFillable", flags.partiallyFillable) | encodeFlag("sellTokenBalance", flags.sellTokenBalance ?? "erc20" /* ERC20 */) | encodeFlag("buyTokenBalance", normalizeBuyTokenBalance(flags.buyTokenBalance));
+}
+function decodeOrderFlags(flags) {
+  return {
+    kind: decodeFlag("kind", flags),
+    partiallyFillable: decodeFlag("partiallyFillable", flags),
+    sellTokenBalance: decodeFlag("sellTokenBalance", flags),
+    buyTokenBalance: decodeFlag("buyTokenBalance", flags)
+  };
+}
+function encodeTradeFlags(flags) {
+  return encodeOrderFlags(flags) | encodeSigningScheme(flags.signingScheme);
+}
+function decodeTradeFlags(flags) {
+  return {
+    ...decodeOrderFlags(flags),
+    signingScheme: decodeSigningScheme(flags)
+  };
+}
+function encodeSignatureData(sig) {
+  const adapter = getGlobalAdapter6();
+  switch (sig.scheme) {
+    case 0 /* EIP712 */:
+    case 1 /* ETHSIGN */:
+      return adapter.utils.joinSignature(adapter.utils.splitSignature(sig.data));
+    case 2 /* EIP1271 */:
+      return encodeEip1271SignatureData(sig.data);
+    case 3 /* PRESIGN */:
+      return adapter.utils.getChecksumAddress(sig.data);
+    default:
+      throw new Error("unsupported signing scheme");
+  }
+}
+function decodeSignatureOwner(domain, order, scheme, sig) {
+  const adapter = getGlobalAdapter6();
+  switch (scheme) {
+    case 0 /* EIP712 */:
+      return adapter.utils.verifyTypedData(domain, { Order: ORDER_TYPE_FIELDS }, normalizeOrder(order), sig);
+    case 1 /* ETHSIGN */:
+      return adapter.utils.verifyMessage(
+        adapter.utils.arrayify(hashTypedData(domain, { Order: ORDER_TYPE_FIELDS }, normalizeOrder(order))),
+        sig
+      );
+    case 2 /* EIP1271 */:
+      return decodeEip1271SignatureData(sig).verifier;
+    case 3 /* PRESIGN */:
+      return adapter.utils.getChecksumAddress(adapter.utils.hexlify(sig));
+    default:
+      throw new Error("unsupported signing scheme");
+  }
+}
+function encodeTrade(tokens, order, signature, { executedAmount }) {
+  const tradeFlags = {
+    ...order,
+    signingScheme: signature.scheme
+  };
+  const o = normalizeOrder(order);
+  return {
+    sellTokenIndex: tokens.index(o.sellToken),
+    buyTokenIndex: tokens.index(o.buyToken),
+    receiver: o.receiver,
+    sellAmount: o.sellAmount,
+    buyAmount: o.buyAmount,
+    validTo: o.validTo,
+    appData: o.appData,
+    feeAmount: o.feeAmount,
+    flags: encodeTradeFlags(tradeFlags),
+    executedAmount,
+    signature: encodeSignatureData(signature)
+  };
+}
+var TokenRegistry = class {
+  /**
+   * Creates a new TokenRegistry instance
+   *
+   * @param adapter Provider adapter implementation
+   */
+  constructor(adapter) {
+    if (adapter)
+      setGlobalAdapter(adapter);
+  }
+  _tokens = [];
+  _tokenMap = {};
+  /**
+   * Gets the array of token addresses currently stored in the registry.
+   */
+  get addresses() {
+    return this._tokens.slice();
+  }
+  /**
+   * 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) {
+    const tokenAddress = getGlobalAdapter6().utils.getChecksumAddress(token);
+    let tokenIndex = this._tokenMap[tokenAddress];
+    if (tokenIndex === void 0) {
+      tokenIndex = this._tokens.length;
+      this._tokens.push(tokenAddress);
+      this._tokenMap[tokenAddress] = tokenIndex;
+    }
+    return tokenIndex;
+  }
+};
+var SettlementEncoder = class _SettlementEncoder {
+  /**
+   * Creates a new settlement encoder instance.
+   * @param domain Domain used for signing orders. See {@link signOrder} for
+   * more details.
+   */
+  constructor(domain, adapter) {
+    this.domain = domain;
+    if (adapter)
+      setGlobalAdapter(adapter);
+  }
+  _tokens = new TokenRegistry();
+  _trades = [];
+  _interactions = {
+    [0 /* PRE */]: [],
+    [1 /* INTRA */]: [],
+    [2 /* POST */]: []
+  };
+  _orderRefunds = {
+    filledAmounts: [],
+    preSignatures: []
+  };
+  /**
+   * Gets the array of token addresses used by the currently encoded orders.
+   */
+  get tokens() {
+    return this._tokens.addresses;
+  }
+  /**
+   * Gets the encoded trades.
+   */
+  get trades() {
+    return this._trades.slice();
+  }
+  /**
+   * Gets all encoded interactions for all stages.
+   *
+   * Note that order refund interactions are included as post-interactions.
+   */
+  get interactions() {
+    return [
+      this._interactions[0 /* PRE */].slice(),
+      this._interactions[1 /* INTRA */].slice(),
+      [...this._interactions[2 /* POST */], ...this.encodedOrderRefunds]
+    ];
+  }
+  /**
+   * Gets the order refunds encoded as interactions.
+   */
+  get encodedOrderRefunds() {
+    const { filledAmounts, preSignatures } = this._orderRefunds;
+    if (filledAmounts.length + preSignatures.length === 0) {
+      return [];
+    }
+    const settlement = this.domain.verifyingContract;
+    if (settlement === void 0) {
+      throw new Error("domain missing settlement contract address");
+    }
+    const iface = getGlobalAdapter6().utils.createInterface([
+      "function freeFilledAmountStorage(bytes[] orderUids)",
+      "function freePreSignatureStorage(bytes[] orderUids)"
+    ]);
+    const interactions = [];
+    for (const [functionName, orderUids] of [
+      ["freeFilledAmountStorage", filledAmounts],
+      ["freePreSignatureStorage", preSignatures]
+    ].filter(([, orderUids2]) => orderUids2.length > 0)) {
+      interactions.push(
+        normalizeInteraction({
+          target: settlement,
+          callData: iface.encodeFunctionData(functionName, [orderUids])
+        })
+      );
+    }
+    return interactions;
+  }
+  /**
+   * 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) {
+    return this.tokens.map((token) => {
+      const price = prices[token];
+      if (price === void 0) {
+        throw new Error(`missing price for token ${token}`);
+      }
+      return price;
+    });
+  }
+  /**
+   * 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, signature, { executedAmount } = {}) {
+    if (order.partiallyFillable && executedAmount === void 0) {
+      throw new Error("missing executed amount for partially fillable trade");
+    }
+    this._trades.push(
+      encodeTrade(this._tokens, order, signature, {
+        executedAmount: executedAmount ?? 0
+      })
+    );
+  }
+  /**
+   * 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.
+   */
+  async signEncodeTrade(order, scheme, tradeExecution, owner) {
+    const signature = await signOrder(this.domain, order, scheme, owner);
+    this.encodeTrade(order, signature, tradeExecution);
+  }
+  /**
+   * 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, stage = 1 /* INTRA */) {
+    this._interactions[stage].push(normalizeInteraction(interaction));
+  }
+  /**
+   * Encodes order UIDs for gas refunds.
+   *
+   * @param settlement The address of the settlement contract.
+   * @param orderRefunds The order refunds to encode.
+   */
+  encodeOrderRefunds(orderRefunds) {
+    if (this.domain.verifyingContract === void 0) {
+      throw new Error("domain missing settlement contract address");
+    }
+    const filledAmounts = orderRefunds.filledAmounts ?? [];
+    const preSignatures = orderRefunds.preSignatures ?? [];
+    for (const orderUid of [...filledAmounts, ...preSignatures]) {
+      const bytes = getGlobalAdapter6().utils.arrayify(orderUid);
+      if (bytes.length !== ORDER_UID_LENGTH) {
+        throw new Error("one or more invalid order UIDs");
+      }
+    }
+    this._orderRefunds.filledAmounts.push(...filledAmounts);
+    this._orderRefunds.preSignatures.push(...preSignatures);
+  }
+  /**
+   * Returns the encoded settlement parameters.
+   */
+  encodedSettlement(prices) {
+    return [this.tokens, this.clearingPrices(prices), this.trades, this.interactions];
+  }
+  /**
+   * 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) {
+    const encoder = new _SettlementEncoder({ name: "unused" });
+    for (const interaction of interactions) {
+      encoder.encodeInteraction(interaction);
+    }
+    return encoder.encodedSettlement({});
+  }
+};
+function decodeOrder(trade, tokens) {
+  const adapter = getGlobalAdapter6();
+  const sellTokenIndex = adapter.utils.toNumber(adapter.utils.toBigIntish(trade.sellTokenIndex));
+  const buyTokenIndex = adapter.utils.toNumber(adapter.utils.toBigIntish(trade.buyTokenIndex));
+  if (Math.max(sellTokenIndex, buyTokenIndex) >= tokens.length) {
+    throw new Error("Invalid trade");
+  }
+  return {
+    sellToken: tokens[sellTokenIndex],
+    buyToken: tokens[buyTokenIndex],
+    receiver: trade.receiver,
+    sellAmount: trade.sellAmount,
+    buyAmount: trade.buyAmount,
+    validTo: adapter.utils.toNumber(adapter.utils.toBigIntish(trade.validTo)),
+    appData: trade.appData,
+    feeAmount: trade.feeAmount,
+    ...decodeOrderFlags(trade.flags)
+  };
+}
+
+// src/swap.ts
+import {
+  setGlobalAdapter as setGlobalAdapter2
+} from "@cowprotocol/sdk-common";
+function encodeSwapStep(tokens, swap) {
+  return {
+    poolId: swap.poolId,
+    assetInIndex: tokens.index(swap.assetIn),
+    assetOutIndex: tokens.index(swap.assetOut),
+    amount: swap.amount,
+    userData: swap.userData || "0x"
+  };
+}
+var SwapEncoder = class _SwapEncoder {
+  /**
+   * Creates a new settlement encoder instance.
+   *
+   * @param domain Domain used for signing orders. See {@link signOrder} for
+   * more details.
+   */
+  constructor(domain, adapter) {
+    this.domain = domain;
+    if (adapter)
+      setGlobalAdapter2(adapter);
+  }
+  _tokens = new TokenRegistry();
+  _swaps = [];
+  _trade = void 0;
+  /**
+   * Gets the array of token addresses used by the currently encoded swaps.
+   */
+  get tokens() {
+    return this._tokens.addresses;
+  }
+  /**
+   * Gets the encoded swaps.
+   */
+  get swaps() {
+    return this._swaps.slice();
+  }
+  /**
+   * Gets the encoded trade.
+   */
+  get trade() {
+    if (this._trade === void 0) {
+      throw new Error("trade not encoded");
+    }
+    return this._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) {
+    this._swaps.push(...swaps.map((swap) => encodeSwapStep(this._tokens, swap)));
+  }
+  /**
+   * 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, signature, swapExecution) {
+    const { limitAmount } = {
+      limitAmount: order.kind == "sell" /* SELL */ ? order.buyAmount : order.sellAmount,
+      ...swapExecution
+    };
+    this._trade = encodeTrade(this._tokens, order, signature, {
+      executedAmount: limitAmount
+    });
+  }
+  /**
+   * 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.
+   */
+  async signEncodeTrade(order, scheme, swapExecution, owner) {
+    const signature = await signOrder(this.domain, order, scheme, owner);
+    this.encodeTrade(order, signature, swapExecution);
+  }
+  /**
+   * 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() {
+    return [this.swaps, this.tokens, this.trade];
+  }
+  /**
+   * Utility method for encoding a direct swap between an order and Balancer
+   * pools.
+   *
+   * This method functions identically to using a {@link SwapEncoder} and is
+   * provided as a short-cut.
+   */
+  static encodeSwap(...args) {
+    if (args.length < 5) {
+      const [swaps, order, signature, swapExecution] = args;
+      const encoder = new _SwapEncoder({});
+      encoder.encodeSwapStep(...swaps);
+      encoder.encodeTrade(order, signature, swapExecution);
+      return encoder.encodedSwap();
+    } else {
+      const [domain, swaps, order, owner, scheme, swapExecution] = args;
+      const encoder = new _SwapEncoder(domain);
+      encoder.encodeSwapStep(...swaps);
+      return encoder.signEncodeTrade(order, scheme, swapExecution, owner).then(() => encoder.encodedSwap());
+    }
+  }
+};
+
+// src/ContractsTs.ts
+var ContractsTs = class {
+  // Make ORDER_TYPE_FIELDS and ORDER_UID_LENGTH available
+  ORDER_TYPE_FIELDS = ORDER_TYPE_FIELDS;
+  ORDER_UID_LENGTH = ORDER_UID_LENGTH;
+  /**
+   * Creates a new ContractsTs instance
+   *
+   * @param adapter Provider adapter implementation
+   */
+  constructor(adapter) {
+    setGlobalAdapter3(adapter);
+  }
+  //deploy
+  deterministicDeploymentAddress = deterministicDeploymentAddress;
+  //interaction
+  normalizeInteraction = normalizeInteraction;
+  normalizeInteractions = normalizeInteractions;
+  //order
+  timestamp = timestamp;
+  hashify = hashify;
+  normalizeBuyTokenBalance = normalizeBuyTokenBalance;
+  normalizeOrder = normalizeOrder;
+  hashTypedData = hashTypedData;
+  hashOrder = hashOrder;
+  computeOrderUid = computeOrderUid;
+  packOrderUidParams = packOrderUidParams;
+  extractOrderUidParams = extractOrderUidParams;
+  //proxy
+  implementationAddress = implementationAddress;
+  ownerAddress = ownerAddress;
+  //sign
+  signOrder = signOrder;
+  encodeEip1271SignatureData = encodeEip1271SignatureData;
+  decodeEip1271SignatureData = decodeEip1271SignatureData;
+  //vault
+  grantRequiredRoles = grantRequiredRoles;
+  //settlement
+  encodeSigningScheme = encodeSigningScheme;
+  decodeSigningScheme = decodeSigningScheme;
+  encodeOrderFlags = encodeOrderFlags;
+  decodeOrderFlags = decodeOrderFlags;
+  encodeTradeFlags = encodeTradeFlags;
+  decodeTradeFlags = decodeTradeFlags;
+  encodeSignatureData = encodeSignatureData;
+  decodeSignatureOwner = decodeSignatureOwner;
+  encodeTrade = encodeTrade;
+  decodeOrder = decodeOrder;
+  TokenRegistry = TokenRegistry;
+  SettlementEncoder = SettlementEncoder;
+  InteractionStage = InteractionStage;
+  FLAG_MASKS = FLAG_MASKS;
+  //swap
+  encodeSwapStep = encodeSwapStep;
+  SwapEncoder = 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, verifyingContract) {
+    return {
+      name: "Gnosis Protocol",
+      version: "v2",
+      chainId,
+      verifyingContract
+    };
+  }
+};
+
+// src/api.ts
+import { getGlobalAdapter as getGlobalAdapter7 } from "@cowprotocol/sdk-common";
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2[Environment2["Dev"] = 0] = "Dev";
+  Environment2[Environment2["Prod"] = 1] = "Prod";
+  return Environment2;
+})(Environment || {});
+var LIMIT_CONCURRENT_REQUESTS = 5;
+function apiUrl(environment, network) {
+  switch (environment) {
+    case 0 /* Dev */:
+      return `https://barn.api.cow.fi/${network}`;
+    case 1 /* Prod */:
+      return `https://api.cow.fi/${network}`;
+    default:
+      throw new Error("Invalid environment");
+  }
+}
+var QuotePriceQuality = /* @__PURE__ */ ((QuotePriceQuality2) => {
+  QuotePriceQuality2["FAST"] = "fast";
+  QuotePriceQuality2["OPTIMAL"] = "optimal";
+  return QuotePriceQuality2;
+})(QuotePriceQuality || {});
+var GetQuoteErrorType = /* @__PURE__ */ ((GetQuoteErrorType2) => {
+  GetQuoteErrorType2["SellAmountDoesNotCoverFee"] = "SellAmountDoesNotCoverFee";
+  GetQuoteErrorType2["NoLiquidity"] = "NoLiquidity";
+  return GetQuoteErrorType2;
+})(GetQuoteErrorType || {});
+function apiKind(kind) {
+  switch (kind) {
+    case "sell" /* SELL */:
+      return "sell";
+    case "buy" /* BUY */:
+      return "buy";
+    default:
+      throw new Error(`Unsupported kind ${kind}`);
+  }
+}
+function apiSigningScheme(scheme) {
+  switch (scheme) {
+    case 0 /* EIP712 */:
+      return "eip712";
+    case 1 /* ETHSIGN */:
+      return "ethsign";
+    case 2 /* EIP1271 */:
+      return "eip1271";
+    case 3 /* PRESIGN */:
+      return "presign";
+    default:
+      throw new Error(`Unsupported signing scheme ${scheme}`);
+  }
+}
+async function call(route, baseUrl, init) {
+  const url = `${baseUrl}/api/v1/${route}`;
+  const response = await fetch(url, init);
+  const body = await response.text();
+  if (!response.ok) {
+    const error = new Error(
+      `Calling "${url} ${JSON.stringify(init)} failed with ${response.status}: ${body}`
+    );
+    try {
+      error.apiError = JSON.parse(body);
+    } catch {
+    }
+    throw error;
+  }
+  return JSON.parse(body);
+}
+async function estimateTradeAmount({
+  sellToken,
+  buyToken,
+  kind,
+  amount,
+  baseUrl
+}) {
+  const side = kind == "sell" /* SELL */ ? {
+    kind: "sell" /* SELL */,
+    sellAmountAfterFee: amount
+  } : {
+    kind: "buy" /* BUY */,
+    buyAmountAfterFee: amount
+  };
+  const { quote } = await getQuote(
+    { baseUrl },
+    {
+      from: "0x0000000000000000000000000000000000000000",
+      sellToken,
+      buyToken,
+      priceQuality: "fast" /* FAST */,
+      ...side
+    }
+  );
+  if (quote.buyToken.toLowerCase() !== buyToken.toLowerCase()) {
+    throw new Error(
+      `Price returned for sell token ${sellToken} uses an incorrect quote token (${quote.buyToken.toLowerCase()} instead of ${buyToken.toLowerCase()})`
+    );
+  }
+  const estimatedAmount = kind == "sell" /* SELL */ ? quote.buyAmount : quote.sellAmount;
+  return getGlobalAdapter7().utils.toBigIntish(estimatedAmount);
+}
+async function placeOrder({ order, signature, baseUrl, from }) {
+  const normalizedOrder = normalizeOrder(order);
+  const adapter = getGlobalAdapter7();
+  return await call("orders", baseUrl, {
+    method: "post",
+    body: JSON.stringify({
+      sellToken: normalizedOrder.sellToken,
+      buyToken: normalizedOrder.buyToken,
+      sellAmount: String(adapter.utils.toBigIntish(normalizedOrder.sellAmount)),
+      buyAmount: String(adapter.utils.toBigIntish(normalizedOrder.buyAmount)),
+      validTo: normalizedOrder.validTo,
+      appData: normalizedOrder.appData,
+      feeAmount: String(adapter.utils.toBigIntish(normalizedOrder.feeAmount)),
+      kind: apiKind(order.kind),
+      partiallyFillable: normalizedOrder.partiallyFillable,
+      signature: encodeSignatureData(signature),
+      signingScheme: apiSigningScheme(signature.scheme),
+      receiver: normalizedOrder.receiver,
+      from
+    }),
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function getExecutedSellAmount({ uid, baseUrl }) {
+  const response = await call(`orders/${uid}`, baseUrl);
+  return getGlobalAdapter7().utils.toBigIntish(response.executedSellAmount);
+}
+async function getQuote({ baseUrl }, quote) {
+  if (quote.sellAmountBeforeFee) {
+    ;
+    quote.sellAmountBeforeFee = String(quote.sellAmountBeforeFee);
+  }
+  if (quote.sellAmountAfterFee) {
+    ;
+    quote.sellAmountAfterFee = String(quote.sellAmountAfterFee);
+  }
+  if (quote.buyAmountAfterFee) {
+    ;
+    quote.buyAmountAfterFee = String(quote.buyAmountAfterFee);
+  }
+  return call("quote", baseUrl, {
+    method: "post",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(quote)
+  });
+}
+var Api = class {
+  network;
+  baseUrl;
+  constructor(network, baseUrlOrEnv) {
+    this.network = network;
+    let baseUrl;
+    if (typeof baseUrlOrEnv === "string") {
+      baseUrl = baseUrlOrEnv;
+    } else {
+      baseUrl = apiUrl(baseUrlOrEnv, network);
+    }
+    this.baseUrl = baseUrl;
+  }
+  apiCallParams() {
+    return { network: this.network, baseUrl: this.baseUrl };
+  }
+  async estimateTradeAmount(query) {
+    return estimateTradeAmount({ ...this.apiCallParams(), ...query });
+  }
+  async placeOrder(query) {
+    return placeOrder({ ...this.apiCallParams(), ...query });
+  }
+  async getExecutedSellAmount(query) {
+    return getExecutedSellAmount({ ...this.apiCallParams(), ...query });
+  }
+  async getQuote(query) {
+    return getQuote(this.apiCallParams(), query);
+  }
+};
+
+// src/reader.ts
+import { getGlobalAdapter as getGlobalAdapter8 } from "@cowprotocol/sdk-common";
+async function readStorage(baseAddress, baseAbi, readerAddress, readerAbi, provider, method, parameters) {
+  return getGlobalAdapter8().utils.readStorage(
+    baseAddress,
+    baseAbi,
+    readerAddress,
+    readerAbi,
+    provider,
+    method,
+    parameters
+  );
+}
+var AllowListReader = class {
+  constructor(allowListAddress, allowListAbi, readerAddress, readerAbi, provider) {
+    this.allowListAddress = allowListAddress;
+    this.allowListAbi = allowListAbi;
+    this.readerAddress = readerAddress;
+    this.readerAbi = readerAbi;
+    this.provider = provider;
+  }
+  /**
+   * Returns true if all the specified addresses are allowed solvers.
+   */
+  async areSolvers(solvers) {
+    return String(
+      await readStorage(
+        this.allowListAddress,
+        this.allowListAbi,
+        this.readerAddress,
+        this.readerAbi,
+        this.provider,
+        "areSolvers",
+        [solvers]
+      )
+    );
+  }
+};
+var SettlementReader = class {
+  constructor(settlementAddress, settlementAbi, readerAddress, readerAbi, provider) {
+    this.settlementAddress = settlementAddress;
+    this.settlementAbi = settlementAbi;
+    this.readerAddress = readerAddress;
+    this.readerAbi = readerAbi;
+    this.provider = provider;
+  }
+  /**
+   * Read and return filled amounts for a list of orders
+   */
+  async filledAmountsForOrders(orderUids) {
+    return await readStorage(
+      this.settlementAddress,
+      this.settlementAbi,
+      this.readerAddress,
+      this.readerAbi,
+      this.provider,
+      "filledAmountsForOrders",
+      [orderUids]
+    );
+  }
+};
+var TradeSimulator = class {
+  constructor(settlementAddress, settlementAbi, simulatorAddress, simulatorAbi, provider) {
+    this.settlementAddress = settlementAddress;
+    this.settlementAbi = settlementAbi;
+    this.simulatorAddress = simulatorAddress;
+    this.simulatorAbi = simulatorAbi;
+    this.provider = provider;
+  }
+  /**
+   * Simulates the single order settlement for an executed trade and a set of
+   * interactions.
+   */
+  async simulateTrade(trade, interactions) {
+    const adapter = getGlobalAdapter8();
+    const normalizedTrade = {
+      ...trade,
+      receiver: trade.receiver ?? adapter.ZERO_ADDRESS,
+      sellTokenBalance: adapter.utils.id(trade.sellTokenBalance ?? "erc20" /* ERC20 */),
+      buyTokenBalance: adapter.utils.id(trade.buyTokenBalance ?? "erc20" /* ERC20 */)
+    };
+    const normalizedInteractions = [
+      normalizeInteractions(interactions[0 /* PRE */] ?? []),
+      normalizeInteractions(interactions[1 /* INTRA */] ?? []),
+      normalizeInteractions(interactions[2 /* POST */] ?? [])
+    ];
+    return await readStorage(
+      this.settlementAddress,
+      this.settlementAbi,
+      this.simulatorAddress,
+      this.simulatorAbi,
+      this.provider,
+      "simulateTrade",
+      [normalizedTrade, normalizedInteractions]
+    );
+  }
+};
+
+// src/signers.ts
+import { getGlobalAdapter as getGlobalAdapter9 } from "@cowprotocol/sdk-common";
+function getTypedDataVersionedSigner(signer, version) {
+  const adapter = getGlobalAdapter9();
+  return new adapter.TypedDataVersionedSigner(signer, version);
+}
+function getTypedDataV3Signer(signer) {
+  const adapter = getGlobalAdapter9();
+  return new adapter.TypedDataV3Signer(signer);
+}
+function getIntChainIdTypedDataV4Signer(signer) {
+  const adapter = getGlobalAdapter9();
+  return new adapter.IntChainIdTypedDataV4Signer(signer);
+}
+
+// src/generated/packageVersion.ts
+var CONTRACTS_PKG_VERSION = "0.1.0";
+export {
+  AllowListReader,
+  Api,
+  BUY_ETH_ADDRESS,
+  CANCELLATIONS_TYPE_FIELDS,
+  CONTRACTS_PKG_VERSION,
+  CONTRACT_NAMES,
+  OrderKind as ContractsOrderKind,
+  SigningScheme as ContractsSigningScheme,
+  ContractsTs,
+  DEPLOYER_CONTRACT,
+  EIP1271_MAGICVALUE,
+  EIP173_PROXY_ABI,
+  Environment,
+  FLAG_MASKS,
+  GetQuoteErrorType,
+  InteractionStage,
+  LIMIT_CONCURRENT_REQUESTS,
+  ORDER_TYPE_FIELDS,
+  ORDER_TYPE_HASH,
+  ORDER_UID_LENGTH,
+  OrderBalance,
+  PRE_SIGNED,
+  QuotePriceQuality,
+  SALT,
+  SettlementEncoder,
+  SettlementReader,
+  SwapEncoder,
+  TokenRegistry,
+  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
+};