9860320964

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

Build # 9860320964

Build Type

Pull #1734

github

Committed by

iamacook

Commit Message

Add logging and favour throwing over null-returns

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 99 new or added lines in 11 files covered. (48.48%)

11 existing lines in 2 files 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

23.81

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

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

/**
 * 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(
    @Inject(LoggingService) readonly loggingService: ILoggingService,
  ) {
    super(loggingService, 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.setPreSignature(data);

    if (!decoded) {
      return null;
    }

    return decoded[0];
  }

  /**
   * 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.settle(data);

    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),
    };
  }

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

safe-global / safe-client-gateway / 9860320964

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