9860366179

Committed 09 Jul 2024 04:00PM UTC coverage: 48.628% (+0.4%) from 48.272%

Build # 9860366179

Build Type

Pull #1734

github

Committed by

iamacook

Commit Message

Assure data is of `setPreSignature`

Pull Request Pull Request #1734: Generate specific function/event decoders in `AbiDecoder`

Run Details

415 of 2568 branches covered (16.16%)

Branch coverage included in aggregate %.

48 of 100 new or added lines in 11 files covered. (48.0%)

9 existing lines in 1 file now uncovered.

4247 of 7019 relevant lines covered (60.51%)

14.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.63

/src/domain/swaps/contracts/decoders/composable-cow-decoder.helper.ts

import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { Inject, Injectable } from '@nestjs/common';
import { decodeAbiParameters, isAddressEqual, parseAbiParameters } from 'viem';

/**
 * Taken from CoW SDK:
 *
 * @see https://github.com/cowprotocol/cow-sdk/blob/5aa61a03d2ed9921c5f95522866b2af0ceb1c24d/abi/ComposableCoW.json
 *
 * TODO: We should locate this in @/abis/... but we will need to refactor the /scripts/generate-abis.js
 * to handle ABIs that are present (or alternatively install the @cowprotocol/contracts package and generate
 * the ABIs from there)
 */
