@0xtorch/evm 0.0.11 → 0.0.13

package/analyzer/json/index.ts

@@ -1 +1,2 @@
 export { createAnalyzeByJsonRule } from './analyze'
+export { evmAnalyzersSchema } from './schemas'

package/analyzer/json/schemas/generator.ts

@@ -0,0 +1,389 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import { crossTypeSchema, normalActionActionSchema } from '@0xtorch/core'
+import { z } from 'zod'
+import { isHex, toLowerHex } from '../../../types'
+import { premitiveAddressSchema } from './utils'
+
+/** transaction from/to address 取得 component  */
+const transactionAddressComponentSchema = z.object({
+  type: z.union([z.literal('from'), z.literal('to')]),
+  /** true の場合、中央の値を短縮表記 */
+  minify: z.boolean().optional(),
+})
+
+/** transaction value 取得 component */
+const valueComponentSchema = z.object({
+  type: z.literal('value'),
+})
+
+/** log argument 取得 component */
+export const logArgumentRawComponentSchema = z.object({
+  type: z.literal('log'),
+  /** target で指定された log の中から選択するかどうか */
+  target: z.boolean().optional(),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))
+    .optional(),
+  indexedCount: z.number().int().optional(),
+  args: z
+    .array(
+      z.object({
+        index: z.number().int(),
+        value: z
+          .string()
+          .transform((x) => x.toLowerCase() as Lowercase<string>),
+      }),
+    )
+    .optional(),
+  index: z.number().int(),
+  argIndex: z.number().int(),
+})
+
+export const erc20RawComponentSchema = z.object({
+  type: z.literal('erc20'),
+  /** target で指定された erc20 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: premitiveAddressSchema.optional(),
+  from: premitiveAddressSchema.optional(),
+  to: premitiveAddressSchema.optional(),
+  value: z.bigint().optional(),
+  index: z.number().int(),
+})
+
+export const erc721RawComponentSchema = z.object({
+  type: z.literal('erc721'),
+  /** target で指定された erc721 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: premitiveAddressSchema.optional(),
+  tokenId: z.bigint().optional(),
+  from: premitiveAddressSchema.optional(),
+  to: premitiveAddressSchema.optional(),
+  index: z.number().int(),
+})
+
+export const erc1155RawComponentSchema = z.object({
+  type: z.literal('erc1155'),
+  /** target で指定された erc1155 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: premitiveAddressSchema.optional(),
+  tokenId: z.bigint().optional(),
+  from: premitiveAddressSchema.optional(),
+  to: premitiveAddressSchema.optional(),
+  value: z.bigint().optional(),
+  index: z.number().int(),
+})
+
+export const internalRawComponentSchema = z.object({
+  type: z.literal('internal'),
+  /** target で指定された erc1155 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  from: premitiveAddressSchema.optional(),
+  to: premitiveAddressSchema.optional(),
+  value: z.bigint().optional(),
+  index: z.number().int(),
+})
+
+const addressKeySchema = z.union([z.literal('from'), z.literal('to')])
+
+export const addressConditionSchema = z.union([
+  // manual address
+  premitiveAddressSchema,
+  // transaction from/to
+  transactionAddressComponentSchema,
+  // erc20
+  erc20RawComponentSchema.extend({
+    key: addressKeySchema,
+  }),
+  // erc721
+  erc721RawComponentSchema.extend({
+    key: addressKeySchema,
+  }),
+  // erc1155
+  erc1155RawComponentSchema.extend({
+    key: addressKeySchema,
+  }),
+  // internal
+  internalRawComponentSchema.extend({
+    key: addressKeySchema,
+  }),
+  // log
+  logArgumentRawComponentSchema,
+])
+
+export const valueConditionSchema = z.union([
+  // plus
+  z.literal('plus'),
+  // bigint
+  z.bigint(),
+  // transaction value
+  valueComponentSchema,
+  // erc20
+  erc20RawComponentSchema,
+  // erc1155
+  erc1155RawComponentSchema,
+  // internal
+  internalRawComponentSchema,
+  // log
+  logArgumentRawComponentSchema,
+])
+
+export const logArgumentValueConditionSchema = z.union([
+  // string
+  z.string().transform((x) => x.toLowerCase() as Lowercase<string>),
+  // transaction from/to
+  transactionAddressComponentSchema,
+  // transaction value
+  valueComponentSchema,
+  // log
+  logArgumentRawComponentSchema,
+])
+
+/** log argument 取得 component */
+export const logArgumentComponentSchema = z.object({
+  type: z.literal('log'),
+  /** target で指定された log の中から選択するかどうか */
+  target: z.boolean().optional(),
+  signature: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x'))
+    .optional(),
+  indexedCount: z.number().int().optional(),
+  args: z
+    .array(
+      z.object({
+        index: z.number().int(),
+        value: logArgumentValueConditionSchema,
+      }),
+    )
+    .optional(),
+  index: z.union([z.number().int(), z.literal('any')]),
+  argIndex: z.number().int(),
+  valueType: z.union([
+    z.literal('address'),
+    z.literal('bigint'),
+    z.literal('other'),
+  ]),
+})
+
+/** comment component */
+export const commentComponentSchema = z.union([
+  z.string(),
+  z.number(),
+  z.bigint(),
+  transactionAddressComponentSchema,
+  valueComponentSchema,
+  logArgumentComponentSchema,
+])
+
+/** cross/loan id component */
+export const idComponentSchema = z.union([
+  z.string(),
+  z.number(),
+  z.bigint(),
+  transactionAddressComponentSchema,
+  valueComponentSchema,
+  logArgumentComponentSchema,
+])
+
+/** action.transfer.direction */
+const transferDirectionSchema = z.union([
+  z.literal('in'),
+  z.literal('out'),
+  z.literal('none'),
+])
+
+export const erc20ComponentSchema = z.object({
+  type: z.literal('erc20'),
+  /** target で指定された erc20 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: addressConditionSchema.optional(),
+  from: addressConditionSchema.optional(),
+  to: addressConditionSchema.optional(),
+  value: valueConditionSchema.optional(),
+  index: z.union([z.number().int(), z.literal('any')]),
+})
+
+export const erc721ComponentSchema = z.object({
+  type: z.literal('erc721'),
+  /** target で指定された erc721 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: addressConditionSchema.optional(),
+  tokenId: z.bigint().optional(),
+  from: addressConditionSchema.optional(),
+  to: addressConditionSchema.optional(),
+  index: z.union([z.number().int(), z.literal('any')]),
+})
+
+export const erc1155ComponentSchema = z.object({
+  type: z.literal('erc1155'),
+  /** target で指定された erc1155 の中から選択するかどうか */
+  target: z.boolean().optional(),
+  token: addressConditionSchema.optional(),
+  tokenId: z.bigint().optional(),
+  from: addressConditionSchema.optional(),
+  to: addressConditionSchema.optional(),
+  value: valueConditionSchema.optional(),
+  index: z.union([z.number().int(), z.literal('any')]),
+})
+
+export const internalComponentSchema = z.object({
+  type: z.literal('internal'),
+  /** target で指定された internal の中から選択するかどうか */
+  target: z.boolean().optional(),
+  from: addressConditionSchema.optional(),
+  to: addressConditionSchema.optional(),
+  value: valueConditionSchema.optional(),
+  index: z.union([z.number().int(), z.literal('any')]),
+})
+
+const transferErc20ComponentSchema = erc20ComponentSchema.extend({
+  direction: transferDirectionSchema,
+})
+
+const transferErc20AddressComponentSchema = erc20ComponentSchema.extend({
+  key: z.union([z.literal('from'), z.literal('to')]),
+})
+
+const transferErc721ComponentSchema = erc721ComponentSchema.extend({
+  direction: transferDirectionSchema,
+})
+
+const transferErc721AddressComponentSchema = erc721ComponentSchema.extend({
+  key: z.union([z.literal('from'), z.literal('to')]),
+})
+
+const transferErc1155ComponentSchema = erc1155ComponentSchema.extend({
+  direction: transferDirectionSchema,
+})
+
+const transferErc1155AddressComponentSchema = erc1155ComponentSchema.extend({
+  key: z.union([z.literal('from'), z.literal('to')]),
+})
+
+const transferInternalComponentSchema = internalComponentSchema.extend({
+  direction: transferDirectionSchema,
+})
+
+const transferInternalAddressComponentSchema = internalComponentSchema.extend({
+  key: z.union([z.literal('from'), z.literal('to')]),
+})
+
+const transferValueComponentSchema = z.object({
+  type: z.literal('value'),
+  direction: transferDirectionSchema,
+})
+
+export const transferCustomAddressComponentSchema = z.union([
+  // manual address
+  z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{40}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  // transaction from/to
+  transactionAddressComponentSchema,
+  // erc20
+  transferErc20AddressComponentSchema,
+  // erc721
+  transferErc721AddressComponentSchema,
+  // erc1155
+  transferErc1155AddressComponentSchema,
+  // internal
+  transferInternalAddressComponentSchema,
+  // log
+  logArgumentComponentSchema,
+])
+
+export const transferCustomAssetComponentSchema = z.union([
+  // native
+  z.literal('native'),
+  // erc20
+  erc20ComponentSchema,
+  // erc721
+  erc721ComponentSchema,
+  // erc1155
+  erc1155ComponentSchema,
+])
+
+export const transferCustomAmountComponentSchema = z.object({
+  plus: z.boolean(),
+  value: z.union([
+    // big-decimal
+    z
+      .string()
+      .regex(/^\d+(\.\d+)?$/)
+      .transform((x) => createBigDecimal(x)),
+    // value
+    valueComponentSchema,
+    // internal
+    internalComponentSchema,
+    // erc20
+    erc20ComponentSchema,
+    // erc1155
+    erc1155ComponentSchema,
+  ]),
+})
+
+const transferCustomComponentSchema = z.object({
+  type: z.literal('custom'),
+  from: transferCustomAddressComponentSchema,
+  to: transferCustomAddressComponentSchema,
+  asset: transferCustomAssetComponentSchema,
+  /** amount component の合計値を amount として返す */
+  amount: z.array(transferCustomAmountComponentSchema),
+  direction: transferDirectionSchema,
+})
+
+export const transferComponentSchema = z.union([
+  transferErc20ComponentSchema,
+  transferErc721ComponentSchema,
+  transferErc1155ComponentSchema,
+  transferInternalComponentSchema,
+  transferValueComponentSchema,
+  transferCustomComponentSchema,
+])
+
+const targetComponentSchema = z.union([
+  // erc20
+  erc20ComponentSchema.omit({ index: true }),
+  // erc721
+  erc721ComponentSchema.omit({ index: true }),
+  // erc1155
+  erc1155ComponentSchema.omit({ index: true }),
+  // internal
+  internalComponentSchema.omit({ index: true }),
+  // log
+  logArgumentComponentSchema.omit({
+    index: true,
+    argIndex: true,
+    valueType: true,
+  }),
+])
+
+type ActionGeneratorSchema = z.ZodObject<{
+  target: z.ZodOptional<z.ZodArray<typeof targetComponentSchema>>
+  action: typeof normalActionActionSchema
+  comment: z.ZodOptional<z.ZodArray<typeof commentComponentSchema>>
+  crossId: z.ZodOptional<z.ZodArray<typeof idComponentSchema>>
+  crossType: z.ZodOptional<typeof crossTypeSchema>
+  loanId: z.ZodOptional<z.ZodArray<typeof idComponentSchema>>
+  transfers: z.ZodArray<typeof transferComponentSchema>
+}>
+
+export const actionGeneratorSchema: ActionGeneratorSchema = z.object({
+  /** 条件に合致する target 情報毎に 1 つの action を生成 */
+  target: z.array(targetComponentSchema).optional(),
+  action: normalActionActionSchema,
+  /** comment component で取得した値を結合して comment 生成 */
+  comment: z.array(commentComponentSchema).optional(),
+  /** id component で取得した値を結合して crossId 生成 */
+  crossId: z.array(idComponentSchema).optional(),
+  crossType: crossTypeSchema.optional(),
+  /** id component で取得した値を結合して loanId 生成 */
+  loanId: z.array(idComponentSchema).optional(),
+  // TODO transfer は任意の値を用いて生成できるようにする
+  /** component に基づいて transfer 生成 */
+  transfers: z.array(transferComponentSchema),
+})