9580396288

Committed 19 Jun 2024 10:26AM UTC coverage: 48.908% (+0.09%) from 48.823%

Build # 9580396288

Build Type

push

github

Committed by

iamacook

Commit Message

Refactor `AbiDecoder['decodeFunctionData']` to specify function name

Run Details

410 of 2464 branches covered (16.64%)

Branch coverage included in aggregate %.

3 of 64 new or added lines in 8 files covered. (4.69%)

4 existing lines in 2 files now uncovered.

4070 of 6696 relevant lines covered (60.78%)

13.34 hits per line

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

17.78

/src/domain/swaps/contracts/decoders/gp-v2-decoder.helper.ts

import { Injectable, Module } from '@nestjs/common';
import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';
import {
  BuyTokenBalance,
  OrderKind,
  SellTokenBalance,
} from '@/domain/swaps/entities/order.entity';

/**
 * Taken from CoW contracts:
 *
 * @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/deployments/arbitrumOne/GPv2Settlement.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 GPv2Abi = [
  {
    inputs: [
      {
        internalType: 'contract GPv2Authentication',
        name: 'authenticator_',
        type: 'address',
      },
      {
        internalType: 'contract IVault',
        name: 'vault_',
        type: 'address',
      },
    ],
    stateMutability: 'nonpayable',
    type: 'constructor',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'target',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'uint256',
        name: 'value',
        type: 'uint256',
      },
      {
        indexed: false,
        internalType: 'bytes4',
        name: 'selector',
        type: 'bytes4',
      },
    ],
    name: 'Interaction',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'bytes',
        name: 'orderUid',
        type: 'bytes',
      },
    ],
    name: 'OrderInvalidated',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'bytes',
        name: 'orderUid',
        type: 'bytes',
      },
      {
        indexed: false,
        internalType: 'bool',
        name: 'signed',
        type: 'bool',
      },
    ],
    name: 'PreSignature',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'solver',
        type: 'address',
      },
    ],
    name: 'Settlement',
    type: 'event',
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'owner',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'contract IERC20',
        name: 'sellToken',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'contract IERC20',
        name: 'buyToken',
        type: 'address',
      },
      {
        indexed: false,
        internalType: 'uint256',
        name: 'sellAmount',
        type: 'uint256',
      },
      {
        indexed: false,
        internalType: 'uint256',
        name: 'buyAmount',
        type: 'uint256',
      },
      {
        indexed: false,
        internalType: 'uint256',
        name: 'feeAmount',
        type: 'uint256',
      },
      {
        indexed: false,
        internalType: 'bytes',
        name: 'orderUid',
        type: 'bytes',
      },
    ],
    name: 'Trade',
    type: 'event',
  },
  {
    inputs: [],
    name: 'authenticator',
    outputs: [
      {
        internalType: 'contract GPv2Authentication',
        name: '',
        type: 'address',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [],
    name: 'domainSeparator',
    outputs: [
      {
        internalType: 'bytes32',
        name: '',
        type: 'bytes32',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes',
        name: '',
        type: 'bytes',
      },
    ],
    name: 'filledAmount',
    outputs: [
      {
        internalType: 'uint256',
        name: '',
        type: 'uint256',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes[]',
        name: 'orderUids',
        type: 'bytes[]',
      },
    ],
    name: 'freeFilledAmountStorage',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes[]',
        name: 'orderUids',
        type: 'bytes[]',
      },
    ],
    name: 'freePreSignatureStorage',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'uint256',
        name: 'offset',
        type: 'uint256',
      },
      {
        internalType: 'uint256',
        name: 'length',
        type: 'uint256',
      },
    ],
    name: 'getStorageAt',
    outputs: [
      {
        internalType: 'bytes',
        name: '',
        type: 'bytes',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes',
        name: 'orderUid',
        type: 'bytes',
      },
    ],
    name: 'invalidateOrder',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes',
        name: '',
        type: 'bytes',
      },
    ],
    name: 'preSignature',
    outputs: [
      {
        internalType: 'uint256',
        name: '',
        type: 'uint256',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'bytes',
        name: 'orderUid',
        type: 'bytes',
      },
      {
        internalType: 'bool',
        name: 'signed',
        type: 'bool',
      },
    ],
    name: 'setPreSignature',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'contract IERC20[]',
        name: 'tokens',
        type: 'address[]',
      },
      {
        internalType: 'uint256[]',
        name: 'clearingPrices',
        type: 'uint256[]',
      },
      {
        components: [
          {
            internalType: 'uint256',
            name: 'sellTokenIndex',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'buyTokenIndex',
            type: 'uint256',
          },
          {
            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: 'uint256',
            name: 'flags',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'executedAmount',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'signature',
            type: 'bytes',
          },
        ],
        internalType: 'struct GPv2Trade.Data[]',
        name: 'trades',
        type: 'tuple[]',
      },
      {
        components: [
          {
            internalType: 'address',
            name: 'target',
            type: 'address',
          },
          {
            internalType: 'uint256',
            name: 'value',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'callData',
            type: 'bytes',
          },
        ],
        internalType: 'struct GPv2Interaction.Data[][3]',
        name: 'interactions',
        type: 'tuple[][3]',
      },
    ],
    name: 'settle',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: 'targetContract',
        type: 'address',
      },
      {
        internalType: 'bytes',
        name: 'calldataPayload',
        type: 'bytes',
      },
    ],
    name: 'simulateDelegatecall',
    outputs: [
      {
        internalType: 'bytes',
        name: 'response',
        type: 'bytes',
      },
    ],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: 'targetContract',
        type: 'address',
      },
      {
        internalType: 'bytes',
        name: 'calldataPayload',
        type: 'bytes',
      },
    ],
    name: 'simulateDelegatecallInternal',
    outputs: [
      {
        internalType: 'bytes',
        name: 'response',
        type: 'bytes',
      },
    ],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [
      {
        components: [
          {
            internalType: 'bytes32',
            name: 'poolId',
            type: 'bytes32',
          },
          {
            internalType: 'uint256',
            name: 'assetInIndex',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'assetOutIndex',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'amount',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'userData',
            type: 'bytes',
          },
        ],
        internalType: 'struct IVault.BatchSwapStep[]',
        name: 'swaps',
        type: 'tuple[]',
      },
      {
        internalType: 'contract IERC20[]',
        name: 'tokens',
        type: 'address[]',
      },
      {
        components: [
          {
            internalType: 'uint256',
            name: 'sellTokenIndex',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'buyTokenIndex',
            type: 'uint256',
          },
          {
            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: 'uint256',
            name: 'flags',
            type: 'uint256',
          },
          {
            internalType: 'uint256',
            name: 'executedAmount',
            type: 'uint256',
          },
          {
            internalType: 'bytes',
            name: 'signature',
            type: 'bytes',
          },
        ],
        internalType: 'struct GPv2Trade.Data',
        name: 'trade',
        type: 'tuple',
      },
    ],
    name: 'swap',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [],
    name: 'vault',
    outputs: [
      {
        internalType: 'contract IVault',
        name: '',
        type: 'address',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [],
    name: 'vaultRelayer',
    outputs: [
      {
        internalType: 'contract GPv2VaultRelayer',
        name: '',
        type: 'address',
      },
    ],
    stateMutability: 'view',
    type: 'function',
  },
  {
    stateMutability: 'payable',
    type: 'receive',
  },
] as const;

export type GPv2OrderParameters = {
  sellToken: `0x${string}`;
  buyToken: `0x${string}`;
  receiver: `0x${string}`;
  sellAmount: bigint;
  buyAmount: bigint;
  validTo: number;
  appData: `0x${string}`;
  feeAmount: bigint;
  kind: OrderKind;
  partiallyFillable: boolean;
  sellTokenBalance: SellTokenBalance;
  buyTokenBalance: BuyTokenBalance;
};

/**
 * Decoder for GPv2Settlement contract.
 *
 * The following is based on the CoW SDK implementation:
 * @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/src/ts/settlement.ts
 */