export const ComposableCowAbi = [
  {
    inputs: [
      {
        internalType: 'address',
        name: '_settlement',
        type: 'address',
      },
    ],
    stateMutability: 'nonpayable',
    type: 'constructor',
  },
  {
    inputs: [],
    name: 'InterfaceNotSupported',
    type: 'error',
  },
  {
    inputs: [],
    name: 'InvalidHandler',
    type: 'error',
  },
  {
    inputs: [],
    name: 'ProofNotAuthed',
    type: 'error',
  },
  {
    inputs: [],
    name: 'SingleOrderNotAuthed',
    type: 'error',
  },
  {
    inputs: [],
    name: 'SwapGuardRestricted',
    type: 'error',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        components: [
          {
            internalType: 'contract IConditionalOrder',
            name: 'handler',
            type: 'address',
          },
          {
            internalType: 'bytes32',
            name: 'salt',
            type: 'bytes32',
          },
          {
            internalType: 'bytes',
            name: 'staticInput',
            type: 'bytes',
          },
        ],
        indexed: false,
        internalType: 'struct IConditionalOrder.ConditionalOrderParams',
        name: 'params',
        type: 'tuple',
      },
    ],
    name: 'ConditionalOrderCreated',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'bytes32',
        name: 'root',
        type: 'bytes32',
      },
      {
        components: [
          {
            internalType: 'uint256',
            name: 'location',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'data',
            type: 'bytes',
          },
        ],
        indexed: false,
        internalType: 'struct ComposableCoW.Proof',
        name: 'proof',
        type: 'tuple',
      },
    ],
    name: 'MerkleRootSet',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'contract ISwapGuard',
        name: 'swapGuard',
        type: 'address',
      },
    ],
    name: 'SwapGuardSet',
    type: 'event',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: '',
        type: 'address',
      },
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    name: 'cabinet',
    outputs: [
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        components: [
          {
            internalType: 'contract IConditionalOrder',
            name: 'handler',
            type: 'address',
          },
          {
            internalType: 'bytes32',
            name: 'salt',
            type: 'bytes32',
          },
          {
            internalType: 'bytes',
            name: 'staticInput',
            type: 'bytes',
          },
        ],
        internalType: 'struct IConditionalOrder.ConditionalOrderParams',
        name: 'params',
        type: 'tuple',
      },
      {
        internalType: 'bool',
        name: 'dispatch',
        type: 'bool',
      },
    ],
    name: 'create',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        components: [
          {
            internalType: 'contract IConditionalOrder',
            name: 'handler',
            type: 'address',
          },
          {
            internalType: 'bytes32',
            name: 'salt',
            type: 'bytes32',
          },
          {
            internalType: 'bytes',
            name: 'staticInput',
            type: 'bytes',
          },
        ],
        internalType: 'struct IConditionalOrder.ConditionalOrderParams',
        name: 'params',
        type: 'tuple',
      },
      {
        internalType: 'contract IValueFactory',
        name: 'factory',
        type: 'address',
      },
      {
        internalType: 'bytes',
        name: 'data',
        type: 'bytes',
      },
      {
        internalType: 'bool',
        name: 'dispatch',
        type: 'bool',
      },
    ],
    name: 'createWithContext',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [],
    name: 'domainSeparator',
    outputs: [
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        components: [
          {
            internalType: 'contract IConditionalOrder',
            name: 'handler',
            type: 'address',
          },
          {
            internalType: 'bytes32',
            name: 'salt',
            type: 'bytes32',
          },
          {
            internalType: 'bytes',
            name: 'staticInput',
            type: 'bytes',
          },
        ],
        internalType: 'struct IConditionalOrder.ConditionalOrderParams',
        name: 'params',
        type: 'tuple',
      },
      {
        internalType: 'bytes',
        name: 'offchainInput',
        type: 'bytes',
      },
      {
        internalType: 'bytes32[]',
        name: 'proof',
        type: 'bytes32[]',
      },
    ],
    name: 'getTradeableOrderWithSignature',
    outputs: [
      {
        components: [
          {
            internalType: 'contract IERC20',
            name: 'sellToken',
            type: 'address',
          },
          {
            internalType: 'contract IERC20',
            name: 'buyToken',
            type: 'address',
          },
          {
            internalType: 'address',
            name: 'receiver',
            type: 'address',
          },
          {
            internalType: 'uint256',
            name: 'sellAmount',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'buyAmount',
            type: 'uint256',
          },
          {
            internalType: 'uint32',
            name: 'validTo',
            type: 'uint32',
          },
          {
            internalType: 'bytes32',
            name: 'appData',
            type: 'bytes32',
          },
          {
            internalType: 'uint256',
            name: 'feeAmount',
            type: 'uint256',
          },
          {
            internalType: 'bytes32',
            name: 'kind',
            type: 'bytes32',
          },
          {
            internalType: 'bool',
            name: 'partiallyFillable',
            type: 'bool',
          },
          {
            internalType: 'bytes32',
            name: 'sellTokenBalance',
            type: 'bytes32',
          },
          {
            internalType: 'bytes32',
            name: 'buyTokenBalance',
            type: 'bytes32',
          },
        ],
        internalType: 'struct GPv2Order.Data',
        name: 'order',
        type: 'tuple',
      },
      {
        internalType: 'bytes',
        name: 'signature',
        type: 'bytes',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        components: [
          {
            internalType: 'contract IConditionalOrder',
            name: 'handler',
            type: 'address',
          },
          {
            internalType: 'bytes32',
            name: 'salt',
            type: 'bytes32',
          },
          {
            internalType: 'bytes',
            name: 'staticInput',
            type: 'bytes',
          },
        ],
        internalType: 'struct IConditionalOrder.ConditionalOrderParams',
        name: 'params',
        type: 'tuple',
      },
    ],
    name: 'hash',
    outputs: [
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    stateMutability: 'pure',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'contract Safe',
        name: 'safe',
        type: 'address',
      },
      {
        internalType: 'address',
        name: 'sender',
        type: 'address',
      },
      {
        internalType: 'bytes32',
        name: '_hash',
        type: 'bytes32',
      },
      {
        internalType: 'bytes32',
        name: '_domainSeparator',
        type: 'bytes32',
      },
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
      {
        internalType: 'bytes',
        name: 'encodeData',
        type: 'bytes',
      },
      {
        internalType: 'bytes',
        name: 'payload',
        type: 'bytes',
      },
    ],
    name: 'isValidSafeSignature',
    outputs: [
      {
        internalType: 'bytes4',
        name: 'magic',
        type: 'bytes4',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes32',
        name: 'singleOrderHash',
        type: 'bytes32',
      },
    ],
    name: 'remove',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: '',
        type: 'address',
      },
    ],
    name: 'roots',
    outputs: [
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes32',
        name: 'root',
        type: 'bytes32',
      },
      {
        components: [
          {
            internalType: 'uint256',
            name: 'location',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'data',
            type: 'bytes',
          },
        ],
        internalType: 'struct ComposableCoW.Proof',
        name: 'proof',
        type: 'tuple',
      },
    ],
    name: 'setRoot',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes32',
        name: 'root',
        type: 'bytes32',
      },
      {
        components: [
          {
            internalType: 'uint256',
            name: 'location',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'data',
            type: 'bytes',
          },
        ],
        internalType: 'struct ComposableCoW.Proof',
        name: 'proof',
        type: 'tuple',
      },
      {
        internalType: 'contract IValueFactory',
        name: 'factory',
        type: 'address',
      },
      {
        internalType: 'bytes',
        name: 'data',
        type: 'bytes',
      },
    ],
    name: 'setRootWithContext',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'contract ISwapGuard',
        name: 'swapGuard',
        type: 'address',
      },
    ],
    name: 'setSwapGuard',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: '',
        type: 'address',
      },
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    name: 'singleOrders',
    outputs: [
      {
        internalType: 'bool',
        name: '',
        type: 'bool',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: '',
        type: 'address',
      },
    ],
    name: 'swapGuards',
    outputs: [
      {
        internalType: 'contract ISwapGuard',
        name: '',
        type: 'address',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
] as const;

/**
 * Decoder for ComposableCow contract which focuses on decoding TWAP (`createWithContext`) orders
 *
 * The following is based on teh CoW SDK implementation:
 * @see https://github.com/cowprotocol/cow-sdk/blob/5aa61a03d2ed9921c5f95522866b2af0ceb1c24d/src/composable/orderTypes/Twap.ts
 */
@Injectable()
export class ComposableCowDecoder extends AbiDecoder<typeof ComposableCowAbi> {
  // Address of the TWAP handler contract
  private static readonly TwapHandlerAddress =
    '0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5';

  // Define the ABI of the TwapStruct
  private static readonly TwapStructAbiParameters = parseAbiParameters(
    'address sellToken, address buyToken, address receiver, uint256 partSellAmount, uint256 minPartLimit, uint256 t0, uint256 n, uint256 t, uint256 span, bytes32 appData',
  );

  constructor(
    @Inject(LoggingService) readonly loggingService: ILoggingService,
  ) {
    super(loggingService, ComposableCowAbi);
  }

  /**
   * Decode {@link TwapStruct} from `createWithContext` data
   * @param data - transaction data to decode
   * @returns the decoded {@link TwapStruct}
   */
  decodeTwapStruct(data: `0x${string}`): TwapStruct {
    const decoded = this.decodeFunctionData.createWithContext(data);

    const [params] = decoded;

    if (
      !isAddressEqual(params.handler, ComposableCowDecoder.TwapHandlerAddress)
    ) {
      throw new Error('Invalid TWAP handler');
    }

    return this.decodeConditionalOrderParams(params.staticInput);
  }

  /**
   * Decode the `ConditionalOrderParams` from `createWithContext` data
   * @param staticInput - `staticInput` of `createWithContext` call
   * @returns decoded `ConditionalOrderParams` as {@link TwapStruct}
   */
  private decodeConditionalOrderParams(
    staticInput: `0x${string}`, // IConditionalOrder.ConditionalOrderParams calldata
  ): TwapStruct {
    const [
      sellToken,
      buyToken,
      receiver,
      partSellAmount,
      minPartLimit,
      t0,
      n,
      t,
      span,
      appData,
    ] = decodeAbiParameters(
      ComposableCowDecoder.TwapStructAbiParameters,
      staticInput,
    );

    return {
      sellToken,
      buyToken,
      receiver,
      partSellAmount,
      minPartLimit,
      t0,
      n,
      t,
      span,
      appData,
    };
  }
}

/**
 * Model of the contract's struct used for `staticIntput` of the `createWithContext` function
 * @see https://docs.cow.fi/cow-protocol/reference/sdks/cow-sdk/interfaces/TwapStruct
 */
export type TwapStruct = {
  /**
   * which token to sell
   */
  readonly sellToken: `0x${string}`;

  /**
   * which token to buy
   */
  readonly buyToken: `0x${string}`;

  /**
   * who to send the tokens to
   */
  readonly receiver: `0x${string}`;

  /**
   * Meta-data associated with the order. Normally would be the keccak256 hash of the document generated in http://github.com/cowprotocol/app-data
   *
   * This hash should have been uploaded to the API https://api.cow.fi/docs/#/default/put_api_v1_app_data__app_data_hash_ and potentially to other data availability protocols like IPFS.
   *
   */
  readonly appData: `0x${string}`;

  /**
   * amount of sellToken to sell in each part
   */
  readonly partSellAmount: bigint;

  /**
   * minimum amount of buyToken that must be bought in each part
   */
  readonly minPartLimit: bigint;

  /**
   * start time of the TWAP
   */
  readonly t0: bigint;

  /**
   * number of parts
   */
  readonly n: bigint;

  /**
   * duration of the TWAP interval
   */
  readonly t: bigint;

  /**
   * whether the TWAP is valid for the entire interval or not
   */
  readonly span: bigint;
};

1	import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';	16✔
2	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	16✔
3	import { Inject, Injectable } from '@nestjs/common';	16✔
4	import { decodeAbiParameters, isAddressEqual, parseAbiParameters } from 'viem';	16✔
5
6	/**
7	* Taken from CoW SDK:
8	*
9	* @see https://github.com/cowprotocol/cow-sdk/blob/5aa61a03d2ed9921c5f95522866b2af0ceb1c24d/abi/ComposableCoW.json
10	*
11	* TODO: We should locate this in @/abis/... but we will need to refactor the /scripts/generate-abis.js
12	* to handle ABIs that are present (or alternatively install the @cowprotocol/contracts package and generate
13	* the ABIs from there)
14	*/
15	export const ComposableCowAbi = [	16✔
16	{
17	inputs: [
18	{
19	internalType: 'address',
20	name: '_settlement',
21	type: 'address',
22	},
23	],
24	stateMutability: 'nonpayable',
25	type: 'constructor',
26	},
27	{
28	inputs: [],
29	name: 'InterfaceNotSupported',
30	type: 'error',
31	},
32	{
33	inputs: [],
34	name: 'InvalidHandler',
35	type: 'error',
36	},
37	{
38	inputs: [],
39	name: 'ProofNotAuthed',
40	type: 'error',
41	},
42	{
43	inputs: [],
44	name: 'SingleOrderNotAuthed',
45	type: 'error',
46	},
47	{
48	inputs: [],
49	name: 'SwapGuardRestricted',
50	type: 'error',
51	},
52	{
53	anonymous: false,
54	inputs: [
55	{
56	indexed: true,
57	internalType: 'address',
58	name: 'owner',
59	type: 'address',
60	},
61	{
62	components: [
63	{
64	internalType: 'contract IConditionalOrder',
65	name: 'handler',
66	type: 'address',
67	},
68	{
69	internalType: 'bytes32',
70	name: 'salt',
71	type: 'bytes32',
72	},
73	{
74	internalType: 'bytes',
75	name: 'staticInput',
76	type: 'bytes',
77	},
78	],
79	indexed: false,
80	internalType: 'struct IConditionalOrder.ConditionalOrderParams',
81	name: 'params',
82	type: 'tuple',
83	},
84	],
85	name: 'ConditionalOrderCreated',
86	type: 'event',
87	},
88	{
89	anonymous: false,
90	inputs: [
91	{
92	indexed: true,
93	internalType: 'address',
94	name: 'owner',
95	type: 'address',
96	},
97	{
98	indexed: false,
99	internalType: 'bytes32',
100	name: 'root',
101	type: 'bytes32',
102	},
103	{
104	components: [
105	{
106	internalType: 'uint256',
107	name: 'location',
108	type: 'uint256',
109	},
110	{
111	internalType: 'bytes',
112	name: 'data',
113	type: 'bytes',
114	},
115	],
116	indexed: false,
117	internalType: 'struct ComposableCoW.Proof',
118	name: 'proof',
119	type: 'tuple',
120	},
121	],
122	name: 'MerkleRootSet',
123	type: 'event',
124	},
125	{
126	anonymous: false,
127	inputs: [
128	{
129	indexed: true,
130	internalType: 'address',
131	name: 'owner',
132	type: 'address',
133	},
134	{
135	indexed: false,
136	internalType: 'contract ISwapGuard',
137	name: 'swapGuard',
138	type: 'address',
139	},
140	],
141	name: 'SwapGuardSet',
142	type: 'event',
143	},
144	{
145	inputs: [
146	{
147	internalType: 'address',
148	name: '',
149	type: 'address',
150	},
151	{
152	internalType: 'bytes32',
153	name: '',
154	type: 'bytes32',
155	},
156	],
157	name: 'cabinet',
158	outputs: [
159	{
160	internalType: 'bytes32',
161	name: '',
162	type: 'bytes32',
163	},
164	],
165	stateMutability: 'view',
166	type: 'function',
167	},
168	{
169	inputs: [
170	{
171	components: [
172	{
173	internalType: 'contract IConditionalOrder',
174	name: 'handler',
175	type: 'address',
176	},
177	{
178	internalType: 'bytes32',
179	name: 'salt',
180	type: 'bytes32',
181	},
182	{
183	internalType: 'bytes',
184	name: 'staticInput',
185	type: 'bytes',
186	},
187	],
188	internalType: 'struct IConditionalOrder.ConditionalOrderParams',
189	name: 'params',
190	type: 'tuple',
191	},
192	{
193	internalType: 'bool',
194	name: 'dispatch',
195	type: 'bool',
196	},
197	],
198	name: 'create',
199	outputs: [],
200	stateMutability: 'nonpayable',
201	type: 'function',
202	},
203	{
204	inputs: [
205	{
206	components: [
207	{
208	internalType: 'contract IConditionalOrder',
209	name: 'handler',
210	type: 'address',
211	},
212	{
213	internalType: 'bytes32',
214	name: 'salt',
215	type: 'bytes32',
216	},
217	{
218	internalType: 'bytes',
219	name: 'staticInput',
220	type: 'bytes',
221	},
222	],
223	internalType: 'struct IConditionalOrder.ConditionalOrderParams',
224	name: 'params',
225	type: 'tuple',
226	},
227	{
228	internalType: 'contract IValueFactory',
229	name: 'factory',
230	type: 'address',
231	},
232	{
233	internalType: 'bytes',
234	name: 'data',
235	type: 'bytes',
236	},
237	{
238	internalType: 'bool',
239	name: 'dispatch',
240	type: 'bool',
241	},
242	],
243	name: 'createWithContext',
244	outputs: [],
245	stateMutability: 'nonpayable',
246	type: 'function',
247	},
248	{
249	inputs: [],
250	name: 'domainSeparator',
251	outputs: [
252	{
253	internalType: 'bytes32',
254	name: '',
255	type: 'bytes32',
256	},
257	],
258	stateMutability: 'view',
259	type: 'function',
260	},
261	{
262	inputs: [
263	{
264	internalType: 'address',
265	name: 'owner',
266	type: 'address',
267	},
268	{
269	components: [
270	{
271	internalType: 'contract IConditionalOrder',
272	name: 'handler',
273	type: 'address',
274	},
275	{
276	internalType: 'bytes32',
277	name: 'salt',
278	type: 'bytes32',
279	},
280	{
281	internalType: 'bytes',
282	name: 'staticInput',
283	type: 'bytes',
284	},
285	],
286	internalType: 'struct IConditionalOrder.ConditionalOrderParams',
287	name: 'params',
288	type: 'tuple',
289	},
290	{
291	internalType: 'bytes',
292	name: 'offchainInput',
293	type: 'bytes',
294	},
295	{
296	internalType: 'bytes32[]',
297	name: 'proof',
298	type: 'bytes32[]',
299	},
300	],
301	name: 'getTradeableOrderWithSignature',
302	outputs: [
303	{
304	components: [
305	{
306	internalType: 'contract IERC20',
307	name: 'sellToken',
308	type: 'address',
309	},
310	{
311	internalType: 'contract IERC20',
312	name: 'buyToken',
313	type: 'address',
314	},
315	{
316	internalType: 'address',
317	name: 'receiver',
318	type: 'address',
319	},
320	{
321	internalType: 'uint256',
322	name: 'sellAmount',
323	type: 'uint256',
324	},
325	{
326	internalType: 'uint256',
327	name: 'buyAmount',
328	type: 'uint256',
329	},
330	{
331	internalType: 'uint32',
332	name: 'validTo',
333	type: 'uint32',
334	},
335	{
336	internalType: 'bytes32',
337	name: 'appData',
338	type: 'bytes32',
339	},
340	{
341	internalType: 'uint256',
342	name: 'feeAmount',
343	type: 'uint256',
344	},
345	{
346	internalType: 'bytes32',
347	name: 'kind',
348	type: 'bytes32',
349	},
350	{
351	internalType: 'bool',
352	name: 'partiallyFillable',
353	type: 'bool',
354	},
355	{
356	internalType: 'bytes32',
357	name: 'sellTokenBalance',
358	type: 'bytes32',
359	},
360	{
361	internalType: 'bytes32',
362	name: 'buyTokenBalance',
363	type: 'bytes32',
364	},
365	],
366	internalType: 'struct GPv2Order.Data',
367	name: 'order',
368	type: 'tuple',
369	},
370	{
371	internalType: 'bytes',
372	name: 'signature',
373	type: 'bytes',
374	},
375	],
376	stateMutability: 'view',
377	type: 'function',
378	},
379	{
380	inputs: [
381	{
382	components: [
383	{
384	internalType: 'contract IConditionalOrder',
385	name: 'handler',
386	type: 'address',
387	},
388	{
389	internalType: 'bytes32',
390	name: 'salt',
391	type: 'bytes32',
392	},
393	{
394	internalType: 'bytes',
395	name: 'staticInput',
396	type: 'bytes',
397	},
398	],
399	internalType: 'struct IConditionalOrder.ConditionalOrderParams',
400	name: 'params',
401	type: 'tuple',
402	},
403	],
404	name: 'hash',
405	outputs: [
406	{
407	internalType: 'bytes32',
408	name: '',
409	type: 'bytes32',
410	},
411	],
412	stateMutability: 'pure',
413	type: 'function',
414	},
415	{
416	inputs: [
417	{
418	internalType: 'contract Safe',
419	name: 'safe',
420	type: 'address',
421	},
422	{
423	internalType: 'address',
424	name: 'sender',
425	type: 'address',
426	},
427	{
428	internalType: 'bytes32',
429	name: '_hash',
430	type: 'bytes32',
431	},
432	{
433	internalType: 'bytes32',
434	name: '_domainSeparator',
435	type: 'bytes32',
436	},
437	{
438	internalType: 'bytes32',
439	name: '',
440	type: 'bytes32',
441	},
442	{
443	internalType: 'bytes',
444	name: 'encodeData',
445	type: 'bytes',
446	},
447	{
448	internalType: 'bytes',
449	name: 'payload',
450	type: 'bytes',
451	},
452	],
453	name: 'isValidSafeSignature',
454	outputs: [
455	{
456	internalType: 'bytes4',
457	name: 'magic',
458	type: 'bytes4',
459	},
460	],
461	stateMutability: 'view',
462	type: 'function',
463	},
464	{
465	inputs: [
466	{
467	internalType: 'bytes32',
468	name: 'singleOrderHash',
469	type: 'bytes32',
470	},
471	],
472	name: 'remove',
473	outputs: [],
474	stateMutability: 'nonpayable',
475	type: 'function',
476	},
477	{
478	inputs: [
479	{
480	internalType: 'address',
481	name: '',
482	type: 'address',
483	},
484	],
485	name: 'roots',
486	outputs: [
487	{
488	internalType: 'bytes32',
489	name: '',
490	type: 'bytes32',
491	},
492	],
493	stateMutability: 'view',
494	type: 'function',
495	},
496	{
497	inputs: [
498	{
499	internalType: 'bytes32',
500	name: 'root',
501	type: 'bytes32',
502	},
503	{
504	components: [
505	{
506	internalType: 'uint256',
507	name: 'location',
508	type: 'uint256',
509	},
510	{
511	internalType: 'bytes',
512	name: 'data',
513	type: 'bytes',
514	},
515	],
516	internalType: 'struct ComposableCoW.Proof',
517	name: 'proof',
518	type: 'tuple',
519	},
520	],
521	name: 'setRoot',
522	outputs: [],
523	stateMutability: 'nonpayable',
524	type: 'function',
525	},
526	{
527	inputs: [
528	{
529	internalType: 'bytes32',
530	name: 'root',
531	type: 'bytes32',
532	},
533	{
534	components: [
535	{
536	internalType: 'uint256',
537	name: 'location',
538	type: 'uint256',
539	},
540	{
541	internalType: 'bytes',
542	name: 'data',
543	type: 'bytes',
544	},
545	],
546	internalType: 'struct ComposableCoW.Proof',
547	name: 'proof',
548	type: 'tuple',
549	},
550	{
551	internalType: 'contract IValueFactory',
552	name: 'factory',
553	type: 'address',
554	},
555	{
556	internalType: 'bytes',
557	name: 'data',
558	type: 'bytes',
559	},
560	],
561	name: 'setRootWithContext',
562	outputs: [],
563	stateMutability: 'nonpayable',
564	type: 'function',
565	},
566	{
567	inputs: [
568	{
569	internalType: 'contract ISwapGuard',
570	name: 'swapGuard',
571	type: 'address',
572	},
573	],
574	name: 'setSwapGuard',
575	outputs: [],
576	stateMutability: 'nonpayable',
577	type: 'function',
578	},
579	{
580	inputs: [
581	{
582	internalType: 'address',
583	name: '',
584	type: 'address',
585	},
586	{
587	internalType: 'bytes32',
588	name: '',
589	type: 'bytes32',
590	},
591	],
592	name: 'singleOrders',
593	outputs: [
594	{
595	internalType: 'bool',
596	name: '',
597	type: 'bool',
598	},
599	],
600	stateMutability: 'view',
601	type: 'function',
602	},
603	{
604	inputs: [
605	{
606	internalType: 'address',
607	name: '',
608	type: 'address',
609	},
610	],
611	name: 'swapGuards',
612	outputs: [
613	{
614	internalType: 'contract ISwapGuard',
615	name: '',
616	type: 'address',
617	},
618	],
619	stateMutability: 'view',
620	type: 'function',
621	},
622	] as const;
623
624	/**
625	* Decoder for ComposableCow contract which focuses on decoding TWAP (`createWithContext`) orders
626	*
627	* The following is based on teh CoW SDK implementation:
628	* @see https://github.com/cowprotocol/cow-sdk/blob/5aa61a03d2ed9921c5f95522866b2af0ceb1c24d/src/composable/orderTypes/Twap.ts
629	*/
630	@Injectable()
631	export class ComposableCowDecoder extends AbiDecoder<typeof ComposableCowAbi> {	16✔
632	// Address of the TWAP handler contract
633	private static readonly TwapHandlerAddress =	16✔
634	'0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5';
635
636	// Define the ABI of the TwapStruct
637	private static readonly TwapStructAbiParameters = parseAbiParameters(	16✔
638	'address sellToken, address buyToken, address receiver, uint256 partSellAmount, uint256 minPartLimit, uint256 t0, uint256 n, uint256 t, uint256 span, bytes32 appData',
639	);
640
641	constructor(
642	@Inject(LoggingService) readonly loggingService: ILoggingService,	32✔
643	) {
644	super(loggingService, ComposableCowAbi);	32✔
645	}
646
647	/**
648	* Decode {@link TwapStruct} from `createWithContext` data
649	* @param data - transaction data to decode
650	* @returns the decoded {@link TwapStruct}
651	*/
652	decodeTwapStruct(data: `0x${string}`): TwapStruct {
NEW 653	const decoded = this.decodeFunctionData.createWithContext(data);	×
654
655	const [params] = decoded;	×
656
657	if (	×
658	!isAddressEqual(params.handler, ComposableCowDecoder.TwapHandlerAddress)
659	) {
660	throw new Error('Invalid TWAP handler');	×
661	}
662
663	return this.decodeConditionalOrderParams(params.staticInput);	×
664	}
665
666	/**
667	* Decode the `ConditionalOrderParams` from `createWithContext` data
668	* @param staticInput - `staticInput` of `createWithContext` call
669	* @returns decoded `ConditionalOrderParams` as {@link TwapStruct}
670	*/
671	private decodeConditionalOrderParams(
672	staticInput: `0x${string}`, // IConditionalOrder.ConditionalOrderParams calldata
673	): TwapStruct {
674	const [
675	sellToken,
676	buyToken,
677	receiver,
678	partSellAmount,
679	minPartLimit,
680	t0,
681	n,
682	t,
683	span,
684	appData,
685	] = decodeAbiParameters(	×
686	ComposableCowDecoder.TwapStructAbiParameters,
687	staticInput,
688	);
689
690	return {	×
691	sellToken,
692	buyToken,
693	receiver,
694	partSellAmount,
695	minPartLimit,
696	t0,
697	n,
698	t,
699	span,
700	appData,
701	};
702	}
703	}
704
705	/**
706	* Model of the contract's struct used for `staticIntput` of the `createWithContext` function
707	* @see https://docs.cow.fi/cow-protocol/reference/sdks/cow-sdk/interfaces/TwapStruct
708	*/
709	export type TwapStruct = {
710	/**
711	* which token to sell
712	*/
713	readonly sellToken: `0x${string}`;
714
715	/**
716	* which token to buy
717	*/
718	readonly buyToken: `0x${string}`;
719
720	/**
721	* who to send the tokens to
722	*/
723	readonly receiver: `0x${string}`;
724
725	/**
726	* Meta-data associated with the order. Normally would be the keccak256 hash of the document generated in http://github.com/cowprotocol/app-data
727	*
728	* This hash should have been uploaded to the API https://api.cow.fi/docs/#/default/put_api_v1_app_data__app_data_hash_ and potentially to other data availability protocols like IPFS.
729	*
730	*/
731	readonly appData: `0x${string}`;
732
733	/**
734	* amount of sellToken to sell in each part
735	*/
736	readonly partSellAmount: bigint;
737
738	/**
739	* minimum amount of buyToken that must be bought in each part
740	*/
741	readonly minPartLimit: bigint;
742
743	/**
744	* start time of the TWAP
745	*/
746	readonly t0: bigint;
747
748	/**
749	* number of parts
750	*/
751	readonly n: bigint;
752
753	/**
754	* duration of the TWAP interval
755	*/
756	readonly t: bigint;
757
758	/**
759	* whether the TWAP is valid for the entire interval or not
760	*/
761	readonly span: bigint;
762	};

safe-global / safe-client-gateway / 9860366179

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous