@0xtorch/evm 0.0.11 → 0.0.13

package/analyzer/json/schemas/index.ts

@@ -0,0 +1,363 @@
+import { z } from 'zod'
+import { isHex, toLowerHex } from '../../../types'
+import { actionGeneratorSchema } from './generator'
+import { methodIdSchema, premitiveAddressSchema } from './utils'
+
+export { actionGeneratorSchema } from './generator'
+
+const logArgumentPatternToLowerCaseValueSchema = z.object({
+  type: z.literal('to-lower-string-value'),
+  index: z.number().int(),
+  value: z.string().transform((x) => x.toLowerCase()),
+})
+
+const logsPatternPartialSchema = z
+  .object({
+    matchType: z.literal('partial'),
+    signature: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{64}$/)
+      .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+    indexedCount: z.number().int(),
+    logCount: z.number().int().optional(),
+    args: z.array(logArgumentPatternToLowerCaseValueSchema).optional(),
+  })
+  .transform((x) => ({
+    ...x,
+    logCount: x.logCount,
+    args: x.args,
+  }))
+
+const logsPatternExactSchema = z.object({
+  matchType: z.literal('exact'),
+  items: z.array(
+    z
+      .object({
+        signature: z
+          .string()
+          .regex(/^0x[\dA-Fa-f]{64}$/)
+          .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+        indexedCount: z.number().int(),
+        args: z.array(logArgumentPatternToLowerCaseValueSchema).optional(),
+      })
+      .transform((x) => ({
+        ...x,
+        args: x.args,
+      })),
+  ),
+})
+
+const logsPatternSchema = z.union([
+  logsPatternPartialSchema,
+  logsPatternExactSchema,
+])
+
+const internalsPatternPartialSchema = z
+  .object({
+    type: z.literal('partial'),
+    from: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))
+      .optional(),
+    to: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))
+      .optional(),
+    value: z.union([z.literal('plus'), z.literal('zero')]).optional(),
+    count: z.number().int().optional(),
+  })
+  .transform((x) => ({
+    ...x,
+    from: x.from,
+    to: x.to,
+    value: x.value,
+    count: x.count,
+  }))
+
+const internalsPatternSchema = internalsPatternPartialSchema
+
+const parameterDefaultSchema = z.object({
+  type: z.union([z.literal('from'), z.literal('to'), z.literal('value')]),
+})
+
+const parameterFunctionSchema = z.object({
+  type: z.literal('function'),
+  argIndex: z.number().int(),
+})
+
+const parameterLogSchema = z.object({
+  type: z.literal('log'),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  indexedCount: z.number().int(),
+  index: z.union([z.literal('some'), z.literal('every'), z.number().int()]),
+  argIndex: z.number().int(),
+})
+
+const parameterBaseLogSchema = z.object({
+  type: z.literal('log'),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  indexedCount: z.number().int(),
+  index: z.number().int(),
+  argIndex: z.number().int(),
+})
+
+const parameterInternalSchema = z.object({
+  type: z.literal('internal'),
+  index: z.union([z.literal('some'), z.literal('every'), z.number().int()]),
+  key: z.union([z.literal('from'), z.literal('to'), z.literal('value')]),
+})
+
+const parameterBaseInternalSchema = z.object({
+  type: z.literal('internal'),
+  index: z.number().int(),
+  key: z.union([z.literal('from'), z.literal('to'), z.literal('value')]),
+})
+
+export const parameterSchema = z.union([
+  parameterDefaultSchema,
+  parameterFunctionSchema,
+  parameterLogSchema,
+  parameterInternalSchema,
+])
+
+export const parameterBaseSchema = z.union([
+  parameterDefaultSchema,
+  parameterFunctionSchema,
+  parameterBaseLogSchema,
+  parameterBaseInternalSchema,
+])
+
+const parameterMatchPatternSchema = z.object({
+  base: parameterBaseSchema,
+  compare: parameterSchema,
+})
+
+const actionSchema = z.union([
+  z.literal('add-liquidity'),
+  z.literal('atomic-arbitrage'),
+  z.literal('bridge-from'),
+  z.literal('bridge-to'),
+  z.literal('buy-nft'),
+  z.literal('deposit'),
+  z.literal('deposit-with-bond'),
+  z.literal('free-mint-nft'),
+  z.literal('remove-liquidity'),
+  z.literal('spam'),
+  z.literal('trade'),
+  z.literal('transaction-fee'),
+  z.literal('transfer'),
+  z.literal('withdraw'),
+  z.literal('withdraw-with-bond'),
+])
+
+export const actionGeneratorAnyTokenTransferSchema = z
+  .object({
+    type: z.literal('any-token-transfer'),
+    token: z.union([
+      z.literal('erc20'),
+      z.literal('erc721'),
+      z.literal('erc1155'),
+    ]),
+    action: actionSchema,
+    comment: z.string().optional(),
+    target: z.union([z.literal('from'), z.literal('to'), z.literal('none')]),
+  })
+  .transform((x) => ({
+    ...x,
+    comment: x.comment,
+  }))
+
+const actionGeneratorAnyLogTokenNativeSchema = z.object({
+  token: z.literal('native'),
+})
+
+const actionGeneratorAnyLogTokenSchema = actionGeneratorAnyLogTokenNativeSchema
+
+const actionGeneratorAnyLogAddressDefaultSchema = z.object({
+  type: z.union([z.literal('from'), z.literal('to')]),
+})
+
+const actionGeneratorAnyLogAddressFixValueSchema = z.object({
+  type: z.literal('fix-value'),
+  value: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{40}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+})
+
+const actionGeneratorAnyLogAddressTargetSchema = z.object({
+  type: z.literal('target'),
+  argIndex: z.number().int(),
+})
+
+const actionGeneratorAnyLogAddressLogSchema = z.object({
+  type: z.literal('log'),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  indexedCount: z.number().int(),
+  index: z.number().int(),
+  argIndex: z.number().int(),
+})
+
+export const actionGeneratorAnyLogAddressSchema = z.union([
+  actionGeneratorAnyLogAddressDefaultSchema,
+  actionGeneratorAnyLogAddressFixValueSchema,
+  actionGeneratorAnyLogAddressTargetSchema,
+  actionGeneratorAnyLogAddressLogSchema,
+])
+
+const actionGeneratorAnyLogAmountDefaultSchema = z.object({
+  type: z.literal('value'),
+})
+
+const actionGeneratorAnyLogAmountFixValueSchema = z.object({
+  type: z.literal('fix-value'),
+  value: z.string().regex(/^\d+$/).transform(BigInt),
+})
+
+const actionGeneratorAnyLogAmountTargetSchema = z.object({
+  type: z.literal('target'),
+  argIndex: z.number().int(),
+})
+
+const actionGeneratorAnyLogAmountLogSchema = z.object({
+  type: z.literal('log'),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  indexedCount: z.number().int(),
+  index: z.number().int(),
+  argIndex: z.number().int(),
+})
+
+export const actionGeneratorAnyLogAmountSchema = z.union([
+  actionGeneratorAnyLogAmountDefaultSchema,
+  actionGeneratorAnyLogAmountFixValueSchema,
+  actionGeneratorAnyLogAmountTargetSchema,
+  actionGeneratorAnyLogAmountLogSchema,
+])
+
+export const actionGeneratorAnyLogSchema = z
+  .object({
+    type: z.literal('any-log'),
+    action: actionSchema,
+    comment: z.string().optional(),
+    target: z.union([z.literal('from'), z.literal('to'), z.literal('none')]),
+    signature: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{64}$/)
+      .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+    indexedCount: z.number().int(),
+    token: actionGeneratorAnyLogTokenSchema,
+    from: actionGeneratorAnyLogAddressSchema,
+    to: actionGeneratorAnyLogAddressSchema,
+    amount: actionGeneratorAnyLogAmountSchema,
+  })
+  .transform((x) => ({
+    ...x,
+    comment: x.comment,
+  }))
+
+export const actionTransferGeneratorFromTokenTransferSchema = z.object({
+  type: z.literal('token-transfer'),
+  token: z.union([
+    z.literal('erc20'),
+    z.literal('erc721'),
+    z.literal('erc1155'),
+    z.literal('value'),
+    z.literal('internal'),
+  ]),
+  transferIndex: z.union([z.literal('any'), z.number().int()]),
+  target: z.union([z.literal('from'), z.literal('to'), z.literal('none')]),
+})
+
+const conditionAddressSchema = z.union([
+  actionGeneratorAnyLogAddressDefaultSchema,
+  actionGeneratorAnyLogAddressFixValueSchema,
+  actionGeneratorAnyLogAddressLogSchema,
+])
+
+export const tokenTransferConditionAddressSchema = z.object({
+  type: z.union([z.literal('from'), z.literal('to')]),
+  condition: conditionAddressSchema,
+})
+
+const tokenTransferConditionSchema = tokenTransferConditionAddressSchema
+
+export const actionTransferGeneratorFromTokenTransferWithConditionSchema =
+  z.object({
+    type: z.literal('token-transfer-with-condition'),
+    token: z.union([
+      z.literal('erc20'),
+      z.literal('erc721'),
+      z.literal('erc1155'),
+      z.literal('internal'),
+    ]),
+    conditions: z.array(tokenTransferConditionSchema),
+    target: z.union([z.literal('from'), z.literal('to'), z.literal('none')]),
+  })
+
+const actionTransferGeneratorSchema = z.union([
+  actionTransferGeneratorFromTokenTransferSchema,
+  actionTransferGeneratorFromTokenTransferWithConditionSchema,
+])
+
+export const actionGeneratorSpecificTokenTransferSchema = z
+  .object({
+    type: z.literal('specific-token-transfer'),
+    action: actionSchema,
+    comment: z.string().optional(),
+    transfers: z.array(actionTransferGeneratorSchema),
+  })
+  .transform((x) => ({
+    ...x,
+    comment: x.comment,
+  }))
+
+// const actionGeneratorSchema = z.union([
+//   actionGeneratorAnyTokenTransferSchema,
+//   actionGeneratorAnyLogSchema,
+//   actionGeneratorSpecificTokenTransferSchema,
+// ])
+
+type EvmAnalyzerSchema = z.ZodObject<{
+  chainId: z.ZodOptional<z.ZodNumber>
+  from: z.ZodOptional<z.ZodArray<typeof premitiveAddressSchema>>
+  to: z.ZodOptional<z.ZodArray<typeof premitiveAddressSchema>>
+  value: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<'plus'>, z.ZodLiteral<'zero'>]>>
+  functionSignature: typeof methodIdSchema
+  functionInterface: z.ZodOptional<z.ZodString>
+  logsPatterns: z.ZodArray<typeof logsPatternSchema>
+  internalsPatterns: z.ZodOptional<z.ZodArray<typeof internalsPatternSchema>>
+  parameterMatchPatterns: z.ZodOptional<
+    z.ZodArray<typeof parameterMatchPatternSchema>
+  >
+  generators: z.ZodArray<typeof actionGeneratorSchema>
+}>
+
+export const evmAnalyzerSchema: EvmAnalyzerSchema = z.object({
+  chainId: z.number().int().optional(),
+  from: z.array(premitiveAddressSchema).optional(),
+  to: z.array(premitiveAddressSchema).optional(),
+  value: z.union([z.literal('plus'), z.literal('zero')]).optional(),
+  functionSignature: methodIdSchema,
+  functionInterface: z.string().optional(),
+  logsPatterns: z.array(logsPatternSchema),
+  internalsPatterns: z.array(internalsPatternSchema).optional(),
+  parameterMatchPatterns: z.array(parameterMatchPatternSchema).optional(),
+  generators: z.array(actionGeneratorSchema),
+})
+
+export const evmAnalyzersSchema: z.ZodArray<typeof evmAnalyzerSchema> =
+  z.array(evmAnalyzerSchema)

package/analyzer/json/schemas/utils.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import { isHex, toLowerHex } from '../../../types'
+
+export const premitiveAddressSchema = z
+  .string()
+  .regex(/^0x[\dA-Fa-f]{40}$/)
+  .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))
+
+export const methodIdSchema = z
+  .string()
+  .regex(/^0x[\dA-Fa-f]{8}$/)
+  .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))