@Injectable()
export class GPv2Decoder extends AbiDecoder<typeof GPv2Abi> {
  private static readonly FlagMasks = {
    kind: {
      offset: 0,
      options: [OrderKind.Sell, OrderKind.Buy],
    },
    partiallyFillable: {
      offset: 1,
      options: [false, true],
    },
    sellTokenBalance: {
      offset: 2,
      options: [
        SellTokenBalance.Erc20,
        undefined, // unused
        SellTokenBalance.External,
        SellTokenBalance.Internal,
      ],
    },
    buyTokenBalance: {
      offset: 4,
      options: [BuyTokenBalance.Erc20, BuyTokenBalance.Internal],
    },
  } as const;

  constructor() {
    super(GPv2Abi);
  }

  /**
   * Gets the Order UID associated with the provided transaction data.
   *
   * @param data - the transaction data for the setPreSignature call
   * @returns {`0x${string}`} the order UID or null if the data does not represent a setPreSignature transaction
   */
  public getOrderUidFromSetPreSignature(
    data: `0x${string}`,
  ): `0x${string}` | null {
    const decoded = this.decodeFunctionData({
      data,
      functionName: 'setPreSignature',
    });

    return decoded?.[0] ?? null;
  }

  /**
   * Decodes an order from a settlement trade.
   *
   * @param trade The trade to decode into an order.
   * @param tokens The list of token addresses as they appear in the settlement.
   * @returns The decoded {@link GPv2OrderParameters} or null if the trade is invalid.
   */
  public decodeOrderFromSettle(
    data: `0x${string}`,
  ): GPv2OrderParameters | null {
    const decoded = this.decodeFunctionData({
      data,
      functionName: 'settle',
    });

    if (!decoded) {
      return null;
    }

    const [tokens, , [trade]] = decoded;

    const sellTokenIndex = Number(trade.sellTokenIndex);
    const buyTokenIndex = Number(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: trade.validTo,
      appData: trade.appData,
      feeAmount: trade.feeAmount,
      kind: this.decodeFlag('kind', trade.flags),
      partiallyFillable: this.decodeFlag('partiallyFillable', trade.flags),
      sellTokenBalance: this.decodeFlag('sellTokenBalance', trade.flags),
      buyTokenBalance: this.decodeFlag('buyTokenBalance', trade.flags),
    };
  }

