feat: Allow passing multiple entities in the ApplySystem function

clients/bolt-sdk/src/index.ts

@@ -3,7 +3,7 @@ import BN from "bn.js";
 import { PROGRAM_ID } from "./generated";
 export * from "./generated/accounts";
 export * from "./generated/instructions";
-export * from "./transactions/transactions";
+export * from "./world/transactions";
 export * from "./delegation/accounts";
 export * from "./delegation/delegate";
 
@@ -41,13 +41,12 @@ export function FindEntityPda(
   worldId = CastToBN(worldId);
   entityId = CastToBN(entityId);
   const worldIdBuffer = Buffer.from(worldId.toArrayLike(Buffer, "be", 8));
-  const entityIdBuffer = Buffer.from(entityId.toArrayLike(Buffer, "be", 8));
   const seeds = [Buffer.from("entity"), worldIdBuffer];
   if (extraSeed != null) {
     seeds.push(Buffer.from(new Uint8Array(8)));
     seeds.push(Buffer.from(extraSeed));
   } else {
-    seeds.push(entityIdBuffer);
+    seeds.push(Buffer.from(entityId.toArrayLike(Buffer, "be", 8)));
   }
   return PublicKey.findProgramAddressSync(seeds, programId)[0];
 }

clients/bolt-sdk/src/transactions/transactions.ts → clients/bolt-sdk/src/world/transactions.ts

