Attempt to making filter generation automated in Anchor / Solana.

filterGenerator.ts

export const generateFilter = (filterParams) => {
  const IDL_DEFINATION = {
    name: "vote",
    type: {
      kind: "struct",
      fields: [
        {
          name: "proposalId",
          type: "u64",
        },
        {
          name: "vote",
          type: "bool",
        },
        {
          name: "voter",
          type: "publicKey",
        },
        {
          name: "createdAt",
          type: "i64",
        },
        {
          name: "bump",
          type: "u8",
        },
      ],
    },
  };

  type sizeType = {
    [key: string]: number;
  };
  const sizeDict: sizeType = {
    bool: 1,
    i8: 1,
    u8: 1,
    i16: 2,
    u16: 2,
    i32: 4,
    u32: 4,
    i64: 8,
    u64: 8,
    i128: 16,
    u128: 16,
    publicKey: 32,
  };

  const formatterDict: { [key: string]: (value: any) => any } = {
    u64: (value: number | Buffer) => {
      if (value instanceof Buffer) return value;
      return bs58.encode(getNumberBuffer(value));
    },
    publicKey: (value: PublicKey | Buffer) => {
      if (value instanceof Buffer) return value;
      return bs58.encode(value.toBuffer() as Buffer);
    },
    i64: (value: number | Buffer) => {
      if (value instanceof Buffer) return value;
      return bs58.encode(getNumberBuffer(value));
    },
    bool: (value: boolean | Buffer) => {
      if (value instanceof Buffer) return value;
      return bs58.encode(value ? Buffer.from([1]) : Buffer.from([0]));
    },
    string: (value: string | Buffer) => {
      if (value instanceof Buffer) return value;
      return bs58.encode(Buffer.from(value));
    },
  };

  const param = IDL_DEFINATION.type.fields
    .reduce((prev: any[], field, index) => {
      let offset = 0;
      if (index === 0) {
        offset += sizeDict[field.type];
      } else {
        const previous = prev[index - 1];
        offset = sizeDict[field.type] + previous.offset + previous.size;
      }
      const f = {
        offset, // Account Discriminator.
        ...field,
        size: sizeDict[field.type],
      };
      return [...prev, f];
    }, [])
    .map((v) => {
      console.log(v);
      return v;
    })
    .reduce(
      (prev, curr) => {
        prev[curr.name] = {
          offset: curr.offset,
          type: curr.type,
          formatter: formatterDict[curr.type],
        };
        return prev;
      },
      {
        discriminator: { offset: 8, formatter: (v: any) => v },
      }
    );

  console.log(param);
  // const vote: IdlAccounts<AnchorVoting>["vote"] = {};

  const filters = Object.entries(filterParams).map((key, index) => {
    const [keyName, valueName] = key;
    return {
      memcmp: {
        offset: param[keyName].offset,
        bytes: param[keyName].formatter(valueName),
      },
    };
  });
  console.log({
    input: filterParams,
    output: filters,
  });
  return filters;

  // return filterParams
};