update

lang/src/accounts/loader.rs

@@ -68,8 +68,6 @@ impl<'info, T: ZeroCopy> Loader<'info, T> {
         let disc_bytes = array_ref![data, 2, 4];
 
         if disc_bytes != &T::discriminator() {
-            crate::solana_program::msg!("DISC BYTES: {:?}", disc_bytes);
-            crate::solana_program::msg!("DISC BYTES 2: {:?}", data);
             return Err(ErrorCode::AccountDiscriminatorMismatch.into());
         }
 

lang/syn/src/codegen/accounts/constraints.rs

@@ -644,7 +644,10 @@ pub fn generate_init(
 
             let header_write = {
                 match &f.ty {
-                    Ty::Account(_) | Ty::ProgramAccount(_) => {
+                    Ty::Account(_)
+                    | Ty::ProgramAccount(_)
+                    | Ty::Loader(_)
+                    | Ty::AccountLoader(_) => {
                         let account_ty = f.account_ty();
                         if cfg!(feature = "deprecated-layout") {
                             quote! {

ts/src/coder/borsh/accounts.ts

@@ -1,3 +1,4 @@
+import { GetProgramAccountsFilter } from "@solana/web3.js";
 import bs58 from "bs58";
 import { Buffer } from "buffer";
 import { Layout } from "buffer-layout";
@@ -78,16 +79,20 @@ export class BorshAccountsCoder<A extends string = string>
     return layout.decode(data);
   }
 
-  public memcmp(accountName: A, appendData?: Buffer): any {
+  public memcmp(accountName: A): GetProgramAccountsFilter {
     const discriminator = BorshAccountHeader.discriminator(accountName);
     return {
-      offset: BorshAccountHeader.discriminatorOffset(),
-      bytes: bs58.encode(
-        appendData ? Buffer.concat([discriminator, appendData]) : discriminator
-      ),
+      memcmp: {
+        offset: BorshAccountHeader.discriminatorOffset(),
+        bytes: bs58.encode(discriminator),
+      },
     };
   }
 
+  public memcmpDataOffset(): number {
+    return BorshAccountHeader.size();
+  }
+
   public size(idlAccount: IdlTypeDef): number {
     return BorshAccountHeader.size() + (accountSize(this.idl, idlAccount) ?? 0);
   }
@@ -117,15 +122,17 @@ export class BorshAccountHeader {
    */
   public static discriminator(name: string, nameSpace?: string): Buffer {
     return Buffer.from(
-      sha256.digest(`${nameSpace ?? "account"}:${camelcase(name, { pascalCase: true })}`)
+      sha256.digest(
+        `${nameSpace ?? "account"}:${camelcase(name, { pascalCase: true })}`
+      )
     ).slice(0, BorshAccountHeader.discriminatorSize());
   }
 
-	public static discriminatorSize(): number {
-		return features.isSet("deprecated-layout")
-			? DEPRECATED_ACCOUNT_DISCRIMINATOR_SIZE
-			: ACCOUNT_DISCRIMINATOR_SIZE;
-	}
+  public static discriminatorSize(): number {
+    return features.isSet("deprecated-layout")
+      ? DEPRECATED_ACCOUNT_DISCRIMINATOR_SIZE
+      : ACCOUNT_DISCRIMINATOR_SIZE;
+  }
 
   /**
    * Returns the account data index at which the discriminator starts.

ts/src/coder/borsh/event.ts

@@ -42,7 +42,7 @@ export class BorshEventCoder implements EventCoder {
       idl.events === undefined
         ? []
         : idl.events.map((e) => [
-          base64.fromByteArray(EventHeader.discriminator(e.name)),
+            base64.fromByteArray(EventHeader.discriminator(e.name)),
             e.name,
           ])
     );
@@ -79,31 +79,31 @@ export class BorshEventCoder implements EventCoder {
 }
 
 export function eventDiscriminator(name: string): Buffer {
-	return EventHeader.discriminator(name);
+  return EventHeader.discriminator(name);
 }
 
 class EventHeader {
-	public static parseDiscriminator(data: Buffer): Buffer {
-		if (features.isSet("deprecated-layout")) {
-			return data.slice(0, 8);
-		} else {
-			return data.slice(0, 4);
-		}
-	}
+  public static parseDiscriminator(data: Buffer): Buffer {
+    if (features.isSet("deprecated-layout")) {
+      return data.slice(0, 8);
+    } else {
+      return data.slice(0, 4);
+    }
+  }
 
-	public static size(): number {
-		if (features.isSet("deprecated-layout")) {
-			return 8;
-		} else {
-			return 4;
-		}
-	}
+  public static size(): number {
+    if (features.isSet("deprecated-layout")) {
+      return 8;
+    } else {
+      return 4;
+    }
+  }
 
-	public static discriminator(name: string): Buffer {
-		if (features.isSet("deprecated-layout")) {
-		  return Buffer.from(sha256.digest(`event:${name}`)).slice(0, 8);
-		} else {
-			return Buffer.from(sha256.digest(`event:${name}`)).slice(0, 4);
-		}
-	}
+  public static discriminator(name: string): Buffer {
+    if (features.isSet("deprecated-layout")) {
+      return Buffer.from(sha256.digest(`event:${name}`)).slice(0, 8);
+    } else {
+      return Buffer.from(sha256.digest(`event:${name}`)).slice(0, 4);
+    }
+  }
 }

ts/src/coder/borsh/state.ts

@@ -20,7 +20,7 @@ export class BorshStateCoder {
     const buffer = Buffer.alloc(1000); // TODO: use a tighter buffer.
     const len = this.layout.encode(account, buffer);
 
-		let ns = features.isSet("anchor-deprecated-state") ? "account" : "state";
+    let ns = features.isSet("anchor-deprecated-state") ? "account" : "state";
     const header = BorshAccountHeader.encode(name, ns);
     const accData = buffer.slice(0, len);
 
@@ -37,5 +37,8 @@ export class BorshStateCoder {
 // Calculates unique 8 byte discriminator prepended to all anchor state accounts.
 export async function stateDiscriminator(name: string): Promise<Buffer> {
   let ns = features.isSet("anchor-deprecated-state") ? "account" : "state";
-  return Buffer.from(sha256.digest(`${ns}:${name}`)).slice(0, BorshAccountHeader.discriminatorSize());
+  return Buffer.from(sha256.digest(`${ns}:${name}`)).slice(
+    0,
+    BorshAccountHeader.discriminatorSize()
+  );
 }

ts/src/coder/index.ts

@@ -1,3 +1,4 @@
+import { GetProgramAccountsFilter } from "@solana/web3.js";
 import { IdlEvent, IdlTypeDef } from "../idl.js";
 import { Event } from "../program/event.js";
 
@@ -38,7 +39,8 @@ export interface AccountsCoder<A extends string = string> {
   encode<T = any>(accountName: A, account: T): Promise<Buffer>;
   decode<T = any>(accountName: A, ix: Buffer): T;
   decodeUnchecked<T = any>(accountName: A, ix: Buffer): T;
-  memcmp(accountName: A, appendData?: Buffer): any;
+  memcmp(accountName: A): GetProgramAccountsFilter;
+  memcmpDataOffset(): number;
   size(idlAccount: IdlTypeDef): number;
 }
 

ts/src/coder/spl-token/accounts.ts

@@ -1,3 +1,4 @@
+import { GetProgramAccountsFilter } from "@solana/web3.js";
 import * as BufferLayout from "buffer-layout";
 import { publicKey, uint64, coption, bool } from "./buffer-layout.js";
 import { AccountsCoder } from "../index.js";
@@ -44,8 +45,7 @@ export class SplTokenAccountsCoder<A extends string = string>
     }
   }
 
-  // TODO: this won't use the appendData.
-  public memcmp(accountName: A, _appendData?: Buffer): any {
+  public memcmp(accountName: A): GetProgramAccountsFilter {
     switch (accountName) {
       case "Token": {
         return {
@@ -63,6 +63,10 @@ export class SplTokenAccountsCoder<A extends string = string>
     }
   }
 
+  public memcmpDataOffset(): number {
+    return 0;
+  }
+
   public size(idlAccount: IdlTypeDef): number {
     return accountSize(this.idl, idlAccount) ?? 0;
   }

ts/src/program/namespace/account.ts

@@ -1,3 +1,4 @@
+import * as bs58 from "bs58";
 import camelCase from "camelcase";
 import EventEmitter from "eventemitter3";
 import {
@@ -201,19 +202,25 @@ export class AccountClient<
   async all(
     filters?: Buffer | GetProgramAccountsFilter[]
   ): Promise<ProgramAccount<T>[]> {
+    const typeFilter = [this.coder.accounts.memcmp(this._idlAccount.name)];
+    const dataFilter =
+      filters instanceof Buffer
+        ? [
+            {
+              memcmp: {
+                offset: this.coder.accounts.memcmpDataOffset(),
+                bytes: bs58.encode(filters),
+              },
+            },
+          ]
+        : [];
+    const miscFilters = Array.isArray(filters) ? filters : [];
+
     let resp = await this._provider.connection.getProgramAccounts(
       this._programId,
       {
         commitment: this._provider.connection.commitment,
-        filters: [
-          {
-            memcmp: this.coder.accounts.memcmp(
-              this._idlAccount.name,
-              filters instanceof Buffer ? filters : undefined
-            ),
-          },
-          ...(Array.isArray(filters) ? filters : []),
-        ],
+        filters: typeFilter.concat(dataFilter).concat(miscFilters),
       }
     );
     return resp.map(({ pubkey, account }) => {

ts/src/program/namespace/state.ts

@@ -176,15 +176,15 @@ export class StateClient<IDL extends Idl> {
 
     const expectedDiscriminator = await stateDiscriminator(state.struct.name);
 
-		if (features.isSet('deprecated-layout')) {
-			if (expectedDiscriminator.compare(accountInfo.data.slice(0, 8))) {
-				throw new Error("Invalid state discriminator");
-			}
-		} else {
-			if (expectedDiscriminator.compare(accountInfo.data.slice(2, 6))) {
-				throw new Error("Invalid state discriminator");
-			}
-		}
+    if (features.isSet("deprecated-layout")) {
+      if (expectedDiscriminator.compare(accountInfo.data.slice(0, 8))) {
+        throw new Error("Invalid state discriminator");
+      }
+    } else {
+      if (expectedDiscriminator.compare(accountInfo.data.slice(2, 6))) {
+        throw new Error("Invalid state discriminator");
+      }
+    }
 
     return this.coder.state.decode(accountInfo.data);
   }