@0xtorch/evm 0.0.73 → 0.0.75

package/logic/analyzeTransaction/createActions/json/schema.ts

@@ -0,0 +1,554 @@
+import {
+  actionCrossTypeUnionSchema,
+  actionTypeUnionSchema,
+} from '@0xtorch/core'
+import { z } from 'zod'
+
+const addressSchema = z.string().regex(/^0x[\da-f]{40}$/)
+
+const logSignatureSchema = z.string().regex(/^0x[\da-f]{64}$/)
+
+const bigIntTextSchema = z
+  .string()
+  .regex(/^\d+$/)
+  .transform((v) => BigInt(v))
+
+export const betweenBigIntSchema = z.object({
+  type: z.literal('between'),
+  min: bigIntTextSchema.optional(),
+  max: bigIntTextSchema.optional(),
+})
+
+const indexSchema = z.number().int().nonnegative()
+
+export const addressInSchema = z.object({
+  type: z.literal('address-in'),
+  not: z.boolean().optional(),
+  values: z
+    .array(
+      z.union([
+        z.literal('related'),
+        z.literal('from'),
+        z.literal('to'),
+        addressSchema,
+      ]),
+    )
+    .min(1),
+})
+
+const fromValueSchema = z.object({
+  type: z.literal('from'),
+})
+
+const toValueSchema = z.object({
+  type: z.literal('to'),
+})
+
+const valueValueSchema = z.object({
+  type: z.literal('value'),
+})
+
+const functionValueSchema = z.object({
+  type: z.literal('function'),
+  index: indexSchema,
+})
+
+const logValueSchema = z.object({
+  type: z.literal('log'),
+  address: addressInSchema.optional(),
+  signature: logSignatureSchema.optional(),
+  indexedCount: indexSchema.optional(),
+  args: z
+    .array(
+      z.object({
+        index: indexSchema,
+        value: z.union([addressInSchema, z.string()]),
+      }),
+    )
+    .min(1)
+    .optional(),
+  index: indexSchema,
+  value: z.union([z.literal('address'), indexSchema]),
+})
+
+const erc20ValueSchema = z.object({
+  type: z.literal('erc20'),
+  address: addressInSchema.optional(),
+  from: addressInSchema.optional(),
+  to: addressInSchema.optional(),
+  amount: betweenBigIntSchema.optional(),
+  index: indexSchema,
+  value: z.union([
+    z.literal('address'),
+    z.literal('from'),
+    z.literal('to'),
+    z.literal('amount'),
+    z.literal('amount-decimal'),
+    z.literal('currency-id'),
+    z.literal('currency-name'),
+    z.literal('currency-symbol'),
+  ]),
+})
+
+const erc721ValueSchema = z.object({
+  type: z.literal('erc721'),
+  address: addressInSchema.optional(),
+  from: addressInSchema.optional(),
+  to: addressInSchema.optional(),
+  id: bigIntTextSchema.optional(),
+  index: indexSchema,
+  value: z.union([
+    z.literal('address'),
+    z.literal('from'),
+    z.literal('to'),
+    z.literal('id'),
+    z.literal('nft-id'),
+    z.literal('nft-name'),
+  ]),
+})
+
+const erc1155ValueSchema = z.object({
+  type: z.literal('erc1155'),
+  address: addressInSchema.optional(),
+  from: addressInSchema.optional(),
+  to: addressInSchema.optional(),
+  id: bigIntTextSchema.optional(),
+  amount: betweenBigIntSchema.optional(),
+  index: indexSchema,
+  value: z.union([
+    z.literal('address'),
+    z.literal('from'),
+    z.literal('to'),
+    z.literal('id'),
+    z.literal('amount'),
+    z.literal('nft-id'),
+    z.literal('nft-name'),
+  ]),
+})
+
+export const simpleValueSchema = z.union([
+  z.string(),
+  fromValueSchema,
+  toValueSchema,
+  valueValueSchema,
+  functionValueSchema,
+  logValueSchema,
+  erc20ValueSchema,
+  erc721ValueSchema,
+  erc1155ValueSchema,
+])
+
+export const mathValueSchema = z.object({
+  type: z.literal('math'),
+  values: z
+    .array(
+      z.union([
+        z.literal('+'),
+        z.literal('-'),
+        z.literal('*'),
+        z.literal('/'),
+        simpleValueSchema,
+      ]),
+    )
+    .min(3),
+})
+
+export const sliceValueSchema = z.object({
+  type: z.literal('slice'),
+  value: simpleValueSchema,
+  start: z.number().int().optional(),
+  end: z.number().int().optional(),
+})
+
+export const joinValueSchema = z.object({
+  type: z.literal('join'),
+  values: z
+    .array(z.union([mathValueSchema, sliceValueSchema, simpleValueSchema]))
+    .min(1),
+})
+
+export const allValueSchema = z.union([
+  simpleValueSchema,
+  mathValueSchema,
+  sliceValueSchema,
+  joinValueSchema,
+])
+
+export const arrayInSchema = z.object({
+  type: z.literal('array-in'),
+  not: z.boolean().optional(),
+  values: z.array(z.union([z.literal('related'), allValueSchema])).min(1),
+})
+
+const logPatternSchema = z.object({
+  address: arrayInSchema.optional(),
+  signature: logSignatureSchema,
+  indexedCount: indexSchema,
+  args: z
+    .array(
+      z.object({
+        index: indexSchema,
+        value: z.union([arrayInSchema, allValueSchema, betweenBigIntSchema]),
+      }),
+    )
+    .min(1)
+    .optional(),
+})
+
+export const exactLogsConditionSchema = z.object({
+  type: z.literal('exact'),
+  patterns: z.array(logPatternSchema),
+})
+
+export const someLogsConditionSchema = z.object({
+  type: z.literal('some'),
+  patterns: z.array(
+    logPatternSchema.extend({
+      count: betweenBigIntSchema,
+    }),
+  ),
+})
+
+export const erc20TransferPatternSchema = z.object({
+  address: arrayInSchema.optional(),
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  amount: z.union([allValueSchema, betweenBigIntSchema]).optional(),
+})
+
+export const exactErc20TransfersConditionSchema = z.object({
+  type: z.literal('exact'),
+  patterns: z.array(erc20TransferPatternSchema),
+})
+
+export const someErc20TransfersConditionSchema = z.object({
+  type: z.literal('some'),
+  patterns: z.array(
+    erc20TransferPatternSchema.extend({
+      count: betweenBigIntSchema,
+    }),
+  ),
+})
+
+export const erc721TransferPatternSchema = z.object({
+  address: arrayInSchema.optional(),
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  id: allValueSchema.optional(),
+})
+
+export const exactErc721TransfersConditionSchema = z.object({
+  type: z.literal('exact'),
+  patterns: z.array(erc721TransferPatternSchema),
+})
+
+export const someErc721TransfersConditionSchema = z.object({
+  type: z.literal('some'),
+  patterns: z.array(
+    erc721TransferPatternSchema.extend({
+      count: betweenBigIntSchema,
+    }),
+  ),
+})
+
+export const erc1155TransferPatternSchema = z.object({
+  address: arrayInSchema.optional(),
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  id: allValueSchema.optional(),
+  amount: z.union([allValueSchema, betweenBigIntSchema]).optional(),
+})
+
+export const exactErc1155TransfersConditionSchema = z.object({
+  type: z.literal('exact'),
+  patterns: z.array(erc1155TransferPatternSchema),
+})
+
+export const someErc1155TransfersConditionSchema = z.object({
+  type: z.literal('some'),
+  patterns: z.array(
+    erc1155TransferPatternSchema.extend({
+      count: betweenBigIntSchema,
+    }),
+  ),
+})
+
+const functionArgConditionSchema = z.object({
+  index: indexSchema,
+  value: z.union([arrayInSchema, allValueSchema, betweenBigIntSchema]),
+})
+
+const functionConditionSchema = z.object({
+  id: z.string().regex(/^0x[\da-f]{8}$/),
+  interface: z.string().optional(),
+  args: z.array(functionArgConditionSchema).min(1).optional(),
+})
+
+export const conditionSchema: z.ZodObject<{
+  related: z.ZodOptional<typeof arrayInSchema>
+  chainId: z.ZodOptional<z.ZodArray<z.ZodNumber>>
+  from: z.ZodOptional<typeof arrayInSchema>
+  to: z.ZodOptional<typeof arrayInSchema>
+  value: z.ZodOptional<typeof betweenBigIntSchema>
+  function: typeof functionConditionSchema
+  logs: z.ZodOptional<
+    z.ZodUnion<
+      [typeof exactLogsConditionSchema, typeof someLogsConditionSchema]
+    >
+  >
+  erc20Transfers: z.ZodOptional<
+    z.ZodUnion<
+      [
+        typeof exactErc20TransfersConditionSchema,
+        typeof someErc20TransfersConditionSchema,
+      ]
+    >
+  >
+  erc721Transfers: z.ZodOptional<
+    z.ZodUnion<
+      [
+        typeof exactErc721TransfersConditionSchema,
+        typeof someErc721TransfersConditionSchema,
+      ]
+    >
+  >
+  erc1155Transfers: z.ZodOptional<
+    z.ZodUnion<
+      [
+        typeof exactErc1155TransfersConditionSchema,
+        typeof someErc1155TransfersConditionSchema,
+      ]
+    >
+  >
+}> = z.object({
+  related: arrayInSchema.optional(),
+  chainId: z.array(z.number().int().positive()).min(1).optional(),
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  value: betweenBigIntSchema.optional(),
+  function: functionConditionSchema,
+  logs: z.union([exactLogsConditionSchema, someLogsConditionSchema]).optional(),
+  erc20Transfers: z
+    .union([
+      exactErc20TransfersConditionSchema,
+      someErc20TransfersConditionSchema,
+    ])
+    .optional(),
+  erc721Transfers: z
+    .union([
+      exactErc721TransfersConditionSchema,
+      someErc721TransfersConditionSchema,
+    ])
+    .optional(),
+  erc1155Transfers: z
+    .union([
+      exactErc1155TransfersConditionSchema,
+      someErc1155TransfersConditionSchema,
+    ])
+    .optional(),
+})
+
+const transferDirectionSchema = z.union([
+  z.literal('in'),
+  z.literal('out'),
+  z.literal('none'),
+])
+
+export const erc20TransferGeneratorSchema = erc20TransferPatternSchema.extend({
+  type: z.literal('erc20'),
+  direction: transferDirectionSchema,
+  index: indexSchema.optional(),
+})
+
+export const erc721TransferGeneratorSchema = erc721TransferPatternSchema.extend(
+  {
+    type: z.literal('erc721'),
+    direction: transferDirectionSchema,
+    index: indexSchema.optional(),
+  },
+)
+
+export const erc1155TransferGeneratorSchema =
+  erc1155TransferPatternSchema.extend({
+    type: z.literal('erc1155'),
+    direction: transferDirectionSchema,
+    index: indexSchema.optional(),
+  })
+
+export const internalTransferGeneratorSchema = z.object({
+  type: z.literal('internal'),
+  direction: transferDirectionSchema,
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  value: z.union([allValueSchema, betweenBigIntSchema]).optional(),
+  index: indexSchema.optional(),
+})
+
+const customTransferErc20AssetSchema = erc20TransferPatternSchema.extend({
+  type: z.literal('erc20'),
+  index: indexSchema,
+})
+
+const customTransferErc721AssetSchema = erc721TransferPatternSchema.extend({
+  type: z.literal('erc721'),
+  index: indexSchema,
+})
+
+const customTransferErc1155AssetSchema = erc1155TransferPatternSchema.extend({
+  type: z.literal('erc1155'),
+  index: indexSchema,
+})
+
+const customTransferAssetSchema: z.ZodUnion<
+  [
+    z.ZodObject<{
+      type: z.ZodLiteral<'native'>
+    }>,
+    typeof customTransferErc20AssetSchema,
+    typeof customTransferErc721AssetSchema,
+    typeof customTransferErc1155AssetSchema,
+  ]
+> = z.union([
+  z.object({
+    type: z.literal('native'),
+  }),
+  customTransferErc20AssetSchema,
+  customTransferErc721AssetSchema,
+  customTransferErc1155AssetSchema,
+])
+
+export const customTransferGeneratorSchema: z.ZodObject<{
+  type: z.ZodLiteral<'custom'>
+  direction: typeof transferDirectionSchema
+  from: z.ZodOptional<typeof allValueSchema>
+  to: z.ZodOptional<typeof allValueSchema>
+  asset: typeof customTransferAssetSchema
+  amount: typeof allValueSchema
+}> = z.object({
+  type: z.literal('custom'),
+  direction: transferDirectionSchema,
+  from: allValueSchema.optional(),
+  to: allValueSchema.optional(),
+  asset: customTransferAssetSchema,
+  amount: allValueSchema,
+})
+
+const valueTransferGeneratorSchema = z.object({
+  type: z.literal('value'),
+  direction: transferDirectionSchema,
+  from: arrayInSchema.optional(),
+  to: arrayInSchema.optional(),
+  value: z.union([allValueSchema, betweenBigIntSchema]).optional(),
+})
+
+const targetTransferGeneratorSchema = z.object({
+  type: z.literal('target'),
+  direction: transferDirectionSchema,
+})
+
+export const transferGeneratorSchema: z.ZodUnion<
+  [
+    typeof valueTransferGeneratorSchema,
+    typeof internalTransferGeneratorSchema,
+    typeof erc20TransferGeneratorSchema,
+    typeof erc721TransferGeneratorSchema,
+    typeof erc1155TransferGeneratorSchema,
+    typeof targetTransferGeneratorSchema,
+    typeof customTransferGeneratorSchema,
+  ]
+> = z.union([
+  // value を指定して自動生成
+  valueTransferGeneratorSchema,
+  // internal transaction を指定して自動生成
+  internalTransferGeneratorSchema,
+  // erc20 transfer を指定して自動生成
+  erc20TransferGeneratorSchema,
+  // erc721 transfer を指定して自動生成
+  erc721TransferGeneratorSchema,
+  // erc1155 transfer を指定して自動生成
+  erc1155TransferGeneratorSchema,
+  // target で抽出した transfer 毎に自動生成
+  targetTransferGeneratorSchema,
+  // 各 parameter を個別指定して生成
+  customTransferGeneratorSchema,
+])
+
+const targetErc20GeneratorSchema = erc20TransferPatternSchema.extend({
+  type: z.literal('erc20'),
+})
+
+const targetErc721GeneratorSchema = erc721TransferPatternSchema.extend({
+  type: z.literal('erc721'),
+})
+
+const targetErc1155GeneratorSchema = erc1155TransferPatternSchema.extend({
+  type: z.literal('erc1155'),
+})
+
+const targetGeneratorSchema: z.ZodUnion<
+  [
+    typeof targetErc20GeneratorSchema,
+    typeof targetErc721GeneratorSchema,
+    typeof targetErc1155GeneratorSchema,
+  ]
+> = z.union([
+  targetErc20GeneratorSchema,
+  targetErc721GeneratorSchema,
+  targetErc1155GeneratorSchema,
+])
+
+const valueTargetErc721GeneratorSchema = erc721TransferPatternSchema.extend({
+  type: z.literal('erc721'),
+  index: indexSchema,
+})
+
+const valueTargetErc1155GeneratorSchema = erc1155TransferPatternSchema.extend({
+  type: z.literal('erc1155'),
+  index: indexSchema,
+})
+
+const valueTargetGeneratorSchema: z.ZodUnion<
+  [
+    typeof valueTargetErc721GeneratorSchema,
+    typeof valueTargetErc1155GeneratorSchema,
+  ]
+> = z.union([
+  valueTargetErc721GeneratorSchema,
+  valueTargetErc1155GeneratorSchema,
+])
+
+export const generatorSchema: z.ZodObject<{
+  target: z.ZodOptional<typeof targetGeneratorSchema>
+  type: typeof actionTypeUnionSchema
+  comment: z.ZodOptional<typeof allValueSchema>
+  crossId: z.ZodOptional<typeof allValueSchema>
+  crossType: z.ZodOptional<typeof actionCrossTypeUnionSchema>
+  loanId: z.ZodOptional<typeof allValueSchema>
+  valueTarget: z.ZodOptional<typeof valueTargetGeneratorSchema>
+  transfers: z.ZodArray<typeof transferGeneratorSchema>
+}> = z.object({
+  target: targetGeneratorSchema.optional(),
+  type: actionTypeUnionSchema,
+  comment: allValueSchema.optional(),
+  crossId: allValueSchema.optional(),
+  crossType: actionCrossTypeUnionSchema.optional(),
+  loanId: allValueSchema.optional(),
+  valueTarget: valueTargetGeneratorSchema.optional(),
+  transfers: z.array(transferGeneratorSchema),
+})
+
+const exampleSchema = z.object({
+  chainId: z.number().int().positive(),
+  hash: z.string().regex(/^0x[\da-f]{64}$/),
+  addresses: z.array(addressSchema),
+})
+
+export const analyzerSchema: z.ZodObject<{
+  example: z.ZodOptional<typeof exampleSchema>
+  condition: typeof conditionSchema
+  generators: z.ZodArray<typeof generatorSchema>
+}> = z.object({
+  example: exampleSchema.optional(),
+  condition: conditionSchema,
+  generators: z.array(generatorSchema).min(1),
+})