@whetstone-research/doppler-sdk 1.0.14 → 1.0.16

package/dist/solana/index.cjs

@@ -3603,6 +3603,930 @@ async function fetchConfigWithAddress(rpc, programId = chunk3BW6IVP3_cjs.CPMM_PR
   return { address: configAddress, account };
 }
 
+// src/solana/cosignerHook/index.ts
+var cosignerHook_exports = {};
+chunkQ7SFCCGT_cjs.__export(cosignerHook_exports, {
+  ADD_COSIGNER_DISCRIMINATOR: () => ADD_COSIGNER_DISCRIMINATOR,
+  COSIGNER_CONFIG_DISCRIMINATOR: () => COSIGNER_CONFIG_DISCRIMINATOR,
+  COSIGNER_HOOK_ERROR__COSIGNER_ALREADY_EXISTS: () => COSIGNER_HOOK_ERROR__COSIGNER_ALREADY_EXISTS,
+  COSIGNER_HOOK_ERROR__COSIGNER_LIST_FULL: () => COSIGNER_HOOK_ERROR__COSIGNER_LIST_FULL,
+  COSIGNER_HOOK_ERROR__COSIGNER_NOT_FOUND: () => COSIGNER_HOOK_ERROR__COSIGNER_NOT_FOUND,
+  COSIGNER_HOOK_ERROR__INVALID_AUTHORITY: () => COSIGNER_HOOK_ERROR__INVALID_AUTHORITY,
+  COSIGNER_HOOK_ERROR__INVALID_CONFIG: () => COSIGNER_HOOK_ERROR__INVALID_CONFIG,
+  COSIGNER_HOOK_ERROR__INVALID_COSIGNER: () => COSIGNER_HOOK_ERROR__INVALID_COSIGNER,
+  COSIGNER_HOOK_PROGRAM_ADDRESS: () => COSIGNER_HOOK_PROGRAM_ADDRESS,
+  COSIGNER_HOOK_PROGRAM_ID: () => COSIGNER_HOOK_PROGRAM_ID,
+  CosignerHookAccount: () => CosignerHookAccount,
+  CosignerHookInstruction: () => CosignerHookInstruction,
+  INITIALIZE_CONFIG_DISCRIMINATOR: () => INITIALIZE_CONFIG_DISCRIMINATOR2,
+  MAX_COSIGNERS: () => MAX_COSIGNERS,
+  REMOVE_COSIGNER_DISCRIMINATOR: () => REMOVE_COSIGNER_DISCRIMINATOR,
+  SEED_COSIGNER_HOOK_CONFIG: () => SEED_COSIGNER_HOOK_CONFIG,
+  SET_AUTHORITY_DISCRIMINATOR: () => SET_AUTHORITY_DISCRIMINATOR,
+  cosignerHookProgram: () => cosignerHookProgram,
+  decodeCosignerConfig: () => decodeCosignerConfig,
+  fetchAllCosignerConfig: () => fetchAllCosignerConfig,
+  fetchAllMaybeCosignerConfig: () => fetchAllMaybeCosignerConfig,
+  fetchCosignerConfig: () => fetchCosignerConfig,
+  fetchMaybeCosignerConfig: () => fetchMaybeCosignerConfig,
+  getAddCosignerDiscriminatorBytes: () => getAddCosignerDiscriminatorBytes,
+  getAddCosignerInstruction: () => getAddCosignerInstruction,
+  getAddCosignerInstructionAsync: () => getAddCosignerInstructionAsync,
+  getAddCosignerInstructionDataCodec: () => getAddCosignerInstructionDataCodec,
+  getAddCosignerInstructionDataDecoder: () => getAddCosignerInstructionDataDecoder,
+  getAddCosignerInstructionDataEncoder: () => getAddCosignerInstructionDataEncoder,
+  getCosignerArgCodec: () => getCosignerArgCodec,
+  getCosignerArgDecoder: () => getCosignerArgDecoder,
+  getCosignerArgEncoder: () => getCosignerArgEncoder,
+  getCosignerConfigCodec: () => getCosignerConfigCodec,
+  getCosignerConfigDecoder: () => getCosignerConfigDecoder,
+  getCosignerConfigDiscriminatorBytes: () => getCosignerConfigDiscriminatorBytes,
+  getCosignerConfigEncoder: () => getCosignerConfigEncoder,
+  getCosignerConfigSize: () => getCosignerConfigSize,
+  getCosignerHookConfigAddress: () => getCosignerHookConfigAddress,
+  getCosignerHookErrorMessage: () => getCosignerHookErrorMessage,
+  getInitializeConfigArgsCodec: () => getInitializeConfigArgsCodec,
+  getInitializeConfigArgsDecoder: () => getInitializeConfigArgsDecoder,
+  getInitializeConfigArgsEncoder: () => getInitializeConfigArgsEncoder,
+  getInitializeConfigDiscriminatorBytes: () => getInitializeConfigDiscriminatorBytes2,
+  getInitializeConfigInstruction: () => getInitializeConfigInstruction2,
+  getInitializeConfigInstructionAsync: () => getInitializeConfigInstructionAsync2,
+  getInitializeConfigInstructionDataCodec: () => getInitializeConfigInstructionDataCodec2,
+  getInitializeConfigInstructionDataDecoder: () => getInitializeConfigInstructionDataDecoder2,
+  getInitializeConfigInstructionDataEncoder: () => getInitializeConfigInstructionDataEncoder2,
+  getRemoveCosignerDiscriminatorBytes: () => getRemoveCosignerDiscriminatorBytes,
+  getRemoveCosignerInstruction: () => getRemoveCosignerInstruction,
+  getRemoveCosignerInstructionAsync: () => getRemoveCosignerInstructionAsync,
+  getRemoveCosignerInstructionDataCodec: () => getRemoveCosignerInstructionDataCodec,
+  getRemoveCosignerInstructionDataDecoder: () => getRemoveCosignerInstructionDataDecoder,
+  getRemoveCosignerInstructionDataEncoder: () => getRemoveCosignerInstructionDataEncoder,
+  getSetAuthorityArgsCodec: () => getSetAuthorityArgsCodec,
+  getSetAuthorityArgsDecoder: () => getSetAuthorityArgsDecoder,
+  getSetAuthorityArgsEncoder: () => getSetAuthorityArgsEncoder,
+  getSetAuthorityDiscriminatorBytes: () => getSetAuthorityDiscriminatorBytes,
+  getSetAuthorityInstruction: () => getSetAuthorityInstruction,
+  getSetAuthorityInstructionAsync: () => getSetAuthorityInstructionAsync,
+  getSetAuthorityInstructionDataCodec: () => getSetAuthorityInstructionDataCodec,
+  getSetAuthorityInstructionDataDecoder: () => getSetAuthorityInstructionDataDecoder,
+  getSetAuthorityInstructionDataEncoder: () => getSetAuthorityInstructionDataEncoder,
+  identifyCosignerHookAccount: () => identifyCosignerHookAccount,
+  identifyCosignerHookInstruction: () => identifyCosignerHookInstruction,
+  isCosignerHookError: () => isCosignerHookError,
+  parseAddCosignerInstruction: () => parseAddCosignerInstruction,
+  parseCosignerHookInstruction: () => parseCosignerHookInstruction,
+  parseInitializeConfigInstruction: () => parseInitializeConfigInstruction2,
+  parseRemoveCosignerInstruction: () => parseRemoveCosignerInstruction,
+  parseSetAuthorityInstruction: () => parseSetAuthorityInstruction
+});
+var COSIGNER_CONFIG_DISCRIMINATOR = new Uint8Array([
+  133,
+  227,
+  177,
+  74,
+  145,
+  74,
+  247,
+  183
+]);
+function getCosignerConfigDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    COSIGNER_CONFIG_DISCRIMINATOR
+  );
+}
+function getCosignerConfigEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["adminAuthority", kit.getAddressEncoder()],
+      ["cosignerCount", kit.getU8Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["version", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 37)],
+      ["cosigners", kit.getArrayEncoder(kit.getAddressEncoder(), { size: 32 })]
+    ]),
+    (value) => ({ ...value, discriminator: COSIGNER_CONFIG_DISCRIMINATOR })
+  );
+}
+function getCosignerConfigDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["adminAuthority", kit.getAddressDecoder()],
+    ["cosignerCount", kit.getU8Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["version", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 37)],
+    ["cosigners", kit.getArrayDecoder(kit.getAddressDecoder(), { size: 32 })]
+  ]);
+}
+function getCosignerConfigCodec() {
+  return kit.combineCodec(getCosignerConfigEncoder(), getCosignerConfigDecoder());
+}
+function decodeCosignerConfig(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getCosignerConfigDecoder()
+  );
+}
+async function fetchCosignerConfig(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeCosignerConfig(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeCosignerConfig(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeCosignerConfig(maybeAccount);
+}
+async function fetchAllCosignerConfig(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeCosignerConfig(
+    rpc,
+    addresses,
+    config
+  );
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeCosignerConfig(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map(
+    (maybeAccount) => decodeCosignerConfig(maybeAccount)
+  );
+}
+function getCosignerConfigSize() {
+  return 1104;
+}
+var ADD_COSIGNER_DISCRIMINATOR = new Uint8Array([
+  17,
+  34,
+  183,
+  119,
+  202,
+  255,
+  218,
+  233
+]);
+function getAddCosignerDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ADD_COSIGNER_DISCRIMINATOR
+  );
+}
+function getAddCosignerInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["cosigner", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: ADD_COSIGNER_DISCRIMINATOR })
+  );
+}
+function getAddCosignerInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["cosigner", kit.getAddressDecoder()]
+  ]);
+}
+function getAddCosignerInstructionDataCodec() {
+  return kit.combineCodec(
+    getAddCosignerInstructionDataEncoder(),
+    getAddCosignerInstructionDataDecoder()
+  );
+}
+async function getAddCosignerInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            99,
+            111,
+            115,
+            105,
+            103,
+            110,
+            101,
+            114,
+            95,
+            104,
+            111,
+            111,
+            107,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getAddCosignerInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getAddCosignerInstruction(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getAddCosignerInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseAddCosignerInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { adminAuthority: getNextAccount(), config: getNextAccount() },
+    data: getAddCosignerInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_CONFIG_DISCRIMINATOR2 = new Uint8Array([
+  208,
+  127,
+  21,
+  1,
+  194,
+  190,
+  196,
+  70
+]);
+function getInitializeConfigDiscriminatorBytes2() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_CONFIG_DISCRIMINATOR2
+  );
+}
+function getInitializeConfigInstructionDataEncoder2() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["cosigners", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR2 })
+  );
+}
+function getInitializeConfigInstructionDataDecoder2() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["cosigners", kit.getArrayDecoder(kit.getAddressDecoder())]
+  ]);
+}
+function getInitializeConfigInstructionDataCodec2() {
+  return kit.combineCodec(
+    getInitializeConfigInstructionDataEncoder2(),
+    getInitializeConfigInstructionDataDecoder2()
+  );
+}
+async function getInitializeConfigInstructionAsync2(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    payer: { value: input.payer ?? null, isWritable: true },
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true },
+    programData: { value: input.programData ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            99,
+            111,
+            115,
+            105,
+            103,
+            110,
+            101,
+            114,
+            95,
+            104,
+            111,
+            111,
+            107,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("programData", accounts.programData),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeConfigInstructionDataEncoder2().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializeConfigInstruction2(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    payer: { value: input.payer ?? null, isWritable: true },
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true },
+    programData: { value: input.programData ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("programData", accounts.programData),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeConfigInstructionDataEncoder2().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeConfigInstruction2(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 5
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      payer: getNextAccount(),
+      adminAuthority: getNextAccount(),
+      config: getNextAccount(),
+      programData: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeConfigInstructionDataDecoder2().decode(instruction.data)
+  };
+}
+var REMOVE_COSIGNER_DISCRIMINATOR = new Uint8Array([
+  174,
+  11,
+  171,
+  252,
+  179,
+  99,
+  220,
+  27
+]);
+function getRemoveCosignerDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    REMOVE_COSIGNER_DISCRIMINATOR
+  );
+}
+function getRemoveCosignerInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["cosigner", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: REMOVE_COSIGNER_DISCRIMINATOR })
+  );
+}
+function getRemoveCosignerInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["cosigner", kit.getAddressDecoder()]
+  ]);
+}
+function getRemoveCosignerInstructionDataCodec() {
+  return kit.combineCodec(
+    getRemoveCosignerInstructionDataEncoder(),
+    getRemoveCosignerInstructionDataDecoder()
+  );
+}
+async function getRemoveCosignerInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            99,
+            111,
+            115,
+            105,
+            103,
+            110,
+            101,
+            114,
+            95,
+            104,
+            111,
+            111,
+            107,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getRemoveCosignerInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getRemoveCosignerInstruction(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getRemoveCosignerInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseRemoveCosignerInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { adminAuthority: getNextAccount(), config: getNextAccount() },
+    data: getRemoveCosignerInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SET_AUTHORITY_DISCRIMINATOR = new Uint8Array([
+  133,
+  250,
+  37,
+  21,
+  110,
+  163,
+  26,
+  121
+]);
+function getSetAuthorityDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    SET_AUTHORITY_DISCRIMINATOR
+  );
+}
+function getSetAuthorityInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["adminAuthority", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: SET_AUTHORITY_DISCRIMINATOR })
+  );
+}
+function getSetAuthorityInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["adminAuthority", kit.getAddressDecoder()]
+  ]);
+}
+function getSetAuthorityInstructionDataCodec() {
+  return kit.combineCodec(
+    getSetAuthorityInstructionDataEncoder(),
+    getSetAuthorityInstructionDataDecoder()
+  );
+}
+async function getSetAuthorityInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input, adminAuthority: input.adminAuthorityArg };
+  if (!accounts.config.value) {
+    accounts.config.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            99,
+            111,
+            115,
+            105,
+            103,
+            110,
+            101,
+            114,
+            95,
+            104,
+            111,
+            111,
+            107,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getSetAuthorityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getSetAuthorityInstruction(input, config) {
+  const programAddress = config?.programAddress ?? COSIGNER_HOOK_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    adminAuthority: { value: input.adminAuthority ?? null, isWritable: false },
+    config: { value: input.config ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input, adminAuthority: input.adminAuthorityArg };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("adminAuthority", accounts.adminAuthority),
+      getAccountMeta("config", accounts.config)
+    ],
+    data: getSetAuthorityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseSetAuthorityInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { adminAuthority: getNextAccount(), config: getNextAccount() },
+    data: getSetAuthorityInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/solana/generated/cosignerHook/programs/cosignerHook.ts
+var COSIGNER_HOOK_PROGRAM_ADDRESS = "JDwnBoYE2NsmkQjQLHi1btQxeHirtJ9XjU1dM641QZt";
+var CosignerHookAccount = /* @__PURE__ */ ((CosignerHookAccount2) => {
+  CosignerHookAccount2[CosignerHookAccount2["CosignerConfig"] = 0] = "CosignerConfig";
+  return CosignerHookAccount2;
+})(CosignerHookAccount || {});
+function identifyCosignerHookAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([133, 227, 177, 74, 145, 74, 247, 183])
+    ),
+    0
+  )) {
+    return 0 /* CosignerConfig */;
+  }
+  throw new kit.SolanaError(
+    kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+    { accountData: data, programName: "cosignerHook" }
+  );
+}
+var CosignerHookInstruction = /* @__PURE__ */ ((CosignerHookInstruction2) => {
+  CosignerHookInstruction2[CosignerHookInstruction2["AddCosigner"] = 0] = "AddCosigner";
+  CosignerHookInstruction2[CosignerHookInstruction2["InitializeConfig"] = 1] = "InitializeConfig";
+  CosignerHookInstruction2[CosignerHookInstruction2["RemoveCosigner"] = 2] = "RemoveCosigner";
+  CosignerHookInstruction2[CosignerHookInstruction2["SetAuthority"] = 3] = "SetAuthority";
+  return CosignerHookInstruction2;
+})(CosignerHookInstruction || {});
+function identifyCosignerHookInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([17, 34, 183, 119, 202, 255, 218, 233])
+    ),
+    0
+  )) {
+    return 0 /* AddCosigner */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([208, 127, 21, 1, 194, 190, 196, 70])
+    ),
+    0
+  )) {
+    return 1 /* InitializeConfig */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([174, 11, 171, 252, 179, 99, 220, 27])
+    ),
+    0
+  )) {
+    return 2 /* RemoveCosigner */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([133, 250, 37, 21, 110, 163, 26, 121])
+    ),
+    0
+  )) {
+    return 3 /* SetAuthority */;
+  }
+  throw new kit.SolanaError(
+    kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "cosignerHook" }
+  );
+}
+function parseCosignerHookInstruction(instruction) {
+  const instructionType = identifyCosignerHookInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* AddCosigner */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 0 /* AddCosigner */,
+        ...parseAddCosignerInstruction(instruction)
+      };
+    }
+    case 1 /* InitializeConfig */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 1 /* InitializeConfig */,
+        ...parseInitializeConfigInstruction2(instruction)
+      };
+    }
+    case 2 /* RemoveCosigner */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 2 /* RemoveCosigner */,
+        ...parseRemoveCosignerInstruction(instruction)
+      };
+    }
+    case 3 /* SetAuthority */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 3 /* SetAuthority */,
+        ...parseSetAuthorityInstruction(instruction)
+      };
+    }
+    default:
+      throw new kit.SolanaError(
+        kit.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType,
+          programName: "cosignerHook"
+        }
+      );
+  }
+}
+function cosignerHookProgram() {
+  return (client) => {
+    return {
+      ...client,
+      cosignerHook: {
+        accounts: {
+          cosignerConfig: programClientCore.addSelfFetchFunctions(
+            client,
+            getCosignerConfigCodec()
+          )
+        },
+        instructions: {
+          addCosigner: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getAddCosignerInstructionAsync(input)
+          ),
+          initializeConfig: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getInitializeConfigInstructionAsync2({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          ),
+          removeCosigner: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getRemoveCosignerInstructionAsync(input)
+          ),
+          setAuthority: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getSetAuthorityInstructionAsync(input)
+          )
+        }
+      }
+    };
+  };
+}
+
+// src/solana/generated/cosignerHook/errors/cosignerHook.ts
+var COSIGNER_HOOK_ERROR__INVALID_CONFIG = 6e3;
+var COSIGNER_HOOK_ERROR__INVALID_AUTHORITY = 6001;
+var COSIGNER_HOOK_ERROR__INVALID_COSIGNER = 6002;
+var COSIGNER_HOOK_ERROR__COSIGNER_ALREADY_EXISTS = 6003;
+var COSIGNER_HOOK_ERROR__COSIGNER_NOT_FOUND = 6004;
+var COSIGNER_HOOK_ERROR__COSIGNER_LIST_FULL = 6005;
+var cosignerHookErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  cosignerHookErrorMessages = {
+    [COSIGNER_HOOK_ERROR__COSIGNER_ALREADY_EXISTS]: `Cosigner already exists`,
+    [COSIGNER_HOOK_ERROR__COSIGNER_LIST_FULL]: `Cosigner list is full`,
+    [COSIGNER_HOOK_ERROR__COSIGNER_NOT_FOUND]: `Cosigner not found`,
+    [COSIGNER_HOOK_ERROR__INVALID_AUTHORITY]: `Invalid cosigner hook authority`,
+    [COSIGNER_HOOK_ERROR__INVALID_CONFIG]: `Invalid cosigner hook config`,
+    [COSIGNER_HOOK_ERROR__INVALID_COSIGNER]: `Invalid cosigner key`
+  };
+}
+function getCosignerHookErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return cosignerHookErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isCosignerHookError(error, transactionMessage, code) {
+  return kit.isProgramError(
+    error,
+    transactionMessage,
+    COSIGNER_HOOK_PROGRAM_ADDRESS,
+    code
+  );
+}
+function getCosignerArgEncoder() {
+  return kit.getStructEncoder([["cosigner", kit.getAddressEncoder()]]);
+}
+function getCosignerArgDecoder() {
+  return kit.getStructDecoder([["cosigner", kit.getAddressDecoder()]]);
+}
+function getCosignerArgCodec() {
+  return kit.combineCodec(getCosignerArgEncoder(), getCosignerArgDecoder());
+}
+function getInitializeConfigArgsEncoder() {
+  return kit.getStructEncoder([
+    ["cosigners", kit.getArrayEncoder(kit.getAddressEncoder())]
+  ]);
+}
+function getInitializeConfigArgsDecoder() {
+  return kit.getStructDecoder([
+    ["cosigners", kit.getArrayDecoder(kit.getAddressDecoder())]
+  ]);
+}
+function getInitializeConfigArgsCodec() {
+  return kit.combineCodec(
+    getInitializeConfigArgsEncoder(),
+    getInitializeConfigArgsDecoder()
+  );
+}
+function getSetAuthorityArgsEncoder() {
+  return kit.getStructEncoder([["adminAuthority", kit.getAddressEncoder()]]);
+}
+function getSetAuthorityArgsDecoder() {
+  return kit.getStructDecoder([["adminAuthority", kit.getAddressDecoder()]]);
+}
+function getSetAuthorityArgsCodec() {
+  return kit.combineCodec(
+    getSetAuthorityArgsEncoder(),
+    getSetAuthorityArgsDecoder()
+  );
+}
+
+// src/solana/cosignerHook/constants.ts
+var COSIGNER_HOOK_PROGRAM_ID = COSIGNER_HOOK_PROGRAM_ADDRESS;
+var SEED_COSIGNER_HOOK_CONFIG = "cosigner_hook_config";
+var MAX_COSIGNERS = 32;
+var textEncoder2 = new TextEncoder();
+async function getCosignerHookConfigAddress(programId = COSIGNER_HOOK_PROGRAM_ID) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder2.encode(SEED_COSIGNER_HOOK_CONFIG)]
+  });
+}
+
 // src/solana/initializer/index.ts
 var initializer_exports = {};
 chunkQ7SFCCGT_cjs.__export(initializer_exports, {
@@ -3618,6 +4542,7 @@ chunkQ7SFCCGT_cjs.__export(initializer_exports, {
   HF_BEFORE_CREATE: () => HF_BEFORE_CREATE,
   HF_BEFORE_MIGRATE: () => HF_BEFORE_MIGRATE,
   HF_BEFORE_SWAP: () => HF_BEFORE_SWAP2,
+  HF_FORWARD_READONLY_SIGNERS: () => HF_FORWARD_READONLY_SIGNERS2,
   HOOK_NO_CHANGE: () => HOOK_NO_CHANGE2,
   INITIALIZER_ACCOUNT_DISCRIMINATORS: () => INITIALIZER_ACCOUNT_DISCRIMINATORS,
   INITIALIZER_INSTRUCTION_DISCRIMINATORS: () => INITIALIZER_INSTRUCTION_DISCRIMINATORS,
@@ -3655,9 +4580,9 @@ chunkQ7SFCCGT_cjs.__export(initializer_exports, {
   getInitConfigCodec: () => getInitConfigCodec,
   getInitConfigDecoder: () => getInitConfigDecoder,
   getInitConfigEncoder: () => getInitConfigEncoder,
-  getInitializeConfigArgsCodec: () => getInitializeConfigArgsCodec,
-  getInitializeConfigArgsDecoder: () => getInitializeConfigArgsDecoder,
-  getInitializeConfigArgsEncoder: () => getInitializeConfigArgsEncoder,
+  getInitializeConfigArgsCodec: () => getInitializeConfigArgsCodec2,
+  getInitializeConfigArgsDecoder: () => getInitializeConfigArgsDecoder2,
+  getInitializeConfigArgsEncoder: () => getInitializeConfigArgsEncoder2,
   getInitializeLaunchArgsCodec: () => getInitializeLaunchArgsCodec,
   getInitializeLaunchArgsDecoder: () => getInitializeLaunchArgsDecoder,
   getInitializeLaunchArgsEncoder: () => getInitializeLaunchArgsEncoder,
@@ -3738,6 +4663,7 @@ var HF_BEFORE_CREATE = 1 << 2;
 var HF_AFTER_CREATE = 1 << 3;
 var HF_BEFORE_MIGRATE = 1 << 4;
 var HF_AFTER_MIGRATE = 1 << 5;
+var HF_FORWARD_READONLY_SIGNERS2 = 1 << 6;
 var HOOK_NO_CHANGE2 = 65535;
 var INITIALIZER_INSTRUCTION_DISCRIMINATORS = {
   // SHA256("global:initialize_config")[0:8]
@@ -3877,22 +4803,22 @@ function getInitConfigDecoder() {
 function getInitConfigCodec() {
   return kit.combineCodec(getInitConfigEncoder(), getInitConfigDecoder());
 }
-function getInitializeConfigArgsEncoder() {
+function getInitializeConfigArgsEncoder2() {
   return kit.getStructEncoder([
     ["migratorAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())],
     ["hookAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
   ]);
 }
-function getInitializeConfigArgsDecoder() {
+function getInitializeConfigArgsDecoder2() {
   return kit.getStructDecoder([
     ["migratorAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())],
     ["hookAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())]
   ]);
 }
-function getInitializeConfigArgsCodec() {
+function getInitializeConfigArgsCodec2() {
   return kit.combineCodec(
-    getInitializeConfigArgsEncoder(),
-    getInitializeConfigArgsDecoder()
+    getInitializeConfigArgsEncoder2(),
+    getInitializeConfigArgsDecoder2()
   );
 }
 function getInitializeLaunchArgsEncoder() {
@@ -4112,7 +5038,7 @@ function getCurveSwapExactInInstructionDataEncoder() {
     (value) => ({ ...value, discriminator: CURVE_SWAP_EXACT_IN_DISCRIMINATOR })
   );
 }
-var INITIALIZE_CONFIG_DISCRIMINATOR2 = new Uint8Array([
+var INITIALIZE_CONFIG_DISCRIMINATOR3 = new Uint8Array([
   208,
   127,
   21,
@@ -4122,14 +5048,14 @@ var INITIALIZE_CONFIG_DISCRIMINATOR2 = new Uint8Array([
   196,
   70
 ]);
-function getInitializeConfigInstructionDataEncoder2() {
+function getInitializeConfigInstructionDataEncoder3() {
   return kit.transformEncoder(
     kit.getStructEncoder([
       ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
       ["migratorAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())],
       ["hookAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
     ]),
-    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR2 })
+    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR3 })
   );
 }
 var INITIALIZE_LAUNCH_DISCRIMINATOR = new Uint8Array([
@@ -4258,7 +5184,7 @@ function getSetMigratorAllowlistInstructionDataEncoder() {
 }
 if (process.env.NODE_ENV !== "production") ;
 var addressCodec2 = kit.getAddressCodec();
-var textEncoder2 = new TextEncoder();
+var textEncoder3 = new TextEncoder();
 function encodeU64LE(value) {
   const bytes = new Uint8Array(8);
   const view = new DataView(bytes.buffer);
@@ -4268,7 +5194,7 @@ function encodeU64LE(value) {
 async function getConfigAddress2(programId = INITIALIZER_PROGRAM_ID) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
-    seeds: [textEncoder2.encode(SEED_CONFIG2)]
+    seeds: [textEncoder3.encode(SEED_CONFIG2)]
   });
 }
 async function getProgramDataAddress(programId = INITIALIZER_PROGRAM_ID) {
@@ -4284,7 +5210,7 @@ async function getLaunchAddress(namespace, launchId, programId = INITIALIZER_PRO
   return kit.getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      textEncoder2.encode(SEED_LAUNCH),
+      textEncoder3.encode(SEED_LAUNCH),
       addressCodec2.encode(namespace),
       launchId
     ]
@@ -4294,7 +5220,7 @@ async function getLaunchAuthorityAddress(launch, programId = INITIALIZER_PROGRAM
   return kit.getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      textEncoder2.encode(SEED_LAUNCH_AUTHORITY),
+      textEncoder3.encode(SEED_LAUNCH_AUTHORITY),
       addressCodec2.encode(launch)
     ]
   });
@@ -4327,7 +5253,7 @@ function createInitializeConfigInstruction(accounts, args, programId = INITIALIZ
     { address: systemProgram, role: kit.AccountRole.READONLY }
   ];
   const data = new Uint8Array(
-    getInitializeConfigInstructionDataEncoder2().encode(args)
+    getInitializeConfigInstructionDataEncoder3().encode(args)
   );
   return { programAddress: programId, accounts: keys, data };
 }
@@ -4427,17 +5353,17 @@ var CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS = {
   ])
 };
 var addressCodec3 = kit.getAddressCodec();
-var textEncoder3 = new TextEncoder();
+var textEncoder4 = new TextEncoder();
 async function getCpmmMigratorStateAddress(launch, programId = CPMM_MIGRATOR_PROGRAM_ID) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
-    seeds: [textEncoder3.encode(SEED_STATE), addressCodec3.encode(launch)]
+    seeds: [textEncoder4.encode(SEED_STATE), addressCodec3.encode(launch)]
   });
 }
 async function getCpmmMigrationAuthorityAddress(programId = CPMM_MIGRATOR_PROGRAM_ID) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
-    seeds: [textEncoder3.encode(SEED_MIGRATION_AUTHORITY)]
+    seeds: [textEncoder4.encode(SEED_MIGRATION_AUTHORITY)]
   });
 }
 var CLAIM_RECEIPT_DISCRIMINATOR = new Uint8Array([
@@ -6320,12 +7246,12 @@ function predictionMigratorProgram() {
   };
 }
 var addressCodec4 = kit.getAddressCodec();
-var textEncoder4 = new TextEncoder();
+var textEncoder5 = new TextEncoder();
 async function getPredictionMarketAddress(oracleState, quoteMint, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      textEncoder4.encode("market"),
+      textEncoder5.encode("market"),
       addressCodec4.encode(oracleState),
       addressCodec4.encode(quoteMint)
     ]
@@ -6335,7 +7261,7 @@ async function getPredictionMarketAuthorityAddress(market, programId = PREDICTIO
   return kit.getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      textEncoder4.encode("market_authority"),
+      textEncoder5.encode("market_authority"),
       addressCodec4.encode(market)
     ]
   });
@@ -6343,20 +7269,20 @@ async function getPredictionMarketAuthorityAddress(market, programId = PREDICTIO
 async function getPredictionPotVaultAddress(market, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
-    seeds: [textEncoder4.encode("pot_vault"), addressCodec4.encode(market)]
+    seeds: [textEncoder5.encode("pot_vault"), addressCodec4.encode(market)]
   });
 }
 async function getPredictionEntryAddress(market, entryId, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
-    seeds: [textEncoder4.encode("entry"), addressCodec4.encode(market), entryId]
+    seeds: [textEncoder5.encode("entry"), addressCodec4.encode(market), entryId]
   });
 }
 async function getPredictionEntryByMintAddress(market, mint, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
   return kit.getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      textEncoder4.encode("entry_by_mint"),
+      textEncoder5.encode("entry_by_mint"),
       addressCodec4.encode(market),
       addressCodec4.encode(mint)
     ]
@@ -6479,13 +7405,20 @@ async function createInitializeLaunchInstruction(accounts, args, programId = INI
       )
     )
   );
-  if (migratorProgram === CPMM_MIGRATOR_PROGRAM_ID) {
-    if (!accounts.cpmmConfig) {
+  const shouldAppendCpmmMigratorAccounts = accounts.cpmmConfig !== void 0 || migratorProgram === CPMM_MIGRATOR_PROGRAM_ID;
+  if (shouldAppendCpmmMigratorAccounts) {
+    if (!migratorProgram) {
       throw new Error(
-        "cpmmConfig is required when migratorProgram is CPMM_MIGRATOR_PROGRAM_ID"
+        "migratorProgram is required when cpmmConfig is provided"
       );
     }
-    const [cpmmMigrationState] = await getCpmmMigratorStateAddress(launch);
+    if (!accounts.cpmmConfig) {
+      throw new Error("cpmmConfig is required when using the CPMM migrator");
+    }
+    const [cpmmMigrationState] = await getCpmmMigratorStateAddress(
+      launch,
+      migratorProgram
+    );
     keys.push({ address: cpmmMigrationState, role: kit.AccountRole.WRITABLE });
     keys.push({ address: accounts.cpmmConfig, role: kit.AccountRole.READONLY });
   }
@@ -6519,6 +7452,19 @@ function createAccountMeta2(value, role) {
   }
   return { address: value, role };
 }
+function createRemainingAccountMeta(value) {
+  if (typeof value === "string") {
+    return { address: value, role: kit.AccountRole.READONLY };
+  }
+  if (isTransactionSigner6(value)) {
+    return {
+      address: value.address,
+      role: kit.AccountRole.READONLY_SIGNER,
+      signer: value
+    };
+  }
+  return value;
+}
 function createCurveSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
   const {
     config,
@@ -6533,7 +7479,8 @@ function createCurveSwapExactInInstruction(accounts, args, programId = INITIALIZ
     user,
     hookProgram = chunk3BW6IVP3_cjs.SYSTEM_PROGRAM_ADDRESS,
     baseTokenProgram = chunk3BW6IVP3_cjs.TOKEN_PROGRAM_ADDRESS,
-    quoteTokenProgram = chunk3BW6IVP3_cjs.TOKEN_PROGRAM_ADDRESS
+    quoteTokenProgram = chunk3BW6IVP3_cjs.TOKEN_PROGRAM_ADDRESS,
+    remainingAccounts = []
   } = accounts;
   const keys = [
     { address: config, role: kit.AccountRole.READONLY },
@@ -6551,7 +7498,8 @@ function createCurveSwapExactInInstruction(accounts, args, programId = INITIALIZ
     // no-op placeholder when no real hook is configured.
     { address: hookProgram, role: kit.AccountRole.READONLY },
     { address: baseTokenProgram, role: kit.AccountRole.READONLY },
-    { address: quoteTokenProgram, role: kit.AccountRole.READONLY }
+    { address: quoteTokenProgram, role: kit.AccountRole.READONLY },
+    ...remainingAccounts.map(createRemainingAccountMeta)
   ];
   const data = new Uint8Array(
     getCurveSwapExactInInstructionDataEncoder().encode(args)
@@ -6603,22 +7551,48 @@ function createMigrateLaunchInstruction(accounts, programId = INITIALIZER_PROGRA
   );
   return { programAddress: programId, accounts: keys, data };
 }
+function isTransactionSigner8(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createRemainingAccountMeta2(value) {
+  if (typeof value === "string") {
+    return { address: value, role: kit.AccountRole.READONLY };
+  }
+  if (isTransactionSigner8(value)) {
+    return {
+      address: value.address,
+      role: kit.AccountRole.READONLY_SIGNER,
+      signer: value
+    };
+  }
+  return value;
+}
 var previewSwapExactInResultCodec = kit.getStructCodec([
   ["amountOut", kit.getU64Codec()],
   ["feePaid", kit.getU64Codec()]
 ]);
 function createPreviewSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
-  const { launch, baseVault, quoteVault, hookProgram } = accounts;
+  const {
+    launch,
+    baseVault,
+    quoteVault,
+    hookProgram,
+    remainingAccounts = []
+  } = accounts;
   const keys = [
     { address: launch, role: kit.AccountRole.READONLY },
     { address: baseVault, role: kit.AccountRole.READONLY },
     { address: quoteVault, role: kit.AccountRole.READONLY }
   ];
   const accountsList = hookProgram ? [...keys, { address: hookProgram, role: kit.AccountRole.READONLY }] : keys;
+  const accountsWithRemaining = [
+    ...accountsList,
+    ...remainingAccounts.map(createRemainingAccountMeta2)
+  ];
   const data = new Uint8Array(
     getPreviewSwapExactInInstructionDataEncoder2().encode(args)
   );
-  return { programAddress: programId, accounts: accountsList, data };
+  return { programAddress: programId, accounts: accountsWithRemaining, data };
 }
 function decodePreviewSwapExactInResult(data) {
   return previewSwapExactInResultCodec.decode(data);
@@ -7009,10 +7983,14 @@ async function buildCpmmMigrationRemainingAccounts({
   adminBaseAta,
   adminQuoteAta,
   recipientAtas,
-  cpmmProgram = chunk3BW6IVP3_cjs.CPMM_PROGRAM_ID
+  cpmmProgram = chunk3BW6IVP3_cjs.CPMM_PROGRAM_ID,
+  cpmmMigratorProgram = CPMM_MIGRATOR_PROGRAM_ID
 }) {
-  const [cpmmMigrationState] = await getCpmmMigratorStateAddress(launch);
-  const [migrationAuthority] = await getCpmmMigrationAuthorityAddress();
+  const [cpmmMigrationState] = await getCpmmMigratorStateAddress(
+    launch,
+    cpmmMigratorProgram
+  );
+  const [migrationAuthority] = await getCpmmMigrationAuthorityAddress(cpmmMigratorProgram);
   const poolInit = await chunk3BW6IVP3_cjs.getPoolInitAddresses(baseMint, quoteMint, cpmmProgram);
   const pool = poolInit.pool[0];
   const [launchLpPosition] = await chunk3BW6IVP3_cjs.getPositionAddress(
@@ -7761,8 +8739,31 @@ async function getOracleStateAddress(oracleAuthority, nonce) {
   });
 }
 
+// src/solana/deployment.ts
+var DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES = {
+  cpmmProgram: chunk3BW6IVP3_cjs.CPMM_PROGRAM_ID,
+  initializerProgram: INITIALIZER_PROGRAM_ID,
+  cpmmMigratorProgram: CPMM_MIGRATOR_PROGRAM_ID,
+  cpmmHookProgram: CPMM_HOOK_PROGRAM_ID,
+  cosignerHookProgram: COSIGNER_HOOK_PROGRAM_ID
+};
+async function deriveSolanaCpmmDeployment(programs = DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES) {
+  const [cpmmConfig] = await chunk3BW6IVP3_cjs.getConfigAddress(programs.cpmmProgram);
+  const [initializerConfig] = await getConfigAddress2(
+    programs.initializerProgram
+  );
+  return {
+    ...programs,
+    cpmmConfig,
+    initializerConfig
+  };
+}
+
+exports.DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES = DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES;
+exports.cosignerHook = cosignerHook_exports;
 exports.cpmm = cpmm_exports;
 exports.cpmmMigrator = cpmmMigrator_exports;
+exports.deriveSolanaCpmmDeployment = deriveSolanaCpmmDeployment;
 exports.initializer = initializer_exports;
 exports.predictionMigrator = predictionMigrator_exports;
 exports.trustedOracle = trustedOracle_exports;