  private decodeFlag<K extends keyof typeof GPv2Decoder.FlagMasks>(
    key: K,
    flag: bigint,
  ): Exclude<(typeof GPv2Decoder.FlagMasks)[K]['options'][number], undefined> {
    const { offset, options } = GPv2Decoder.FlagMasks[key];
    const numberFlags = Number(flag);
    const index = (numberFlags >> offset) & this.mask(options);

    const decoded = options[index] as Exclude<
      (typeof GPv2Decoder.FlagMasks)[K]['options'][number],
      undefined
    >;

    if (decoded === undefined || index < 0) {
      throw new Error(
        `Invalid input flag for ${key}: 0b${numberFlags.toString(2)}`,
      );
    }

    return decoded;
  }

  // Counts smallest mask needed to store input options in masked bitfield
  private mask(options: readonly unknown[]): number {
    const num = options.length;
    const bitCount = 32 - Math.clz32(num - 1);
    return (1 << bitCount) - 1;
  }
}

@Module({
  providers: [GPv2Decoder],
  exports: [GPv2Decoder],
})
export class GPv2DecoderModule {}

1	import { Injectable, Module } from '@nestjs/common';	16✔
2	import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';	16✔
3	import {	16✔
4	BuyTokenBalance,
5	OrderKind,
6	SellTokenBalance,
7	} from '@/domain/swaps/entities/order.entity';
8
9	/**
10	* Taken from CoW contracts:
11	*
12	* @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/deployments/arbitrumOne/GPv2Settlement.json
13	*
14	* TODO: We should locate this in @/abis/... but we will need to refactor the /scripts/generate-abis.js
15	* to handle ABIs that are present (or alternatively install the @cowprotocol/contracts package and generate
16	* the ABIs from there)
17	*/
18	export const GPv2Abi = [	16✔
19	{
20	inputs: [
21	{
22	internalType: 'contract GPv2Authentication',
23	name: 'authenticator_',
24	type: 'address',
25	},
26	{
27	internalType: 'contract IVault',
28	name: 'vault_',
29	type: 'address',
30	},
31	],
32	stateMutability: 'nonpayable',
33	type: 'constructor',
34	},
35	{
36	anonymous: false,
37	inputs: [
38	{
39	indexed: true,
40	internalType: 'address',
41	name: 'target',
42	type: 'address',
43	},
44	{
45	indexed: false,
46	internalType: 'uint256',
47	name: 'value',
48	type: 'uint256',
49	},
50	{
51	indexed: false,
52	internalType: 'bytes4',
53	name: 'selector',
54	type: 'bytes4',
55	},
56	],
57	name: 'Interaction',
58	type: 'event',
59	},
60	{
61	anonymous: false,
62	inputs: [
63	{
64	indexed: true,
65	internalType: 'address',
66	name: 'owner',
67	type: 'address',
68	},
69	{
70	indexed: false,
71	internalType: 'bytes',
72	name: 'orderUid',
73	type: 'bytes',
74	},
75	],
76	name: 'OrderInvalidated',
77	type: 'event',
78	},
79	{
80	anonymous: false,
81	inputs: [
82	{
83	indexed: true,
84	internalType: 'address',
85	name: 'owner',
86	type: 'address',
87	},
88	{
89	indexed: false,
90	internalType: 'bytes',
91	name: 'orderUid',
92	type: 'bytes',
93	},
94	{
95	indexed: false,
96	internalType: 'bool',
97	name: 'signed',
98	type: 'bool',
99	},
100	],
101	name: 'PreSignature',
102	type: 'event',
103	},
104	{
105	anonymous: false,
106	inputs: [
107	{
108	indexed: true,
109	internalType: 'address',
110	name: 'solver',
111	type: 'address',
112	},
113	],
114	name: 'Settlement',
115	type: 'event',
116	},
117	{
118	anonymous: false,
119	inputs: [
120	{
121	indexed: true,
122	internalType: 'address',
123	name: 'owner',
124	type: 'address',
125	},
126	{
127	indexed: false,
128	internalType: 'contract IERC20',
129	name: 'sellToken',
130	type: 'address',
131	},
132	{
133	indexed: false,
134	internalType: 'contract IERC20',
135	name: 'buyToken',
136	type: 'address',
137	},
138	{
139	indexed: false,
140	internalType: 'uint256',
141	name: 'sellAmount',
142	type: 'uint256',
143	},
144	{
145	indexed: false,
146	internalType: 'uint256',
147	name: 'buyAmount',
148	type: 'uint256',
149	},
150	{
151	indexed: false,
152	internalType: 'uint256',
153	name: 'feeAmount',
154	type: 'uint256',
155	},
156	{
157	indexed: false,
158	internalType: 'bytes',
159	name: 'orderUid',
160	type: 'bytes',
161	},
162	],
163	name: 'Trade',
164	type: 'event',
165	},
166	{
167	inputs: [],
168	name: 'authenticator',
169	outputs: [
170	{
171	internalType: 'contract GPv2Authentication',
172	name: '',
173	type: 'address',
174	},
175	],
176	stateMutability: 'view',
177	type: 'function',
178	},
179	{
180	inputs: [],
181	name: 'domainSeparator',
182	outputs: [
183	{
184	internalType: 'bytes32',
185	name: '',
186	type: 'bytes32',
187	},
188	],
189	stateMutability: 'view',
190	type: 'function',
191	},
192	{
193	inputs: [
194	{
195	internalType: 'bytes',
196	name: '',
197	type: 'bytes',
198	},
199	],
200	name: 'filledAmount',
201	outputs: [
202	{
203	internalType: 'uint256',
204	name: '',
205	type: 'uint256',
206	},
207	],
208	stateMutability: 'view',
209	type: 'function',
210	},
211	{
212	inputs: [
213	{
214	internalType: 'bytes[]',
215	name: 'orderUids',
216	type: 'bytes[]',
217	},
218	],
219	name: 'freeFilledAmountStorage',
220	outputs: [],
221	stateMutability: 'nonpayable',
222	type: 'function',
223	},
224	{
225	inputs: [
226	{
227	internalType: 'bytes[]',
228	name: 'orderUids',
229	type: 'bytes[]',
230	},
231	],
232	name: 'freePreSignatureStorage',
233	outputs: [],
234	stateMutability: 'nonpayable',
235	type: 'function',
236	},
237	{
238	inputs: [
239	{
240	internalType: 'uint256',
241	name: 'offset',
242	type: 'uint256',
243	},
244	{
245	internalType: 'uint256',
246	name: 'length',
247	type: 'uint256',
248	},
249	],
250	name: 'getStorageAt',
251	outputs: [
252	{
253	internalType: 'bytes',
254	name: '',
255	type: 'bytes',
256	},
257	],
258	stateMutability: 'view',
259	type: 'function',
260	},
261	{
262	inputs: [
263	{
264	internalType: 'bytes',
265	name: 'orderUid',
266	type: 'bytes',
267	},
268	],
269	name: 'invalidateOrder',
270	outputs: [],
271	stateMutability: 'nonpayable',
272	type: 'function',
273	},
274	{
275	inputs: [
276	{
277	internalType: 'bytes',
278	name: '',
279	type: 'bytes',
280	},
281	],
282	name: 'preSignature',
283	outputs: [
284	{
285	internalType: 'uint256',
286	name: '',
287	type: 'uint256',
288	},
289	],
290	stateMutability: 'view',
291	type: 'function',
292	},
293	{
294	inputs: [
295	{
296	internalType: 'bytes',
297	name: 'orderUid',
298	type: 'bytes',
299	},
300	{
301	internalType: 'bool',
302	name: 'signed',
303	type: 'bool',
304	},
305	],
306	name: 'setPreSignature',
307	outputs: [],
308	stateMutability: 'nonpayable',
309	type: 'function',
310	},
311	{
312	inputs: [
313	{
314	internalType: 'contract IERC20[]',
315	name: 'tokens',
316	type: 'address[]',
317	},
318	{
319	internalType: 'uint256[]',
320	name: 'clearingPrices',
321	type: 'uint256[]',
322	},
323	{
324	components: [
325	{
326	internalType: 'uint256',
327	name: 'sellTokenIndex',
328	type: 'uint256',
329	},
330	{
331	internalType: 'uint256',
332	name: 'buyTokenIndex',
333	type: 'uint256',
334	},
335	{
336	internalType: 'address',
337	name: 'receiver',
338	type: 'address',
339	},
340	{
341	internalType: 'uint256',
342	name: 'sellAmount',
343	type: 'uint256',
344	},
345	{
346	internalType: 'uint256',
347	name: 'buyAmount',
348	type: 'uint256',
349	},
350	{
351	internalType: 'uint32',
352	name: 'validTo',
353	type: 'uint32',
354	},
355	{
356	internalType: 'bytes32',
357	name: 'appData',
358	type: 'bytes32',
359	},
360	{
361	internalType: 'uint256',
362	name: 'feeAmount',
363	type: 'uint256',
364	},
365	{
366	internalType: 'uint256',
367	name: 'flags',
368	type: 'uint256',
369	},
370	{
371	internalType: 'uint256',
372	name: 'executedAmount',
373	type: 'uint256',
374	},
375	{
376	internalType: 'bytes',
377	name: 'signature',
378	type: 'bytes',
379	},
380	],
381	internalType: 'struct GPv2Trade.Data[]',
382	name: 'trades',
383	type: 'tuple[]',
384	},
385	{
386	components: [
387	{
388	internalType: 'address',
389	name: 'target',
390	type: 'address',
391	},
392	{
393	internalType: 'uint256',
394	name: 'value',
395	type: 'uint256',
396	},
397	{
398	internalType: 'bytes',
399	name: 'callData',
400	type: 'bytes',
401	},
402	],
403	internalType: 'struct GPv2Interaction.Data[][3]',
404	name: 'interactions',
405	type: 'tuple[][3]',
406	},
407	],
408	name: 'settle',
409	outputs: [],
410	stateMutability: 'nonpayable',
411	type: 'function',
412	},
413	{
414	inputs: [
415	{
416	internalType: 'address',
417	name: 'targetContract',
418	type: 'address',
419	},
420	{
421	internalType: 'bytes',
422	name: 'calldataPayload',
423	type: 'bytes',
424	},
425	],
426	name: 'simulateDelegatecall',
427	outputs: [
428	{
429	internalType: 'bytes',
430	name: 'response',
431	type: 'bytes',
432	},
433	],
434	stateMutability: 'nonpayable',
435	type: 'function',
436	},
437	{
438	inputs: [
439	{
440	internalType: 'address',
441	name: 'targetContract',
442	type: 'address',
443	},
444	{
445	internalType: 'bytes',
446	name: 'calldataPayload',
447	type: 'bytes',
448	},
449	],
450	name: 'simulateDelegatecallInternal',
451	outputs: [
452	{
453	internalType: 'bytes',
454	name: 'response',
455	type: 'bytes',
456	},
457	],
458	stateMutability: 'nonpayable',
459	type: 'function',
460	},
461	{
462	inputs: [
463	{
464	components: [
465	{
466	internalType: 'bytes32',
467	name: 'poolId',
468	type: 'bytes32',
469	},
470	{
471	internalType: 'uint256',
472	name: 'assetInIndex',
473	type: 'uint256',
474	},
475	{
476	internalType: 'uint256',
477	name: 'assetOutIndex',
478	type: 'uint256',
479	},
480	{
481	internalType: 'uint256',
482	name: 'amount',
483	type: 'uint256',
484	},
485	{
486	internalType: 'bytes',
487	name: 'userData',
488	type: 'bytes',
489	},
490	],
491	internalType: 'struct IVault.BatchSwapStep[]',
492	name: 'swaps',
493	type: 'tuple[]',
494	},
495	{
496	internalType: 'contract IERC20[]',
497	name: 'tokens',
498	type: 'address[]',
499	},
500	{
501	components: [
502	{
503	internalType: 'uint256',
504	name: 'sellTokenIndex',
505	type: 'uint256',
506	},
507	{
508	internalType: 'uint256',
509	name: 'buyTokenIndex',
510	type: 'uint256',
511	},
512	{
513	internalType: 'address',
514	name: 'receiver',
515	type: 'address',
516	},
517	{
518	internalType: 'uint256',
519	name: 'sellAmount',
520	type: 'uint256',
521	},
522	{
523	internalType: 'uint256',
524	name: 'buyAmount',
525	type: 'uint256',
526	},
527	{
528	internalType: 'uint32',
529	name: 'validTo',
530	type: 'uint32',
531	},
532	{
533	internalType: 'bytes32',
534	name: 'appData',
535	type: 'bytes32',
536	},
537	{
538	internalType: 'uint256',
539	name: 'feeAmount',
540	type: 'uint256',
541	},
542	{
543	internalType: 'uint256',
544	name: 'flags',
545	type: 'uint256',
546	},
547	{
548	internalType: 'uint256',
549	name: 'executedAmount',
550	type: 'uint256',
551	},
552	{
553	internalType: 'bytes',
554	name: 'signature',
555	type: 'bytes',
556	},
557	],
558	internalType: 'struct GPv2Trade.Data',
559	name: 'trade',
560	type: 'tuple',
561	},
562	],
563	name: 'swap',
564	outputs: [],
565	stateMutability: 'nonpayable',
566	type: 'function',
567	},
568	{
569	inputs: [],
570	name: 'vault',
571	outputs: [
572	{
573	internalType: 'contract IVault',
574	name: '',
575	type: 'address',
576	},
577	],
578	stateMutability: 'view',
579	type: 'function',
580	},
581	{
582	inputs: [],
583	name: 'vaultRelayer',
584	outputs: [
585	{
586	internalType: 'contract GPv2VaultRelayer',
587	name: '',
588	type: 'address',
589	},
590	],
591	stateMutability: 'view',
592	type: 'function',
593	},
594	{
595	stateMutability: 'payable',
596	type: 'receive',
597	},
598	] as const;
599
600	export type GPv2OrderParameters = {
601	sellToken: `0x${string}`;
602	buyToken: `0x${string}`;
603	receiver: `0x${string}`;
604	sellAmount: bigint;
605	buyAmount: bigint;
606	validTo: number;
607	appData: `0x${string}`;
608	feeAmount: bigint;
609	kind: OrderKind;
610	partiallyFillable: boolean;
611	sellTokenBalance: SellTokenBalance;
612	buyTokenBalance: BuyTokenBalance;
613	};
614
615	/**
616	* Decoder for GPv2Settlement contract.
617	*
618	* The following is based on the CoW SDK implementation:
619	* @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/src/ts/settlement.ts
620	*/
621	@Injectable()
622	export class GPv2Decoder extends AbiDecoder<typeof GPv2Abi> {	16✔
623	private static readonly FlagMasks = {	16✔
624	kind: {
625	offset: 0,
626	options: [OrderKind.Sell, OrderKind.Buy],
627	},
628	partiallyFillable: {
629	offset: 1,
630	options: [false, true],
631	},
632	sellTokenBalance: {
633	offset: 2,
634	options: [
635	SellTokenBalance.Erc20,
636	undefined, // unused
637	SellTokenBalance.External,
638	SellTokenBalance.Internal,
639	],
640	},
641	buyTokenBalance: {
642	offset: 4,
643	options: [BuyTokenBalance.Erc20, BuyTokenBalance.Internal],
644	},
645	} as const;
646
647	constructor() {
648	super(GPv2Abi);	48✔
649	}
650
651	/**
652	* Gets the Order UID associated with the provided transaction data.
653	*
654	* @param data - the transaction data for the setPreSignature call
655	* @returns {`0x${string}`} the order UID or null if the data does not represent a setPreSignature transaction
656	*/
657	public getOrderUidFromSetPreSignature(
658	data: `0x${string}`,
659	): `0x${string}` \| null {
NEW 660	const decoded = this.decodeFunctionData({	×
661	data,
662	functionName: 'setPreSignature',
663	});
664
NEW 665	return decoded?.[0] ?? null;	×
666	}
667
668	/**
669	* Decodes an order from a settlement trade.
670	*
671	* @param trade The trade to decode into an order.
672	* @param tokens The list of token addresses as they appear in the settlement.
673	* @returns The decoded {@link GPv2OrderParameters} or null if the trade is invalid.
674	*/
675	public decodeOrderFromSettle(
676	data: `0x${string}`,
677	): GPv2OrderParameters \| null {
NEW 678	const decoded = this.decodeFunctionData({	×
679	data,
680	functionName: 'settle',
681	});
682
683	if (!decoded) {	×
684	return null;	×
685	}
686
687	const [tokens, , [trade]] = decoded;	×
688
689	const sellTokenIndex = Number(trade.sellTokenIndex);	×
690	const buyTokenIndex = Number(trade.buyTokenIndex);	×
691
692	if (Math.max(sellTokenIndex, buyTokenIndex) >= tokens.length) {	×
693	throw new Error('Invalid trade');	×
694	}
695
696	return {	×
697	sellToken: tokens[sellTokenIndex],
698	buyToken: tokens[buyTokenIndex],
699	receiver: trade.receiver,
700	sellAmount: trade.sellAmount,
701	buyAmount: trade.buyAmount,
702	validTo: trade.validTo,
703	appData: trade.appData,
704	feeAmount: trade.feeAmount,
705	kind: this.decodeFlag('kind', trade.flags),
706	partiallyFillable: this.decodeFlag('partiallyFillable', trade.flags),
707	sellTokenBalance: this.decodeFlag('sellTokenBalance', trade.flags),
708	buyTokenBalance: this.decodeFlag('buyTokenBalance', trade.flags),
709	};
710	}
711
712	private decodeFlag<K extends keyof typeof GPv2Decoder.FlagMasks>(
713	key: K,
714	flag: bigint,
715	): Exclude<(typeof GPv2Decoder.FlagMasks)[K]['options'][number], undefined> {
716	const { offset, options } = GPv2Decoder.FlagMasks[key];	×
717	const numberFlags = Number(flag);	×
718	const index = (numberFlags >> offset) & this.mask(options);	×
719
720	const decoded = options[index] as Exclude<	×
721	(typeof GPv2Decoder.FlagMasks)[K]['options'][number],
722	undefined
723	>;
724
725	if (decoded === undefined \|\| index < 0) {	×
726	throw new Error(	×
727	`Invalid input flag for ${key}: 0b${numberFlags.toString(2)}`,
728	);
729	}
730
731	return decoded;	×
732	}
733
734	// Counts smallest mask needed to store input options in masked bitfield
735	private mask(options: readonly unknown[]): number {
736	const num = options.length;	×
737	const bitCount = 32 - Math.clz32(num - 1);	×
738	return (1 << bitCount) - 1;	×
739	}
740	}
741
742	@Module({
743	providers: [GPv2Decoder],
744	exports: [GPv2Decoder],
745	})
746	export class GPv2DecoderModule {}	16✔

safe-global / safe-client-gateway / 9580396288

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