@sentio/sdk 0.6.5 → 1.0.0-rc.2

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

@@ -0,0 +1,298 @@
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk'
+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';
+
+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/builtin/solana/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,
+});