@sentio/sdk 2.0.0-rc.2 → 2.0.0-rc.20

package/src/solana/builtin/spl-token-processor.ts

@@ -0,0 +1,298 @@
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk/solana'
+import { Instruction } from '@project-serum/anchor'
+import { AmountToUiAmount, Approve, ApproveChecked, Burn, BurnChecked, CloseAccount, CreateNativeMint, DefaultAccountStateExtension, FreezeAccount, GetAccountDataSize, InitializeAccount, InitializeAccount2, InitializeAccount3, InitializeImmutableOwner, InitializeMint, InitializeMintCloseAuthority, InitializeMultisig, MemoTransferExtension, MintTo, MintToChecked, Reallocate, Revoke, SyncNative, ThawAccount, Transfer, TransferChecked, TransferFeeExtension, UiAmountToAmount } from './types.js';
+
+export class SPLTokenProcessor extends SolanaBaseProcessor {
+  static bind(options: SolanaBindOptions): SPLTokenProcessor {
+    if (options && !options.name) {
+      options.name = 'SPL Token Program'
+    }
+    return new SPLTokenProcessor(options)
+  }
+
+  fromParsedInstruction: (instruction: { type: string, info: any }) => Instruction | null = (instruction: { type: string, info: any }) => {
+    const instructionType = instruction.type
+    if (!instructionType) {
+      return null
+    }
+    return {
+      name: instruction.type,
+      data: {
+        ...instruction.info,
+      },
+    }
+  }
+
+  public onInitializeMint(
+    handler: (data: InitializeMint, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeMint', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMint, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount(
+    hanlder: (data: InitializeAccount, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount2(
+    hanlder: (data: InitializeAccount2, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount2', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount2, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount3(
+    hanlder: (data: InitializeAccount3, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount3', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount3, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeMultisig(
+    handler: (data: InitializeMultisig, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeMultisig', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMultisig, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransfer(handler: (data: Transfer, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transfer', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Transfer, ctx)
+      }
+    })
+    return this
+  }
+
+  public onApprovend(handler: (data: Approve, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('approve', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Approve, ctx)
+      }
+    })
+    return this
+  }
+
+  public onRevoke(handler: (data: Revoke, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('revoke', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Revoke, ctx)
+      }
+    })
+    return this
+  }
+
+  public onSetAuthority(handler: (data: any, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('setAuthority', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as any, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMintTo(handler: (data: MintTo, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('mintTo', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MintTo, ctx)
+      }
+    })
+    return this
+  }
+
+  public onBurn(handler: (data: Burn, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('burn', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Burn, ctx)
+      }
+    })
+    return this
+  }
+
+  public onCloseAccount(handler: (data: CloseAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('closeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as CloseAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onFreezeAccount(handler: (data: FreezeAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('freezeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as FreezeAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onThawAccount(handler: (data: ThawAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('thawAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as ThawAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransferChecked(handler: (data: TransferChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transferChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as TransferChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onApproveChecked(handler: (data: ApproveChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('approveChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as ApproveChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMintToChecked(handler: (data: MintToChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('mintToChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MintToChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onBurnChecked(handler: (data: BurnChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('burnChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as BurnChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onSyncNative(handler: (data: SyncNative, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('syncNative', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as SyncNative, ctx)
+      }
+    })
+    return this
+  }
+
+  public onGetAccountDataSize(handler: (data: GetAccountDataSize, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('getAccountDataSize', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as GetAccountDataSize, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeImmutableOwner(handler: (data: InitializeImmutableOwner, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('initializeImmutableOwner', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeImmutableOwner, ctx)
+      }
+    })
+    return this
+  }
+
+  public onAmountToUiAmount(handler: (data: AmountToUiAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('amountToUiAmount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as AmountToUiAmount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onUiAmountToAmount(handler: (data: UiAmountToAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('uiAmountToAmount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as UiAmountToAmount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeMintCloseAuthority(handler: (data: InitializeMintCloseAuthority, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('initializeMintCloseAuthority', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMintCloseAuthority, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransferFeeExtension(handler: (data: TransferFeeExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transferFeeExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as TransferFeeExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onDefaultAccountStateExtension(handler: (data: DefaultAccountStateExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('defaultAccountStateExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as DefaultAccountStateExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onReallocate(handler: (data: Reallocate, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('reallocate', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Reallocate, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMemoTransferExtension(handler: (data: MemoTransferExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('memoTransferExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MemoTransferExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onCreateNativeMint(handler: (data: CreateNativeMint, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('createNativeMint', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as CreateNativeMint, ctx)
+      }
+    })
+    return this
+  }
+
+  // Todo(pcxu): auto gen this file
+}

package/src/solana/builtin/types.ts

@@ -0,0 +1,279 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+// copy from https://github.com/solana-labs/solana/blob/master/explorer/src/components/instruction/token/types.ts
+
+import {
+  enums,
+  type,
+  Infer,
+  number,
+  string,
+  optional,
+  array,
+  nullable,
+  union,
+  coerce,
+  instance,
+} from "superstruct";
+
+// Replace with string
+export const PublicKeyFromString = coerce(
+  instance(String),
+  string(),
+  (value) => (value)
+);
+
+export type TokenAmountUi = Infer<typeof TokenAmountUi>;
+export type MintTo = Infer<typeof MintTo>;
+export type Burn = Infer<typeof Burn>;
+export type InitializeMint = Infer<typeof InitializeMint>;
+export type InitializeAccount = Infer<typeof InitializeAccount>;
+export type InitializeAccount2 = Infer<typeof InitializeAccount2>;
+export type InitializeAccount3 = Infer<typeof InitializeAccount3>;
+export type InitializeMultisig = Infer<typeof InitializeMultisig>;
+
+export const TokenAmountUi = type({
+  amount: string(),
+  decimals: number(),
+  uiAmountString: string(),
+});
+
+const InitializeMint = type({
+  mint: PublicKeyFromString,
+  decimals: number(),
+  mintAuthority: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+const InitializeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+});
+
+const InitializeAccount2 = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  owner: PublicKeyFromString,
+});
+
+const InitializeAccount3 = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+});
+
+const InitializeMultisig = type({
+  multisig: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  signers: array(PublicKeyFromString),
+  m: number(),
+});
+
+export type Transfer = Infer<typeof Transfer>;
+export const Transfer = type({
+  source: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type Approve = Infer<typeof Approve>;
+const Approve = type({
+  source: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  amount: union([string(), number()]),
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type Revoke = Infer<typeof Revoke>;
+const Revoke = type({
+  source: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const AuthorityType = enums([
+  "mintTokens",
+  "freezeAccount",
+  "accountOwner",
+  "closeAccount",
+]);
+
+export type SetAuthority = Infer<typeof SetAuthority>;
+const SetAuthority = type({
+  mint: optional(PublicKeyFromString),
+  account: optional(PublicKeyFromString),
+  authorityType: AuthorityType,
+  newAuthority: nullable(PublicKeyFromString),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const MintTo = type({
+  mint: PublicKeyFromString,
+  account: PublicKeyFromString,
+  amount: union([string(), number()]),
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const Burn = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const CloseAccount = type({
+  account: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+export type CloseAccount = Infer<typeof CloseAccount>;
+
+export type FreezeAccount = Infer<typeof FreezeAccount>;
+const FreezeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type ThawAccount = Infer<typeof ThawAccount>;
+const ThawAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type TransferChecked = Infer<typeof TransferChecked>;
+export const TransferChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type ApproveChecked = Infer<typeof ApproveChecked>;
+const ApproveChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type MintToChecked = Infer<typeof MintToChecked>;
+const MintToChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type BurnChecked = Infer<typeof BurnChecked>;
+const BurnChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type SyncNative = Infer<typeof BurnChecked>;
+const SyncNative = type({
+  account: PublicKeyFromString,
+});
+
+export type GetAccountDataSize = Infer<typeof GetAccountDataSize>;
+const GetAccountDataSize = type({
+  mint: PublicKeyFromString,
+  extensionTypes: optional(array(string())),
+});
+
+export type InitializeImmutableOwner = Infer<typeof InitializeImmutableOwner>;
+const InitializeImmutableOwner = type({
+  account: PublicKeyFromString,
+});
+
+export type AmountToUiAmount = Infer<typeof AmountToUiAmount>;
+const AmountToUiAmount = type({
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+});
+
+export type UiAmountToAmount = Infer<typeof UiAmountToAmount>;
+const UiAmountToAmount = type({
+  mint: PublicKeyFromString,
+  uiAmount: string(),
+});
+
+export type InitializeMintCloseAuthority = Infer<typeof InitializeMintCloseAuthority>;
+const InitializeMintCloseAuthority = type({
+  mint: PublicKeyFromString,
+  newAuthority: PublicKeyFromString,
+});
+
+export type TransferFeeExtension = Infer<typeof TransferFeeExtension>;
+const TransferFeeExtension = type({
+  mint: PublicKeyFromString,
+  transferFeeConfigAuthority: PublicKeyFromString,
+  withdrawWitheldAuthority: PublicKeyFromString,
+  transferFeeBasisPoints: number(),
+  maximumFee: number(),
+});
+
+export type DefaultAccountStateExtension = Infer<typeof DefaultAccountStateExtension>;
+const DefaultAccountStateExtension = type({
+  mint: PublicKeyFromString,
+  accountState: string(),
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+export type Reallocate = Infer<typeof Reallocate>;
+const Reallocate = type({
+  account: PublicKeyFromString,
+  payer: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+  extensionTypes: array(string()),
+});
+
+export type MemoTransferExtension = Infer<typeof MemoTransferExtension>;
+const MemoTransferExtension = type({
+  account: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type CreateNativeMint = Infer<typeof CreateNativeMint>;
+const CreateNativeMint = type({
+  payer: PublicKeyFromString,
+  nativeMint: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+});

package/src/solana/codegen/codegen.ts

@@ -0,0 +1,140 @@
+import path from 'path'
+import fs from 'fs'
+import chalk from 'chalk'
+import { Idl } from '@project-serum/anchor'
+import { IdlAccountItem, IdlField, IdlInstruction, IdlType } from '@project-serum/anchor/dist/cjs/idl.js'
+
+export function codegen(abisDir: string, targetPath = path.join('src', 'types', 'solana')) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+
+  const abisFiles = fs.readdirSync(abisDir)
+
+  if (abisFiles.length > 0) {
+    console.log(chalk.green('Generated Types for Solana'))
+  }
+
+  for (const file of abisFiles) {
+    if (path.extname(file) === '.json') {
+      if (!fs.existsSync(targetPath)) {
+        fs.mkdirSync(targetPath, { recursive: true })
+      }
+      const idlContent = fs.readFileSync(path.join(abisDir, file), 'utf-8')
+      const idlObj = JSON.parse(idlContent)
+      const idlName = idlObj.name
+      const idlFile = path.join(targetPath, idlName + '.ts')
+      fs.writeFileSync(idlFile, `export const ${idlName}_idl = ${idlContent}`)
+      fs.writeFileSync(path.join(targetPath, `${idlName}_processor.ts`), codeGenSolanaIdlProcessor(idlObj))
+    }
+  }
+}
+
+function codeGenSolanaIdlProcessor(idlObj: Idl): string {
+  const idlName = idlObj.name
+  const idlNamePascalCase = toPascalCase(idlName)
+  const instructions: any[] = idlObj.instructions
+  return `import { BorshInstructionCoder, Instruction, Idl } from '@project-serum/anchor'
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "@sentio/sdk/solana"
+import { ${idlName}_idl } from "./${idlName}.js"
+import { PublicKey } from '@solana/web3.js'
+
+export class ${idlNamePascalCase}Processor extends SolanaBaseProcessor {
+  static DEFAULT_OPTIONS = {
+    name: '${idlNamePascalCase}',
+    instructionCoder: new BorshInstructionCoder(${idlName}_idl as Idl)
+  }
+
+  static bind(options: SolanaBindOptions): ${idlNamePascalCase}Processor {
+    return new ${idlNamePascalCase}Processor( { ...${idlNamePascalCase}Processor.DEFAULT_OPTIONS, ...options })
+  }
+
+  ${instructions.map((ins) => codeGenSolanaInstruction(idlNamePascalCase, ins)).join('')}
+}
+  `
+}
+
+function codeGenSolanaInstruction(idlName: string, ins: IdlInstruction): string {
+  const instructionName = ins.name
+
+  const argsType = codeGenInstructionArgsType(ins.args)
+  const accountType = codeGenAccountType(ins.accounts)
+
+  return `
+  on${
+    instructionName.charAt(0).toUpperCase() + instructionName.slice(1)
+  }(handler: (args: ${argsType}, accounts: ${accountType}, ctx: SolanaContext) => void): ${idlName}Processor {
+    this.onInstruction('${instructionName}', (ins: Instruction, ctx, accounts: string[]) => {
+      const origin = ins.data as any
+      if (origin) {
+        const data = ${codeGenInstructionArgs(ins.args)}
+        const accountData = ${codeGenAccountTypeArgs(ins.accounts)}
+        handler(data, accountData, ctx)
+      }
+    })
+    return this
+  }
+  `
+}
+
+function codeGenInstructionArgs(args: IdlField[]): string {
+  return `{ ${args.map((arg) => codeGenInstructionArg(arg.name, arg.type)).join(', ')} }`
+}
+
+function codeGenInstructionArg(name: string, type: IdlType): string {
+  const mType = mapType(type)
+  if (mType === 'bigint') {
+    return `${name}: BigInt(origin.${name}.toString())`
+  }
+  return `${name}: origin.${name} as ${mType}`
+}
+
+function codeGenInstructionArgsType(args: IdlField[]): string {
+  return `{ ${args.map((arg) => arg.name + ': ' + mapType(arg.type)).join(', ')} }`
+}
+
+function codeGenAccountType(args: IdlAccountItem[]): string {
+  return `{ ${args.map((arg) => arg.name + ': string').join(', ')} }`
+}
+
+function codeGenAccountTypeArgs(args: IdlAccountItem[]): string {
+  return `{ ${args.map((arg, idx) => `${arg.name}: accounts[${idx}]`).join(', ')} }`
+}
+
+// Reference: https://github.com/coral-xyz/anchor/blob/93332766f13e86efbe77c9986722731742317ede/ts/src/program/namespace/types.ts#L104
+function mapType(tpe: IdlType): string {
+  // TODO handle complex type
+  switch (tpe) {
+    case 'publicKey':
+      return 'PublicKey'
+    case 'bool':
+      return 'boolean'
+    case 'string':
+      return 'string'
+    case 'u8':
+    case 'i8':
+    case 'u16':
+    case 'i16':
+    case 'u32':
+    case 'i32':
+    case 'f32':
+    case 'f64':
+      return 'number'
+    case 'u64':
+    case 'i64':
+    case 'u128':
+    case 'i128':
+      return 'bigint'
+    default:
+      return 'any'
+  }
+}
+
+function toPascalCase(str: string) {
+  return `${str}`
+    .toLowerCase()
+    .replace(new RegExp(/[-_]+/, 'g'), ' ')
+    .replace(new RegExp(/[^\w\s]/, 'g'), '')
+    .replace(new RegExp(/\s+(.)(\w*)/, 'g'), ($1, $2, $3) => `${$2.toUpperCase() + $3}`)
+    .replace(new RegExp(/\w/), (s) => s.toUpperCase())
+}