@sentio/sdk 3.9.0-rc.4 → 3.9.0-rc.5

package/src/solana/builtin/types.ts

@@ -1,280 +1,795 @@
 /* eslint-disable @typescript-eslint/no-redeclare */
-// copy from https://github.com/solana-labs/solana/blob/master/explorer/src/components/instruction/token/types.ts
-// https://github.com/solana-labs/explorer/blob/411b42439553262ef9036985d287a7249acaad77/src/components/instruction/token/types.ts
+// Synced from https://github.com/solana-foundation/explorer/blob/master/app/components/instruction/token/types.ts
+// Local `PublicKeyFromString` is a string-coercing variant (we use kit's `Address` branded
+// string instead of v1's `PublicKey` class), so the import is replaced. Everything else
+// mirrors the upstream JSON-parsed shape produced by Solana RPC's `jsonParsed` encoding.
 
 import {
+  array,
+  boolean,
+  coerce,
   enums,
-  type,
   Infer,
+  instance,
+  nullable,
   number,
-  string,
   optional,
-  array,
-  nullable,
+  string,
+  type,
   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>;
+} from 'superstruct'
 
+export const PublicKeyFromString = coerce(instance(String), string(), (value) => value)
+
+export type TokenAmountUi = Infer<typeof TokenAmountUi>
 export const TokenAmountUi = type({
   amount: string(),
   decimals: number(),
   uiAmountString: string(),
-});
+})
 
-const InitializeMint = type({
-  mint: PublicKeyFromString,
+export type InitializeMint = Infer<typeof InitializeMint>
+export const InitializeMint = type({
   decimals: number(),
+  freezeAuthority: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   mintAuthority: PublicKeyFromString,
   rentSysvar: PublicKeyFromString,
-  freezeAuthority: optional(PublicKeyFromString),
-});
+})
 
-const InitializeAccount = type({
+export type InitializeMint2 = Infer<typeof InitializeMint2>
+export const InitializeMint2 = type({
+  decimals: number(),
+  freezeAuthority: PublicKeyFromString,
+  freezeAuthorityOption: optional(number()),
+  mint: PublicKeyFromString,
+  mintAuthority: PublicKeyFromString,
+})
+
+export type InitializeAccount = Infer<typeof InitializeAccount>
+export const InitializeAccount = type({
   account: PublicKeyFromString,
   mint: PublicKeyFromString,
   owner: PublicKeyFromString,
   rentSysvar: PublicKeyFromString,
-});
+})
 
-const InitializeAccount2 = type({
+export type InitializeAccount2 = Infer<typeof InitializeAccount2>
+export const InitializeAccount2 = type({
   account: PublicKeyFromString,
   mint: PublicKeyFromString,
-  rentSysvar: PublicKeyFromString,
   owner: PublicKeyFromString,
-});
+  rentSysvar: PublicKeyFromString,
+})
 
-const InitializeAccount3 = type({
+export type InitializeAccount3 = Infer<typeof InitializeAccount3>
+export const InitializeAccount3 = type({
   account: PublicKeyFromString,
   mint: PublicKeyFromString,
   owner: PublicKeyFromString,
-});
+})
 
-const InitializeMultisig = type({
+export type InitializeMultisig = Infer<typeof InitializeMultisig>
+export const InitializeMultisig = type({
+  m: number(),
   multisig: PublicKeyFromString,
   rentSysvar: PublicKeyFromString,
   signers: array(PublicKeyFromString),
-  m: number(),
-});
+})
 
