@sentio/sdk 1.13.1 → 1.13.2

package/template/node_modules/@sentio/sdk/src/solana/builtin/types.ts

@@ -1,268 +0,0 @@
-/* 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/template/node_modules/@sentio/sdk/src/solana/builtin/wormhole-processor.ts

@@ -1,178 +0,0 @@
-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/template/node_modules/@sentio/sdk/src/solana-processor.ts

@@ -1,106 +0,0 @@
-import { ProcessResult } 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 }): ProcessResult | 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,
-      logs: [],
-    }
-  }
-
-  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
-  }
-}