ts: Add instruction decode api (#372)

CHANGELOG.md

@@ -15,6 +15,8 @@ incremented for features.
 
 * cli: Add `--program-name` option for build command to build a single program at a time ([#362](https://github.com/project-serum/anchor/pull/362)).
 * cli, client: Parse custom cluster urls from str ([#369](https://github.com/project-serum/anchor/pull/369)).
+* cli, client, lang: Update solana toolchain to v1.7.1 ([#368](https://github.com/project-serum/anchor/pull/369)).
+* ts: Instruction decoding and formatting ([#372](https://github.com/project-serum/anchor/pull/372)).
 * lang: Add `#[account(close = <destination>)]` constraint for closing accounts and sending the rent exemption lamports to a specified destination account ([#371](https://github.com/project-serum/anchor/pull/371)).
 
 ### Fixes

ts/src/coder/instruction.ts

@@ -1,9 +1,19 @@
 import camelCase from "camelcase";
 import { Layout } from "buffer-layout";
 import * as borsh from "@project-serum/borsh";
-import { Idl, IdlField, IdlStateMethod } from "../idl";
+import * as bs58 from "bs58";
+import {
+  Idl,
+  IdlField,
+  IdlStateMethod,
+  IdlType,
+  IdlTypeDef,
+  IdlAccount,
+  IdlAccountItem,
+} from "../idl";
 import { IdlCoder } from "./idl";
 import { sighash } from "./common";
+import { AccountMeta, PublicKey } from "@solana/web3.js";
 
 /**
  * Namespace for state method function signatures.
@@ -19,13 +29,35 @@ export const SIGHASH_GLOBAL_NAMESPACE = "global";
  * Encodes and decodes program instructions.
  */
 export class InstructionCoder {
-  /**
-   * Instruction args layout. Maps namespaced method
-   */
+  // Instruction args layout. Maps namespaced method
   private ixLayout: Map<string, Layout>;
 
-  public constructor(idl: Idl) {
+  // Base58 encoded sighash to instruction layout.
+  private sighashLayouts: Map<string, { layout: Layout; name: string }>;
+
+  public constructor(private idl: Idl) {
     this.ixLayout = InstructionCoder.parseIxLayout(idl);
+
+    const sighashLayouts = new Map();
+    idl.instructions.forEach((ix) => {
+      const sh = sighash(SIGHASH_GLOBAL_NAMESPACE, ix.name);
+      sighashLayouts.set(bs58.encode(sh), {
+        layout: this.ixLayout.get(ix.name),
+        name: ix.name,
+      });
+    });
+
+    if (idl.state) {
+      idl.state.methods.map((ix) => {
+        const sh = sighash(SIGHASH_STATE_NAMESPACE, ix.name);
+        sighashLayouts.set(bs58.encode(sh), {
+          layout: this.ixLayout.get(ix.name) as Layout,
+          name: ix.name,
+        });
+      });
+    }
+
+    this.sighashLayouts = sighashLayouts;
   }
 
   /**
@@ -73,4 +105,251 @@ export class InstructionCoder {
     // @ts-ignore
     return new Map(ixLayouts);
   }
+
+  /**
+   * Dewcodes a program instruction.
+   */
+  public decode(ix: Buffer | string): Instruction | null {
+    if (typeof ix === "string") {
+      ix = bs58.decode(ix);
+    }
+    let sighash = bs58.encode(ix.slice(0, 8));
+    let data = ix.slice(8);
+    const decoder = this.sighashLayouts.get(sighash);
+    if (!decoder) {
+      return null;
+    }
+    return {
+      data: decoder.layout.decode(data),
+      name: decoder.name,
+    };
+  }
+
+  /**
+   * Returns a formatted table of all the fields in the given instruction data.
+   */
+  public format(
+    ix: Instruction,
+    accountMetas: AccountMeta[]
+  ): InstructionDisplay | null {
+    return InstructionFormatter.format(ix, accountMetas, this.idl);
+  }
+}
+
+export type Instruction = {
+  name: string;
+  data: Object;
+};
+
+export type InstructionDisplay = {
+  args: { name: string; type: string; data: string }[];
+  accounts: {
+    name?: string;
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+  }[];
+};
+
+class InstructionFormatter {
+  public static format(
+    ix: Instruction,
+    accountMetas: AccountMeta[],
+    idl: Idl
+  ): InstructionDisplay | null {
+    const idlIx = idl.instructions.filter((i) => ix.name === i.name)[0];
+    if (idlIx === undefined) {
+      console.error("Invalid instruction given");
+      return null;
+    }
+
+    const args = idlIx.args.map((idlField) => {
+      return {
+        name: idlField.name,
+        type: InstructionFormatter.formatIdlType(idlField.type),
+        data: InstructionFormatter.formatIdlData(
+          idlField,
+          ix.data[idlField.name],
+          idl.types
+        ),
+      };
+    });
+
+    const flatIdlAccounts = InstructionFormatter.flattenIdlAccounts(
+      idlIx.accounts
+    );
+
+    const accounts = accountMetas.map((meta, idx) => {
+      if (idx < flatIdlAccounts.length) {
+        return {
+          name: flatIdlAccounts[idx].name,
+          ...meta,
+        };
+      }
+      // "Remaining accounts" are unnamed in Anchor.
+      else {
+        return {
+          name: undefined,
+          ...meta,
+        };
+      }
+    });
+
+    return {
+      args,
+      accounts,
+    };
+  }
+
+  private static formatIdlType(idlType: IdlType): string {
+    if (typeof idlType === "string") {
+      return idlType as string;
+    }
+
+    // @ts-ignore
+    if (idlType.vec) {
+      // @ts-ignore
+      return `Vec<${this.formatIdlType(idlType.vec)}>`;
+    }
+    // @ts-ignore
+    if (idlType.option) {
+      // @ts-ignore
+      return `Option<${this.formatIdlType(idlType.option)}>`;
+    }
+    // @ts-ignore
+    if (idlType.defined) {
+      // @ts-ignore
+      return idlType.defined;
+    }
+  }
+
+  private static formatIdlData(
+    idlField: IdlField,
+    data: Object,
+    types?: IdlTypeDef[]
+  ): string {
+    if (typeof idlField.type === "string") {
+      return data.toString();
+    }
+    // @ts-ignore
+    if (idlField.type.vec) {
+      // @ts-ignore
+      return (
+        "[" +
+        data
+          // @ts-ignore
+          .map((d: IdlField) =>
+            this.formatIdlData(
+              // @ts-ignore
+              { name: "", type: idlField.type.vec },
+              d
+            )
+          )
+          .join(", ") +
+        "]"
+      );
+    }
+    // @ts-ignore
+    if (idlField.type.option) {
+      // @ts-ignore
+      return data === null
+        ? "null"
+        : this.formatIdlData(
+            // @ts-ignore
+            { name: "", type: idlField.type.option },
+            data
+          );
+    }
+    // @ts-ignore
+    if (idlField.type.defined) {
+      if (types === undefined) {
+        throw new Error("User defined types not provided");
+      }
+      // @ts-ignore
+      const filtered = types.filter((t) => t.name === idlField.type.defined);
+      if (filtered.length !== 1) {
+        // @ts-ignore
+        throw new Error(`Type not found: ${idlField.type.defined}`);
+      }
+      return InstructionFormatter.formatIdlDataDefined(
+        filtered[0],
+        data,
+        types
+      );
+    }
+
+    return "unknown";
+  }
+
+  private static formatIdlDataDefined(
+    typeDef: IdlTypeDef,
+    data: Object,
+    types: IdlTypeDef[]
+  ): string {
+    if (typeDef.type.kind === "struct") {
+      const fields = Object.keys(data)
+        .map((k) => {
+          const f = typeDef.type.fields.filter((f) => f.name === k)[0];
+          if (f === undefined) {
+            throw new Error("Unable to find type");
+          }
+          return (
+            k + ": " + InstructionFormatter.formatIdlData(f, data[k], types)
+          );
+        })
+        .join(", ");
+      return "{ " + fields + " }";
+    } else {
+      if (typeDef.type.variants.length === 0) {
+        return "{}";
+      }
+      // Struct enum.
+      if (typeDef.type.variants[0].name) {
+        const variant = Object.keys(data)[0];
+        const enumType = data[variant];
+        const namedFields = Object.keys(enumType)
+          .map((f) => {
+            const fieldData = enumType[f];
+            const idlField = typeDef.type.variants[variant]?.filter(
+              (v: IdlField) => v.name === f
+            )[0];
+            if (idlField === undefined) {
+              throw new Error("Unable to find variant");
+            }
+            return (
+              f +
+              ": " +
+              InstructionFormatter.formatIdlData(idlField, fieldData, types)
+            );
+          })
+          .join(", ");
+
+        const variantName = camelCase(variant, { pascalCase: true });
+        if (namedFields.length === 0) {
+          return variantName;
+        }
+        return `${variantName} { ${namedFields} }`;
+      }
+      // Tuple enum.
+      else {
+        // TODO.
+        return "Tuple formatting not yet implemented";
+      }
+    }
+  }
+
+  private static flattenIdlAccounts(accounts: IdlAccountItem[]): IdlAccount[] {
+    // @ts-ignore
+    return accounts
+      .map((account) => {
+        // @ts-ignore
+        if (account.accounts) {
+          // @ts-ignore
+          return InstructionFormatter.flattenIdlAccounts(account.accounts);
+        } else {
+          return account;
+        }
+      })
+      .flat();
+  }
 }

ts/src/index.ts

@@ -11,6 +11,7 @@ import Coder, {
   StateCoder,
   TypesCoder,
 } from "./coder";
+import { Instruction } from "./coder/instruction";
 import { Idl } from "./idl";
 import workspace from "./workspace";
 import * as utils from "./utils";
@@ -56,6 +57,7 @@ export {
   StateCoder,
   TypesCoder,
   Event,
+  Instruction,
   setProvider,
   getProvider,
   Provider,