@sentio/sdk 1.7.13 → 1.7.16

package/src/solana/builtin/types.ts

@@ -0,0 +1,268 @@
+/* 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,
+});
+
+const SyncNative = type({
+  account: PublicKeyFromString,
+});
+
+const GetAccountDataSize = type({
+  mint: PublicKeyFromString,
+  extensionTypes: optional(array(string())),
+});
+
+const InitializeImmutableOwner = type({
+  account: PublicKeyFromString,
+});
+
+const AmountToUiAmount = type({
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+});
+
+const UiAmountToAmount = type({
+  mint: PublicKeyFromString,
+  uiAmount: string(),
+});
+
+const InitializeMintCloseAuthority = type({
+  mint: PublicKeyFromString,
+  newAuthority: PublicKeyFromString,
+});
+
+const TransferFeeExtension = type({
+  mint: PublicKeyFromString,
+  transferFeeConfigAuthority: PublicKeyFromString,
+  withdrawWitheldAuthority: PublicKeyFromString,
+  transferFeeBasisPoints: number(),
+  maximumFee: number(),
+});
+
+const DefaultAccountStateExtension = type({
+  mint: PublicKeyFromString,
+  accountState: string(),
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+const Reallocate = type({
+  account: PublicKeyFromString,
+  payer: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+  extensionTypes: array(string()),
+});
+
+const MemoTransferExtension = type({
+  account: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const CreateNativeMint = type({
+  payer: PublicKeyFromString,
+  nativeMint: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+});

package/src/solana/builtin/wormhole-processor.ts

@@ -0,0 +1,178 @@
+import { SolanaBaseProcessor } from '../../solana-processor'
+import { SolanaContext } from '../../context'
+import { SolanaBindOptions } from '../../bind-options'
+import { Instruction } from '@project-serum/anchor'
+import * as borsh from '@project-serum/borsh'
+import bs58 from 'bs58'
+
+// https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/lib.rs#L100
+enum TokenBrigeInstruction {
+  Initialize = 0,
+  AttestToken,
+  CompleteNative, // no args
+  CompleteWrapped, // no args
+  TransferWrapped,
+  TransferNative,
+  RegisterChain, // no args
+  CreateWrapped, // no args
+  UpgradeContract, // no args
+  CompleteNativeWithPayload, // no args
+  CompleteWrappedWithPayload, // no args
+  TransferWrappedWithPayload,
+  TransferNativeWithPayload,
+}
+
+export class TokenBridgeProcessor extends SolanaBaseProcessor {
+
+  private readonly transferDataValues = [
+    borsh.u32('nonce'),
+    borsh.u64('amount'),
+    borsh.u64('fee'),
+    borsh.array(borsh.u8(undefined), 32, 'target_address'),
+    borsh.u16('target_chain')
+  ]
+  // https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer_payload.rs#L170
+  private readonly transferDataWithPayloadValues = [
+    borsh.u32('nonce'),
+    borsh.u64('amount'),
+    borsh.array(borsh.u8(undefined), 32, 'target_address'),
+    borsh.u16('target_chain'),
+    borsh.vecU8('payload'),
+    borsh.option(borsh.publicKey(undefined), 'cpi_program_id')
+  ]
+  private readonly attestTokenValues = [
+    borsh.u32('nonce')
+  ]
+  private readonly initializeDataValues = [
+    borsh.publicKey('bridge')
+  ]
+
+  static bind(options: SolanaBindOptions): TokenBridgeProcessor {
+    return new TokenBridgeProcessor(options)
+  }
+
+  decodeInstruction: (rawInstruction: string) => Instruction | null = (ins) => {
+    const u8Arr = bs58.decode(ins)
+    if (u8Arr.length === 0) {
+      return null
+    }
+
+    let data: any
+    // wormhole pass intruction's enum value as its first instrcution data
+    switch (u8Arr[0]) {
+      case TokenBrigeInstruction.Initialize:
+        return {
+          data: '',
+          name: TokenBrigeInstruction[TokenBrigeInstruction.Initialize]
+        }
+      case TokenBrigeInstruction.TransferNative:
+        // struct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
+        data = borsh.struct(this.transferDataValues, 'TransferNativeData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.TransferNative]
+        }
+      case TokenBrigeInstruction.TransferWrapped:
+        // stuct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
+        data = borsh.struct(this.transferDataValues, 'TransferWrappedData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.TransferWrapped]
+        }
+      case TokenBrigeInstruction.TransferNativeWithPayload:
+        data = borsh.struct(this.transferDataWithPayloadValues, 'TransferNativeWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.TransferNativeWithPayload]
+        }
+      case TokenBrigeInstruction.TransferWrappedWithPayload:
+        data = borsh.struct(this.transferDataWithPayloadValues, 'TransferWrappedWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.TransferWrappedWithPayload]
+        }
+      case TokenBrigeInstruction.Initialize:
+        data = borsh.struct(this.initializeDataValues, 'InitializeData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.Initialize]
+        }
+      case TokenBrigeInstruction.AttestToken:
+        data = borsh.struct(this.attestTokenValues, 'AttestTokenData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBrigeInstruction[TokenBrigeInstruction.AttestToken]
+        }
+      case TokenBrigeInstruction.CompleteNative:
+      case TokenBrigeInstruction.CompleteNativeWithPayload:
+      case TokenBrigeInstruction.CompleteWrapped:
+      case TokenBrigeInstruction.CompleteWrappedWithPayload:
+      case TokenBrigeInstruction.CreateWrapped:
+      case TokenBrigeInstruction.UpgradeContract:
+      case TokenBrigeInstruction.RegisterChain:
+        return {
+          data: '',
+          name: TokenBrigeInstruction[u8Arr[0]]
+        }
+
+      default:
+        return null
+    }
+  }
+
+  onInitialize(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('Initialize', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+
+  onAttestToken(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('AttestToken', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+
+
+  onTransferWrapped(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferWrapped', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferNativeWithPayload(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferNativeWithPayload', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferWrappedWithPaylod(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferWrappedWithPaylod', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferNative(handler: (args: any, ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferNative', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data, ctx)
+      }
+    })
+    return this
+  }
+}
+  

package/src/solana-processor.ts

@@ -0,0 +1,105 @@
+import { O11yResult } from './gen/processor/protos/processor'
+import { SolanaContext } from './context'
+import Long from 'long'
+import { Instruction } from '@project-serum/anchor'
+import { SolanaBindOptions } from './bind-options'
+
+type IndexConfigure = {
+  startSlot: Long
+  endSlot?: Long
+}
+
+export class SolanaBaseProcessor {
+  public instructionHanlderMap: Map<string, (instruction: Instruction, ctx: SolanaContext) => void> = new Map()
+  address: string
+  endpoint: string
+  contractName: string
+  processInnerInstruction: boolean
+  config: IndexConfigure = { startSlot: new Long(0) }
+  decodeInstruction: (rawInstruction: string) => Instruction | null
+  fromParsedInstruction: (instruction: { type: string; info: any }) => Instruction | null
+
+  constructor(options: SolanaBindOptions) {
+    if (options) {
+      this.bind(options)
+    }
+    global.PROCESSOR_STATE.solanaProcessors.push(this)
+  }
+
+  bind(options: SolanaBindOptions) {
+    this.address = options.address
+    this.contractName = options.name || ''
+    this.processInnerInstruction = options.processInnerInstruction || false
+    if (options.startBlock) {
+      this.startSlot(options.startBlock)
+    }
+    if (options.endBlock) {
+      this.endBlock(options.endBlock)
+    }
+    this.endpoint = options.network || 'https://api.mainnet-beta.solana.com'
+  }
+
+  innerInstruction(flag: boolean) {
+    this.processInnerInstruction = flag
+    return this
+  }
+
+  public onInstruction(instructionName: string, handler: (instruction: Instruction, ctx: SolanaContext) => void) {
+    if (!this.isBind()) {
+      throw new Error("Processor doesn't bind to an address")
+    }
+
+    this.instructionHanlderMap.set(instructionName, handler)
+
+    return this
+  }
+
+  public handleInstruction(ins: string | { type: string; info: any }): O11yResult | null {
+    const ctx = new SolanaContext(this.address)
+    let parsedInstruction: Instruction | null = null
+
+    if (ins) {
+      if ((ins as { type: string; info: any }).info) {
+        if (this.fromParsedInstruction == null) {
+          return null
+        }
+        parsedInstruction = this.fromParsedInstruction(ins as { type: string; info: any })
+      } else {
+        if (this.decodeInstruction == null) {
+          return null
+        }
+        parsedInstruction = this.decodeInstruction(ins as string)
+      }
+      if (parsedInstruction) {
+        const handler = this.instructionHanlderMap.get(parsedInstruction.name)
+        if (handler) {
+          handler(parsedInstruction, ctx)
+        }
+      }
+    }
+    return {
+      gauges: ctx.gauges,
+      counters: ctx.counters,
+    }
+  }
+
+  public isBind() {
+    return this.address !== null
+  }
+
+  public startSlot(startSlot: Long | number) {
+    if (typeof startSlot === 'number') {
+      startSlot = Long.fromNumber(startSlot)
+    }
+    this.config.startSlot = startSlot
+    return this
+  }
+
+  public endBlock(endBlock: Long | number) {
+    if (typeof endBlock === 'number') {
+      endBlock = Long.fromNumber(endBlock)
+    }
+    this.config.endSlot = endBlock
+    return this
+  }
+}