-export type Transfer = Infer<typeof Transfer>;
+export type Transfer = Infer<typeof Transfer>
 export const Transfer = type({
-  source: PublicKeyFromString,
-  destination: PublicKeyFromString,
   amount: union([string(), number()]),
   authority: optional(PublicKeyFromString),
+  destination: PublicKeyFromString,
   multisigAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
-
-export type Approve = Infer<typeof Approve>;
-const Approve = type({
   source: PublicKeyFromString,
-  delegate: PublicKeyFromString,
+})
+
+export type Approve = Infer<typeof Approve>
+export const Approve = type({
   amount: union([string(), number()]),
-  owner: optional(PublicKeyFromString),
+  delegate: PublicKeyFromString,
   multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
-
-export type Revoke = Infer<typeof Revoke>;
-const Revoke = type({
   source: PublicKeyFromString,
-  owner: optional(PublicKeyFromString),
+})
+
+export type Revoke = Infer<typeof Revoke>
+export const Revoke = type({
   multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+  source: PublicKeyFromString,
+})
 
-const AuthorityType = enums([
-  "mintTokens",
-  "freezeAccount",
-  "accountOwner",
-  "closeAccount",
-]);
+const AuthorityType = enums(['mintTokens', 'freezeAccount', 'accountOwner', 'closeAccount'])
 
-export type SetAuthority = Infer<typeof SetAuthority>;
-const SetAuthority = type({
-  mint: optional(PublicKeyFromString),
+export type SetAuthority = Infer<typeof SetAuthority>
+export const SetAuthority = type({
   account: optional(PublicKeyFromString),
-  authorityType: AuthorityType,
-  newAuthority: nullable(PublicKeyFromString),
   authority: optional(PublicKeyFromString),
+  authorityType: AuthorityType,
+  mint: optional(PublicKeyFromString),
   multisigAuthority: optional(PublicKeyFromString),
+  newAuthority: nullable(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-const MintTo = type({
-  mint: PublicKeyFromString,
+export type MintTo = Infer<typeof MintTo>
+export const MintTo = type({
   account: PublicKeyFromString,
   amount: union([string(), number()]),
+  mint: PublicKeyFromString,
   mintAuthority: optional(PublicKeyFromString),
   multisigMintAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-const Burn = type({
+export type Burn = Infer<typeof Burn>
+export const Burn = type({
   account: PublicKeyFromString,
-  mint: PublicKeyFromString,
   amount: union([string(), number()]),
   authority: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   multisigAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-const CloseAccount = type({
+export type CloseAccount = Infer<typeof CloseAccount>
+export const CloseAccount = type({
   account: PublicKeyFromString,
   destination: PublicKeyFromString,
-  owner: optional(PublicKeyFromString),
   multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
-export type CloseAccount = Infer<typeof CloseAccount>;
+})
 
-export type FreezeAccount = Infer<typeof FreezeAccount>;
-const FreezeAccount = type({
+export type FreezeAccount = Infer<typeof FreezeAccount>
+export const FreezeAccount = type({
   account: PublicKeyFromString,
-  mint: PublicKeyFromString,
   freezeAuthority: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   multisigFreezeAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-export type ThawAccount = Infer<typeof ThawAccount>;
-const ThawAccount = type({
+export type ThawAccount = Infer<typeof ThawAccount>
+export const ThawAccount = type({
   account: PublicKeyFromString,
-  mint: PublicKeyFromString,
   freezeAuthority: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   multisigFreezeAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-export type TransferChecked = Infer<typeof TransferChecked>;
+export type TransferChecked = Infer<typeof TransferChecked>
 export const TransferChecked = type({
-  source: PublicKeyFromString,
-  mint: PublicKeyFromString,
-  destination: PublicKeyFromString,
   authority: optional(PublicKeyFromString),
+  destination: PublicKeyFromString,
+  mint: PublicKeyFromString,
   multisigAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
   tokenAmount: TokenAmountUi,
-});
+})
 
-export type ApproveChecked = Infer<typeof ApproveChecked>;
-const ApproveChecked = type({
-  source: PublicKeyFromString,
-  mint: PublicKeyFromString,
+export type ApproveChecked = Infer<typeof ApproveChecked>
+export const ApproveChecked = type({
   delegate: PublicKeyFromString,
-  owner: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
   tokenAmount: TokenAmountUi,
-});
+})
 
-export type MintToChecked = Infer<typeof MintToChecked>;
-const MintToChecked = type({
+export type MintToChecked = Infer<typeof MintToChecked>
+export 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({
+export type BurnChecked = Infer<typeof BurnChecked>
+export const BurnChecked = type({
   account: PublicKeyFromString,
-  mint: PublicKeyFromString,
   authority: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
   multisigAuthority: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
   tokenAmount: TokenAmountUi,
-});
+})
 
-export type SyncNative = Infer<typeof BurnChecked>;
-const SyncNative = type({
+export type SyncNative = Infer<typeof SyncNative>
+export const SyncNative = type({
   account: PublicKeyFromString,
-});
+})
 
-export type GetAccountDataSize = Infer<typeof GetAccountDataSize>;
-const GetAccountDataSize = type({
-  mint: PublicKeyFromString,
+export type GetAccountDataSize = Infer<typeof GetAccountDataSize>
+export const GetAccountDataSize = type({
   extensionTypes: optional(array(string())),
-});
+  mint: PublicKeyFromString,
+})
 
-export type InitializeImmutableOwner = Infer<typeof InitializeImmutableOwner>;
-const InitializeImmutableOwner = type({
+export type InitializeImmutableOwner = Infer<typeof InitializeImmutableOwner>
+export const InitializeImmutableOwner = type({
   account: PublicKeyFromString,
-});
+})
 
-export type AmountToUiAmount = Infer<typeof AmountToUiAmount>;
-const AmountToUiAmount = type({
-  mint: PublicKeyFromString,
+export type AmountToUiAmount = Infer<typeof AmountToUiAmount>
+export const AmountToUiAmount = type({
   amount: union([string(), number()]),
-});
+  mint: PublicKeyFromString,
+})
 
-export type UiAmountToAmount = Infer<typeof UiAmountToAmount>;
-const UiAmountToAmount = type({
+export type UiAmountToAmount = Infer<typeof UiAmountToAmount>
+export const UiAmountToAmount = type({
   mint: PublicKeyFromString,
   uiAmount: string(),
-});
+})
 
-export type InitializeMintCloseAuthority = Infer<typeof InitializeMintCloseAuthority>;
-const InitializeMintCloseAuthority = type({
+export type InitializeMintCloseAuthority = Infer<typeof InitializeMintCloseAuthority>
+export const InitializeMintCloseAuthority = type({
   mint: PublicKeyFromString,
   newAuthority: PublicKeyFromString,
-});
+})
 
-export type TransferFeeExtension = Infer<typeof TransferFeeExtension>;
-const TransferFeeExtension = type({
+export type TransferFeeExtension = Infer<typeof TransferFeeExtension>
+export const TransferFeeExtension = type({
+  maximumFee: number(),
   mint: PublicKeyFromString,
+  transferFeeBasisPoints: number(),
   transferFeeConfigAuthority: PublicKeyFromString,
   withdrawWitheldAuthority: PublicKeyFromString,
-  transferFeeBasisPoints: number(),
-  maximumFee: number(),
-});
+})
 
-export type DefaultAccountStateExtension = Infer<typeof DefaultAccountStateExtension>;
-const DefaultAccountStateExtension = type({
-  mint: PublicKeyFromString,
+export type DefaultAccountStateExtension = Infer<typeof DefaultAccountStateExtension>
+export const DefaultAccountStateExtension = type({
   accountState: string(),
   freezeAuthority: optional(PublicKeyFromString),
-});
+  mint: PublicKeyFromString,
+})
 
-export type Reallocate = Infer<typeof Reallocate>;
-const Reallocate = type({
+export type Reallocate = Infer<typeof Reallocate>
+export const Reallocate = type({
   account: PublicKeyFromString,
+  extensionTypes: array(string()),
   payer: PublicKeyFromString,
   systemProgram: PublicKeyFromString,
-  extensionTypes: array(string()),
-});
+})
 
-export type MemoTransferExtension = Infer<typeof MemoTransferExtension>;
-const MemoTransferExtension = type({
+export type MemoTransferExtension = Infer<typeof MemoTransferExtension>
+export const MemoTransferExtension = type({
   account: PublicKeyFromString,
-  owner: optional(PublicKeyFromString),
   multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
   signers: optional(array(PublicKeyFromString)),
-});
+})
 
-export type CreateNativeMint = Infer<typeof CreateNativeMint>;
-const CreateNativeMint = type({
-  payer: PublicKeyFromString,
+export type CreateNativeMint = Infer<typeof CreateNativeMint>
+export const CreateNativeMint = type({
   nativeMint: PublicKeyFromString,
+  payer: PublicKeyFromString,
   systemProgram: PublicKeyFromString,
-});
+})
+
+export type InitializeMetadataPointerInfo = Infer<typeof InitializeMetadataPointer>
+export const InitializeMetadataPointer = type({
+  authority: PublicKeyFromString,
+  metadataAddress: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type InitializeGroupMemberPointerInfo = Infer<typeof InitializeGroupMemberPointer>
+export const InitializeGroupMemberPointer = type({
+  authority: PublicKeyFromString,
+  memberAddress: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type InitializeNonTransferableMint = Infer<typeof InitializeNonTransferableMint>
+export const InitializeNonTransferableMint = type({
+  mint: PublicKeyFromString,
+})
+
+export type InitializePermanentDelegate = Infer<typeof InitializePermanentDelegate>
+export const InitializePermanentDelegate = type({
+  delegate: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type InitializeTokenMetadataInfo = Infer<typeof InitializeTokenMetadata>
+export const InitializeTokenMetadata = type({
+  metadata: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  mintAuthority: PublicKeyFromString,
+  name: string(),
+  symbol: string(),
+  updateAuthority: PublicKeyFromString,
+  uri: string(),
+})
+
+export type UpdateTokenMetadataFieldInfo = Infer<typeof UpdateTokenMetadataField>
+export const UpdateTokenMetadataField = type({
+  field: string(),
+  metadata: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+  value: string(),
+})
+
+export type RemoveTokenMetadataKeyInfo = Infer<typeof RemoveTokenMetadataKey>
+export const RemoveTokenMetadataKey = type({
+  idempotent: optional(boolean()),
+  key: string(),
+  metadata: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+})
+
+export type UpdateTokenMetadataUpdateAuthorityInfo = Infer<typeof UpdateTokenMetadataUpdateAuthority>
+export const UpdateTokenMetadataUpdateAuthority = type({
+  metadata: PublicKeyFromString,
+  newUpdateAuthority: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+})
+
+export type UpdateTokenMetadataAuthorityInfo = Infer<typeof UpdateTokenMetadataAuthority>
+export const UpdateTokenMetadataAuthority = type({
+  metadata: PublicKeyFromString,
+  newAuthority: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+})
+
+export type EmitTokenMetadataInfo = Infer<typeof EmitTokenMetadata>
+export const EmitTokenMetadata = type({
+  end: optional(nullable(number())),
+  metadata: PublicKeyFromString,
+  start: optional(nullable(number())),
+})
+
+export type UpdateMetadataPointerInfo = Infer<typeof UpdateMetadataPointer>
+export const UpdateMetadataPointer = type({
+  authority: PublicKeyFromString,
+  metadataAddress: optional(nullable(PublicKeyFromString)),
+  mint: PublicKeyFromString,
+})
+
+export type InitializeGroupPointerInfo = Infer<typeof InitializeGroupPointer>
+export const InitializeGroupPointer = type({
+  authority: PublicKeyFromString,
+  groupAddress: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type UpdateGroupPointerInfo = Infer<typeof UpdateGroupPointer>
+export const UpdateGroupPointer = type({
+  authority: PublicKeyFromString,
+  groupAddress: optional(nullable(PublicKeyFromString)),
+  mint: PublicKeyFromString,
+})
+
+export type UpdateGroupMemberPointerInfo = Infer<typeof UpdateGroupMemberPointer>
+export const UpdateGroupMemberPointer = type({
+  authority: PublicKeyFromString,
+  memberAddress: optional(nullable(PublicKeyFromString)),
+  mint: PublicKeyFromString,
+})
+
+export type InitializeTokenGroupInfo = Infer<typeof InitializeTokenGroup>
+export const InitializeTokenGroup = type({
+  group: PublicKeyFromString,
+  maxSize: number(),
+  mint: PublicKeyFromString,
+  mintAuthority: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+})
+
+export type UpdateTokenGroupMaxSizeInfo = Infer<typeof UpdateTokenGroupMaxSize>
+export const UpdateTokenGroupMaxSize = type({
+  group: PublicKeyFromString,
+  maxSize: number(),
+  updateAuthority: PublicKeyFromString,
+})
+
+export type UpdateTokenGroupUpdateAuthorityInfo = Infer<typeof UpdateTokenGroupUpdateAuthority>
+export const UpdateTokenGroupUpdateAuthority = type({
+  group: PublicKeyFromString,
+  newUpdateAuthority: PublicKeyFromString,
+  updateAuthority: PublicKeyFromString,
+})
+
+export type InitializeTokenGroupMemberInfo = Infer<typeof InitializeTokenGroupMember>
+export const InitializeTokenGroupMember = type({
+  group: PublicKeyFromString,
+  groupUpdateAuthority: PublicKeyFromString,
+  member: PublicKeyFromString,
+  memberMint: PublicKeyFromString,
+  memberMintAuthority: PublicKeyFromString,
+})
+
+// Confidential Transfer extension instructions (Token-2022).
+// JSON shapes mirror agave/transaction-status/src/parse_token/extension/confidential_transfer.rs.
+
+export type InitializeConfidentialTransferMint = Infer<typeof InitializeConfidentialTransferMint>
+export const InitializeConfidentialTransferMint = type({
+  auditorElGamalPubkey: nullable(string()),
+  authority: optional(PublicKeyFromString),
+  autoApproveNewAccounts: boolean(),
+  mint: PublicKeyFromString,
+})
+
+export type UpdateConfidentialTransferMint = Infer<typeof UpdateConfidentialTransferMint>
+export const UpdateConfidentialTransferMint = type({
+  auditorElGamalPubkey: nullable(string()),
+  autoApproveNewAccounts: boolean(),
+  confidentialTransferMintAuthority: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type ConfigureConfidentialTransferAccount = Infer<typeof ConfigureConfidentialTransferAccount>
+export const ConfigureConfidentialTransferAccount = type({
+  account: PublicKeyFromString,
+  decryptableZeroBalance: string(),
+  instructionsSysvar: optional(PublicKeyFromString),
+  maximumPendingBalanceCreditCounter: union([string(), number()]),
+  mint: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
+  proofContextStateAccount: optional(PublicKeyFromString),
+  proofInstructionOffset: number(),
+  recordAccount: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+})
+
+export type ApproveConfidentialTransferAccount = Infer<typeof ApproveConfidentialTransferAccount>
+export const ApproveConfidentialTransferAccount = type({
+  account: PublicKeyFromString,
+  confidentialTransferAuditorAuthority: PublicKeyFromString,
+  mint: PublicKeyFromString,
+})
+
+export type EmptyConfidentialTransferAccount = Infer<typeof EmptyConfidentialTransferAccount>
+export const EmptyConfidentialTransferAccount = type({
+  account: PublicKeyFromString,
+  instructionsSysvar: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
+  proofContextStateAccount: optional(PublicKeyFromString),
+  proofInstructionOffset: number(),
+  recordAccount: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+})
+
+export type DepositConfidentialTransfer = Infer<typeof DepositConfidentialTransfer>
+export const DepositConfidentialTransfer = type({
+  amount: union([string(), number()]),
+  decimals: number(),
+  destination: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
+})
+
+export type WithdrawConfidentialTransfer = Infer<typeof WithdrawConfidentialTransfer>
+export const WithdrawConfidentialTransfer = type({
+  amount: union([string(), number()]),
+  decimals: number(),
+  destination: PublicKeyFromString,
+  equalityProofContextStateAccount: optional(PublicKeyFromString),
+  equalityProofInstructionOffset: number(),
+  equalityProofRecordAccount: optional(PublicKeyFromString),
+  instructionsSysvar: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  newDecryptableAvailableBalance: string(),
+  owner: optional(PublicKeyFromString),
+  rangeProofContextStateAccount: optional(PublicKeyFromString),
+  rangeProofInstructionOffset: number(),
+  rangeProofRecordAccount: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
+})
+
+export type ConfidentialTransfer = Infer<typeof ConfidentialTransfer>
+export const ConfidentialTransfer = type({
+  ciphertextValidityProofContextStateAccount: optional(PublicKeyFromString),
+  ciphertextValidityProofInstructionOffset: number(),
+  ciphertextValidityProofRecordAccount: optional(PublicKeyFromString),
+  destination: PublicKeyFromString,
+  equalityProofContextStateAccount: optional(PublicKeyFromString),
+  equalityProofInstructionOffset: number(),
+  equalityProofRecordAccount: optional(PublicKeyFromString),
+  instructionsSysvar: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  newSourceDecryptableAvailableBalance: string(),
+  owner: optional(PublicKeyFromString),
+  rangeProofContextStateAccount: optional(PublicKeyFromString),
+  rangeProofInstructionOffset: number(),
+  rangeProofRecordAccount: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
+})
+
+export type ConfidentialTransferWithFee = Infer<typeof ConfidentialTransferWithFee>
+export const ConfidentialTransferWithFee = type({
+  destination: PublicKeyFromString,
+  equalityProofContextStateAccount: optional(PublicKeyFromString),
+  equalityProofInstructionOffset: number(),
+  equalityProofRecordAccount: optional(PublicKeyFromString),
+  feeCiphertextValidityProofContextStateAccount: optional(PublicKeyFromString),
+  feeCiphertextValidityProofInstructionOffset: number(),
+  feeCiphertextValidityProofRecordAccount: optional(PublicKeyFromString),
+  feeSigmaProofContextStateAccount: optional(PublicKeyFromString),
+  feeSigmaProofInstructionOffset: number(),
+  feeSigmaProofRecordAccount: optional(PublicKeyFromString),
+  instructionsSysvar: optional(PublicKeyFromString),
+  mint: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  newSourceDecryptableAvailableBalance: string(),
+  owner: optional(PublicKeyFromString),
+  rangeProofContextStateAccount: optional(PublicKeyFromString),
+  rangeProofInstructionOffset: number(),
+  rangeProofRecordAccount: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
+  transferAmountCiphertextValidityProofContextStateAccount: optional(PublicKeyFromString),
+  transferAmountCiphertextValidityProofInstructionOffset: number(),
+  transferAmountCiphertextValidityProofRecordAccount: optional(PublicKeyFromString),
+})
+
+export type ApplyPendingConfidentialTransferBalance = Infer<typeof ApplyPendingConfidentialTransferBalance>
+export const ApplyPendingConfidentialTransferBalance = type({
+  account: PublicKeyFromString,
+  expectedPendingBalanceCreditCounter: union([string(), number()]),
+  multisigOwner: optional(PublicKeyFromString),
+  newDecryptableAvailableBalance: string(),
+  owner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+})
+
+export type ConfidentialTransferCreditsToggle = Infer<typeof ConfidentialTransferCreditsToggle>
+export const ConfidentialTransferCreditsToggle = type({
+  account: PublicKeyFromString,
+  multisigOwner: optional(PublicKeyFromString),
+  owner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+})
+
+export type ConfigureConfidentialAccountWithRegistry = Infer<typeof ConfigureConfidentialAccountWithRegistry>
+export const ConfigureConfidentialAccountWithRegistry = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  registry: PublicKeyFromString,
+})
+
+export type WithdrawExcessLamports = Infer<typeof WithdrawExcessLamports>
+export const WithdrawExcessLamports = type({
+  authority: optional(PublicKeyFromString),
+  destination: PublicKeyFromString,
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  source: PublicKeyFromString,
+})
+
+export type TokenInstructionType = Infer<typeof TokenInstructionType>
+export const TokenInstructionType = enums([
+  'initializeMint',
+  'initializeMint2',
+  'initializeAccount',
+  'initializeAccount2',
+  'initializeAccount3',
+  'initializeGroupMemberPointer',
+  'initializeMultisig',
+  'initializeNonTransferableMint',
+  'initializeTokenGroupMember',
+  'initializeTokenMetadata',
+  'initializePermanentDelegate',
+  'initializeMetadataPointer',
+  'transfer',
+  'approve',
+  'revoke',
+  'setAuthority',
+  'mintTo',
+  'burn',
+  'closeAccount',
+  'freezeAccount',
+  'thawAccount',
+  'transfer2',
+  'approve2',
+  'mintTo2',
+  'burn2',
+  'transferChecked',
+  'approveChecked',
+  'mintToChecked',
+  'burnChecked',
+  'syncNative',
+  'getAccountDataSize',
+  'initializeImmutableOwner',
+  'amountToUiAmount',
+  'uiAmountToAmount',
+  'initializeMintCloseAuthority',
+  'transferFeeExtension',
+  'defaultAccountStateExtension',
+  'reallocate',
+  'memoTransferExtension',
+  'updateTokenMetadataField',
+  'removeTokenMetadataKey',
+  'updateTokenMetadataAuthority',
+  'updateTokenMetadataUpdateAuthority',
+  'emitTokenMetadata',
+  'updateMetadataPointer',
+  'initializeGroupPointer',
+  'updateGroupPointer',
+  'updateGroupMemberPointer',
+  'initializeTokenGroup',
+  'updateTokenGroupMaxSize',
+  'updateTokenGroupUpdateAuthority',
+  'createNativeMint',
+  'initializeConfidentialTransferMint',
+  'updateConfidentialTransferMint',
+  'configureConfidentialTransferAccount',
+  'approveConfidentialTransferAccount',
+  'emptyConfidentialTransferAccount',
+  'depositConfidentialTransfer',
+  'withdrawConfidentialTransfer',
+  'confidentialTransfer',
+  'confidentialTransferWithFee',
+  'applyPendingConfidentialTransferBalance',
+  'enableConfidentialTransferConfidentialCredits',
+  'disableConfidentialTransferConfidentialCredits',
+  'enableConfidentialTransferNonConfidentialCredits',
+  'disableConfidentialTransferNonConfidentialCredits',
+  'configureConfidentialAccountWithRegistry',
+  'withdrawExcessLamports',
+])
+
+export const IX_STRUCTS = {
+  amountToUiAmount: AmountToUiAmount,
+  applyPendingConfidentialTransferBalance: ApplyPendingConfidentialTransferBalance,
+  approve: Approve,
+  approve2: ApproveChecked,
+  approveChecked: ApproveChecked,
+  approveConfidentialTransferAccount: ApproveConfidentialTransferAccount,
+  burn: Burn,
+  burn2: BurnChecked,
+  burnChecked: BurnChecked,
+  closeAccount: CloseAccount,
+  confidentialTransfer: ConfidentialTransfer,
+  confidentialTransferWithFee: ConfidentialTransferWithFee,
+  configureConfidentialAccountWithRegistry: ConfigureConfidentialAccountWithRegistry,
+  configureConfidentialTransferAccount: ConfigureConfidentialTransferAccount,
+  createNativeMint: CreateNativeMint,
+  defaultAccountStateExtension: DefaultAccountStateExtension,
+  depositConfidentialTransfer: DepositConfidentialTransfer,
+  disableConfidentialTransferConfidentialCredits: ConfidentialTransferCreditsToggle,
+  disableConfidentialTransferNonConfidentialCredits: ConfidentialTransferCreditsToggle,
+  emitTokenMetadata: EmitTokenMetadata,
+  emptyConfidentialTransferAccount: EmptyConfidentialTransferAccount,
+  enableConfidentialTransferConfidentialCredits: ConfidentialTransferCreditsToggle,
+  enableConfidentialTransferNonConfidentialCredits: ConfidentialTransferCreditsToggle,
+  freezeAccount: FreezeAccount,
+  getAccountDataSize: GetAccountDataSize,
+  initializeAccount: InitializeAccount,
+  initializeAccount2: InitializeAccount2,
+  initializeAccount3: InitializeAccount3,
+  initializeConfidentialTransferMint: InitializeConfidentialTransferMint,
+  initializeGroupMemberPointer: InitializeGroupMemberPointer,
+  initializeGroupPointer: InitializeGroupPointer,
+  initializeImmutableOwner: InitializeImmutableOwner,
+  initializeMetadataPointer: InitializeMetadataPointer,
+  initializeMint: InitializeMint,
+  initializeMint2: InitializeMint2,
+  initializeMintCloseAuthority: InitializeMintCloseAuthority,
+  initializeMultisig: InitializeMultisig,
+  initializeNonTransferableMint: InitializeNonTransferableMint,
+  initializePermanentDelegate: InitializePermanentDelegate,
+  initializeTokenGroup: InitializeTokenGroup,
+  initializeTokenGroupMember: InitializeTokenGroupMember,
+  initializeTokenMetadata: InitializeTokenMetadata,
+  memoTransferExtension: MemoTransferExtension,
+  mintTo: MintTo,
+  mintTo2: MintToChecked,
+  mintToChecked: MintToChecked,
+  reallocate: Reallocate,
+  removeTokenMetadataKey: RemoveTokenMetadataKey,
+  revoke: Revoke,
+  setAuthority: SetAuthority,
+  syncNative: SyncNative,
+  thawAccount: ThawAccount,
+  transfer: Transfer,
+  transfer2: TransferChecked,
+  transferChecked: TransferChecked,
+  transferFeeExtension: TransferFeeExtension,
+  uiAmountToAmount: UiAmountToAmount,
+  updateConfidentialTransferMint: UpdateConfidentialTransferMint,
+  updateGroupMemberPointer: UpdateGroupMemberPointer,
+  updateGroupPointer: UpdateGroupPointer,
+  updateMetadataPointer: UpdateMetadataPointer,
+  updateTokenGroupMaxSize: UpdateTokenGroupMaxSize,
+  updateTokenGroupUpdateAuthority: UpdateTokenGroupUpdateAuthority,
+  updateTokenMetadataAuthority: UpdateTokenMetadataAuthority,
+  updateTokenMetadataField: UpdateTokenMetadataField,
+  updateTokenMetadataUpdateAuthority: UpdateTokenMetadataUpdateAuthority,
+  withdrawConfidentialTransfer: WithdrawConfidentialTransfer,
+  withdrawExcessLamports: WithdrawExcessLamports,
+}
+
+export const IX_TITLES = {
+  amountToUiAmount: 'Amount To UiAmount',
+  applyPendingConfidentialTransferBalance: 'Apply Pending Confidential Transfer Balance',
+  approve: 'Approve',
+  approve2: 'Approve (Checked)',
+  approveChecked: 'Approve (Checked)',
+  approveConfidentialTransferAccount: 'Approve Confidential Transfer Account',
+  burn: 'Burn',
+  burn2: 'Burn (Checked)',
+  burnChecked: 'Burn (Checked)',
+  closeAccount: 'Close Account',
+  confidentialTransfer: 'Confidential Transfer',
+  confidentialTransferWithFee: 'Confidential Transfer With Fee',
+  configureConfidentialAccountWithRegistry: 'Configure Confidential Account With Registry',
+  configureConfidentialTransferAccount: 'Configure Confidential Transfer Account',
+  createNativeMint: 'Create Native Mint',
+  defaultAccountStateExtension: 'Default Account State Extension',
+  depositConfidentialTransfer: 'Deposit Confidential Transfer',
+  disableConfidentialTransferConfidentialCredits: 'Disable Confidential Credits',
+  disableConfidentialTransferNonConfidentialCredits: 'Disable Non-Confidential Credits',
+  emitTokenMetadata: 'Emit Token Metadata',
+  emptyConfidentialTransferAccount: 'Empty Confidential Transfer Account',
+  enableConfidentialTransferConfidentialCredits: 'Enable Confidential Credits',
+  enableConfidentialTransferNonConfidentialCredits: 'Enable Non-Confidential Credits',
+  freezeAccount: 'Freeze Account',
+  getAccountDataSize: 'Get Account Data Size',
+  initializeAccount: 'Initialize Account',
+  initializeAccount2: 'Initialize Account (2)',
+  initializeAccount3: 'Initialize Account (3)',
+  initializeConfidentialTransferMint: 'Initialize Confidential Transfer Mint',
+  initializeGroupMemberPointer: 'Initialize Group Member Pointer',
+  initializeGroupPointer: 'Initialize Group Pointer',
+  initializeImmutableOwner: 'Initialize Immutable Owner',
+  initializeMetadataPointer: 'Initialize Metadata Pointer',
+  initializeMint: 'Initialize Mint',
+  initializeMint2: 'Initialize Mint (2)',
+  initializeMintCloseAuthority: 'Initialize Mint Close Authority',
+  initializeMultisig: 'Initialize Multisig',
+  initializeNonTransferableMint: 'Initialize Non-Transferable Mint',
+  initializePermanentDelegate: 'Initialize Permanent Delegate',
+  initializeTokenGroup: 'Initialize Token Group',
+  initializeTokenGroupMember: 'Initialize Token Group Member',
+  initializeTokenMetadata: 'Initialize Token Metadata',
+  memoTransferExtension: 'Memo Transfer Extension',
+  mintTo: 'Mint To',
+  mintTo2: 'Mint To (Checked)',
+  mintToChecked: 'Mint To (Checked)',
+  reallocate: 'Reallocate',
+  removeTokenMetadataKey: 'Remove Token Metadata Key',
+  revoke: 'Revoke',
+  setAuthority: 'Set Authority',
+  syncNative: 'Sync Native',
+  thawAccount: 'Thaw Account',
+  transfer: 'Transfer',
+  transfer2: 'Transfer (Checked)',
+  transferChecked: 'Transfer (Checked)',
+  transferFeeExtension: 'Transfer Fee Extension',
+  uiAmountToAmount: 'UiAmount To Amount',
+  updateConfidentialTransferMint: 'Update Confidential Transfer Mint',
+  updateGroupMemberPointer: 'Update Group Member Pointer',
+  updateGroupPointer: 'Update Group Pointer',
+  updateMetadataPointer: 'Update Metadata Pointer',
+  updateTokenGroupMaxSize: 'Update Token Group Max Size',
+  updateTokenGroupUpdateAuthority: 'Update Token Group Update Authority',
+  updateTokenMetadataAuthority: 'Update Token Metadata Authority',
+  updateTokenMetadataField: 'Update Token Metadata Field',
+  updateTokenMetadataUpdateAuthority: 'Update Token Metadata Update Authority',
+  withdrawConfidentialTransfer: 'Withdraw Confidential Transfer',
+  withdrawExcessLamports: 'Withdraw Excess Lamports',
+}