@@ -35,11 +35,10 @@ export async function InitializeNewWorld({
 }: {
   payer: PublicKey;
   connection: Connection;
-}): Promise<{ transaction: Transaction; worldPda: PublicKey; worldId: BN }> {
+}): Promise<{ transaction: Transaction; worldPda: PublicKey }> {
   const registryPda = FindWorldRegistryPda();
   const registry = await Registry.fromAccountAddress(connection, registryPda);
-  const worldId = new BN(registry.worlds);
-  const worldPda = FindWorldPda(new BN(worldId));
+  const worldPda = FindWorldPda(new BN(registry.worlds));
   const initializeWorldIx = createInitializeNewWorldInstruction({
     world: worldPda,
     registry: registryPda,
@@ -48,7 +47,6 @@ export async function InitializeNewWorld({
   return {
     transaction: new Transaction().add(initializeWorldIx),
     worldPda,
-    worldId,
   };
 }
 
@@ -62,28 +60,31 @@ export async function InitializeNewWorld({
 export async function AddEntity({
   payer,
   world,
+  seed,
   connection,
 }: {
   payer: PublicKey;
   world: PublicKey;
+  seed?: string;
   connection: Connection;
-}): Promise<{ transaction: Transaction; entityPda: PublicKey; entityId: BN }> {
+}): Promise<{ transaction: Transaction; entityPda: PublicKey }> {
   const worldInstance = await World.fromAccountAddress(connection, world);
-  const entityId = new BN(worldInstance.entities);
-  const entityPda = FindEntityPda(new BN(worldInstance.id), entityId);
-
+  const entityPda = FindEntityPda(
+    new BN(worldInstance.id),
+    new BN(worldInstance.entities),
+    seed
+  );
   const createEntityIx = createAddEntityInstruction(
     {
       world,
       payer,
       entity: entityPda,
     },
-    { extraSeed: null }
+    { extraSeed: seed ?? null }
   );
   return {
     transaction: new Transaction().add(createEntityIx),
     entityPda,
-    entityId,
   };
 }
 
@@ -119,6 +120,7 @@ export async function InitializeComponent({
     data: componentPda,
     componentProgram: componentId,
     authority: authority ?? PROGRAM_ID,
+    instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
     anchorRemainingAccounts,
     instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
   });
@@ -130,120 +132,119 @@ export async function InitializeComponent({
 }
 
 interface ApplySystemInstruction {
-  entity: PublicKey;
-  components: PublicKey[];
-  system: PublicKey;
   authority: PublicKey;
-  seeds?: string[];
+  systemId: PublicKey;
+  entities: ApplySystemEntity[];
   extraAccounts?: web3.AccountMeta[];
   args?: object;
 }
+function getApplyInstructionFunctionName(componentsCount: number) {
+  if (componentsCount === 1) return "createApplyInstruction";
+  return `createApply${componentsCount}Instruction`;
+}
 
-export function createApplySystemInstruction({
-  entity,
-  components,
-  system,
-  seeds,
+function getBoltComponentName(index: number, componentsCount: number) {
+  if (componentsCount === 1) return "boltComponent";
+  return `boltComponent${index + 1}`;
+}
+function getBoltComponentProgramName(index: number, componentsCount: number) {
+  if (componentsCount === 1) return "componentProgram";
+  return `componentProgram${index + 1}`;
+}
+function createApplySystemInstruction({
   authority,
+  systemId,
+  entities,
   extraAccounts,
   args,
 }: ApplySystemInstruction): web3.TransactionInstruction {
-  const instructionFunctions = {
-    createApplyInstruction,
-    createApply2Instruction,
-    createApply3Instruction,
-    createApply4Instruction,
-    createApply5Instruction,
-  };
-  if (components.length === 0) throw new Error("No components provided");
-  if (seeds == null) seeds = new Array(components.length).fill("");
-  if (seeds.length !== components.length)
-    throw new Error("Seed length does not match components length");
-  const componentPdas: PublicKey[] = [];
-
-  for (let i = 0; i < components.length; i++) {
-    const componentPda = FindComponentPda(components[i], entity, seeds[i]);
-    componentPdas.push(componentPda);
+  let componentCount = 0;
+  entities.forEach(function (entity) {
+    componentCount += entity.components.length;
+  });
+  if (componentCount <= 0) {
+    throw new Error("No components provided");
   }
-  if (components.length < 1 || components.length > MAX_COMPONENTS) {
+  if (componentCount > MAX_COMPONENTS) {
     throw new Error(
       `Not implemented for component counts outside 1-${MAX_COMPONENTS}`
     );
   }
 
   const instructionArgs = {
     authority: authority ?? PROGRAM_ID,
-    boltSystem: system,
+    boltSystem: systemId,
     instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
     anchorRemainingAccounts: extraAccounts,
   };
 
-  components.forEach((component, index) => {
-    instructionArgs[getBoltComponentProgramName(index, components.length)] =
-      component;
-    instructionArgs[getBoltComponentName(index, components.length)] =
-      componentPdas[index];
+  entities.forEach(function (entity) {
+    entity.components.forEach(function (component) {
+      const componentPda = FindComponentPda(
+        component.id,
+        entity.entity,
+        component.seed ?? ""
+      );
+      instructionArgs[
+        getBoltComponentProgramName(componentCount, componentCount)
+      ] = component.id;
+      instructionArgs[getBoltComponentName(componentCount, componentCount)] =
+        componentPda;
+    });
   });
 
-  const functionName = getApplyInstructionFunctionName(components.length);
+  const instructionFunctions = {
+    createApplyInstruction,
+    createApply2Instruction,
+    createApply3Instruction,
+    createApply4Instruction,
+    createApply5Instruction,
+  };
+  const functionName = getApplyInstructionFunctionName(componentCount);
   return instructionFunctions[functionName](instructionArgs, {
     args: SerializeArgs(args),
   });
 }
 
+interface ApplySystemEntity {
+  entity: PublicKey;
+  components: ApplySystemComponent[];
+}
+interface ApplySystemComponent {
+  id: PublicKey;
+  seed?: string;
+}
+
 /**
- * Apply a system to an entity and its components
+ * Apply a system to a set of components
  * @param authority
- * @param system
- * @param entity
- * @param components
- * @param args
+ * @param systemId
+ * @param entities
  * @param extraAccounts
- * @param seeds
+ * @param args
  * @constructor
  */
 export async function ApplySystem({
   authority,
-  system,
-  entity,
-  components,
-  args = {},
+  systemId,
+  entities,
   extraAccounts,
-  seeds,
+  args,
 }: {
   authority: PublicKey;
-  system: PublicKey;
-  entity: PublicKey;
-  components: PublicKey[];
-  args?: object;
+  systemId: PublicKey;
+  entities: ApplySystemEntity[];
   extraAccounts?: web3.AccountMeta[];
-  seeds?: string[];
+  args?: object;
 }): Promise<{ transaction: Transaction }> {
   const applySystemIx = createApplySystemInstruction({
-    entity,
-    components,
-    system,
     authority,
-    seeds,
+    systemId,
+    entities,
     extraAccounts,
     args,
   });
   return {
     transaction: new Transaction().add(applySystemIx),
   };
 }
-
-function getApplyInstructionFunctionName(componentsLength: number) {
-  if (componentsLength === 1) return "createApplyInstruction";
-  return `createApply${componentsLength}Instruction`;
-}
-
-function getBoltComponentName(index: number, componentsLength: number) {
-  if (componentsLength === 1) return "boltComponent";
-  return `boltComponent${index + 1}`;
-}
-
-function getBoltComponentProgramName(index: number, componentsLength: number) {
-  if (componentsLength === 1) return "componentProgram";
-  return `componentProgram${index + 1}`;
-}

package.json

@@ -30,4 +30,4 @@
     },
     "license": "MIT",
     "packageManager": "[email protected]+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
-}
+}