@solana/subscriptions 0.1.0 → 0.2.0

package/dist/index.js

@@ -856,10 +856,10 @@ import {
   assertIsInstructionWithAccounts,
   containsBytes,
   extendClient,
-  getU8Encoder as getU8Encoder19,
+  getU8Encoder as getU8Encoder20,
   SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
   SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
-  SolanaError as SolanaError14
+  SolanaError as SolanaError15
 } from "@solana/kit";
 import {
   addSelfFetchFunctions,
@@ -1512,7 +1512,7 @@ function parseInitSubscriptionAuthorityInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/revokeDelegation.ts
+// src/generated/instructions/resumeSubscription.ts
 import {
   combineCodec as combineCodec24,
   getStructDecoder as getStructDecoder22,
@@ -1523,22 +1523,143 @@ import {
   SolanaError as SolanaError8,
   transformEncoder as transformEncoder8
 } from "@solana/kit";
-import { getAccountMetaFactory as getAccountMetaFactory8 } from "@solana/program-client-core";
+import {
+  getAccountMetaFactory as getAccountMetaFactory8,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount3
+} from "@solana/program-client-core";
+var RESUME_SUBSCRIPTION_DISCRIMINATOR = 13;
+function getResumeSubscriptionDiscriminatorBytes() {
+  return getU8Encoder13().encode(RESUME_SUBSCRIPTION_DISCRIMINATOR);
+}
+function getResumeSubscriptionInstructionDataEncoder() {
+  return transformEncoder8(getStructEncoder22([["discriminator", getU8Encoder13()]]), (value) => ({
+    ...value,
+    discriminator: RESUME_SUBSCRIPTION_DISCRIMINATOR
+  }));
+}
+function getResumeSubscriptionInstructionDataDecoder() {
+  return getStructDecoder22([["discriminator", getU8Decoder13()]]);
+}
+function getResumeSubscriptionInstructionDataCodec() {
+  return combineCodec24(getResumeSubscriptionInstructionDataEncoder(), getResumeSubscriptionInstructionDataDecoder());
+}
+async function getResumeSubscriptionInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.subscriptionPda.value) {
+    accounts.subscriptionPda.value = await findSubscriptionDelegationPda({
+      planPda: getAddressFromResolvedInstructionAccount3("planPda", accounts.planPda.value),
+      subscriber: getAddressFromResolvedInstructionAccount3("subscriber", accounts.subscriber.value)
+    });
+  }
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getResumeSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getResumeSubscriptionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    subscriber: { value: input.subscriber ?? null, isWritable: false },
+    planPda: { value: input.planPda ?? null, isWritable: false },
+    subscriptionPda: { value: input.subscriptionPda ?? null, isWritable: true },
+    eventAuthority: { value: input.eventAuthority ?? null, isWritable: false },
+    selfProgram: { value: input.selfProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.eventAuthority.value) {
+    accounts.eventAuthority.value = "3Hnj4BYoDgtpBuqXfiy7Y8cNa3jXaNd4oqgSXBzkMcH7";
+  }
+  if (!accounts.selfProgram.value) {
+    accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
+  }
+  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("subscriber", accounts.subscriber),
+      getAccountMeta("planPda", accounts.planPda),
+      getAccountMeta("subscriptionPda", accounts.subscriptionPda),
+      getAccountMeta("eventAuthority", accounts.eventAuthority),
+      getAccountMeta("selfProgram", accounts.selfProgram)
+    ],
+    data: getResumeSubscriptionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseResumeSubscriptionInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new SolanaError8(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8, {
+      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: {
+      subscriber: getNextAccount(),
+      planPda: getNextAccount(),
+      subscriptionPda: getNextAccount(),
+      eventAuthority: getNextAccount(),
+      selfProgram: getNextAccount()
+    },
+    data: getResumeSubscriptionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/revokeDelegation.ts
+import {
+  combineCodec as combineCodec25,
+  getStructDecoder as getStructDecoder23,
+  getStructEncoder as getStructEncoder23,
+  getU8Decoder as getU8Decoder14,
+  getU8Encoder as getU8Encoder14,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
+  SolanaError as SolanaError9,
+  transformEncoder as transformEncoder9
+} from "@solana/kit";
+import { getAccountMetaFactory as getAccountMetaFactory9 } from "@solana/program-client-core";
 var REVOKE_DELEGATION_DISCRIMINATOR = 3;
 function getRevokeDelegationDiscriminatorBytes() {
-  return getU8Encoder13().encode(REVOKE_DELEGATION_DISCRIMINATOR);
+  return getU8Encoder14().encode(REVOKE_DELEGATION_DISCRIMINATOR);
 }
 function getRevokeDelegationInstructionDataEncoder() {
-  return transformEncoder8(getStructEncoder22([["discriminator", getU8Encoder13()]]), (value) => ({
+  return transformEncoder9(getStructEncoder23([["discriminator", getU8Encoder14()]]), (value) => ({
     ...value,
     discriminator: REVOKE_DELEGATION_DISCRIMINATOR
   }));
 }
 function getRevokeDelegationInstructionDataDecoder() {
-  return getStructDecoder22([["discriminator", getU8Decoder13()]]);
+  return getStructDecoder23([["discriminator", getU8Decoder14()]]);
 }
 function getRevokeDelegationInstructionDataCodec() {
-  return combineCodec24(getRevokeDelegationInstructionDataEncoder(), getRevokeDelegationInstructionDataDecoder());
+  return combineCodec25(getRevokeDelegationInstructionDataEncoder(), getRevokeDelegationInstructionDataDecoder());
 }
 function getRevokeDelegationInstruction(input, config) {
   const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
@@ -1547,7 +1668,7 @@ function getRevokeDelegationInstruction(input, config) {
     delegationAccount: { value: input.delegationAccount ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory9(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -1559,7 +1680,7 @@ function getRevokeDelegationInstruction(input, config) {
 }
 function parseRevokeDelegationInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError8(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8, {
+    throw new SolanaError9(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 2
     });
@@ -1579,40 +1700,40 @@ function parseRevokeDelegationInstruction(instruction) {
 
 // src/generated/instructions/subscribe.ts
 import {
-  combineCodec as combineCodec25,
-  getStructDecoder as getStructDecoder23,
-  getStructEncoder as getStructEncoder23,
-  getU8Decoder as getU8Decoder14,
-  getU8Encoder as getU8Encoder14,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
-  SolanaError as SolanaError9,
-  transformEncoder as transformEncoder9
+  combineCodec as combineCodec26,
+  getStructDecoder as getStructDecoder24,
+  getStructEncoder as getStructEncoder24,
+  getU8Decoder as getU8Decoder15,
+  getU8Encoder as getU8Encoder15,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
+  SolanaError as SolanaError10,
+  transformEncoder as transformEncoder10
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory9,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount3
+  getAccountMetaFactory as getAccountMetaFactory10,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount4
 } from "@solana/program-client-core";
 var SUBSCRIBE_DISCRIMINATOR = 11;
 function getSubscribeDiscriminatorBytes() {
-  return getU8Encoder14().encode(SUBSCRIBE_DISCRIMINATOR);
+  return getU8Encoder15().encode(SUBSCRIBE_DISCRIMINATOR);
 }
 function getSubscribeInstructionDataEncoder() {
-  return transformEncoder9(
-    getStructEncoder23([
-      ["discriminator", getU8Encoder14()],
+  return transformEncoder10(
+    getStructEncoder24([
+      ["discriminator", getU8Encoder15()],
       ["subscribeData", getSubscribeDataEncoder()]
     ]),
     (value) => ({ ...value, discriminator: SUBSCRIBE_DISCRIMINATOR })
   );
 }
 function getSubscribeInstructionDataDecoder() {
-  return getStructDecoder23([
-    ["discriminator", getU8Decoder14()],
+  return getStructDecoder24([
+    ["discriminator", getU8Decoder15()],
     ["subscribeData", getSubscribeDataDecoder()]
   ]);
 }
 function getSubscribeInstructionDataCodec() {
-  return combineCodec25(getSubscribeInstructionDataEncoder(), getSubscribeInstructionDataDecoder());
+  return combineCodec26(getSubscribeInstructionDataEncoder(), getSubscribeInstructionDataDecoder());
 }
 async function getSubscribeInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
@@ -1630,8 +1751,8 @@ async function getSubscribeInstructionAsync(input, config) {
   const args = { ...input };
   if (!accounts.subscriptionPda.value) {
     accounts.subscriptionPda.value = await findSubscriptionDelegationPda({
-      planPda: getAddressFromResolvedInstructionAccount3("planPda", accounts.planPda.value),
-      subscriber: getAddressFromResolvedInstructionAccount3("subscriber", accounts.subscriber.value)
+      planPda: getAddressFromResolvedInstructionAccount4("planPda", accounts.planPda.value),
+      subscriber: getAddressFromResolvedInstructionAccount4("subscriber", accounts.subscriber.value)
     });
   }
   if (!accounts.systemProgram.value) {
@@ -1643,7 +1764,7 @@ async function getSubscribeInstructionAsync(input, config) {
   if (!accounts.selfProgram.value) {
     accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
   }
-  const getAccountMeta = getAccountMetaFactory9(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("subscriber", accounts.subscriber),
@@ -1682,7 +1803,7 @@ function getSubscribeInstruction(input, config) {
   if (!accounts.selfProgram.value) {
     accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
   }
-  const getAccountMeta = getAccountMetaFactory9(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("subscriber", accounts.subscriber),
@@ -1700,7 +1821,7 @@ function getSubscribeInstruction(input, config) {
 }
 function parseSubscribeInstruction(instruction) {
   if (instruction.accounts.length < 8) {
-    throw new SolanaError9(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9, {
+    throw new SolanaError10(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 8
     });
@@ -1729,37 +1850,37 @@ function parseSubscribeInstruction(instruction) {
 
 // src/generated/instructions/transferFixed.ts
 import {
-  combineCodec as combineCodec26,
-  getStructDecoder as getStructDecoder24,
-  getStructEncoder as getStructEncoder24,
-  getU8Decoder as getU8Decoder15,
-  getU8Encoder as getU8Encoder15,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
-  SolanaError as SolanaError10,
-  transformEncoder as transformEncoder10
+  combineCodec as combineCodec27,
+  getStructDecoder as getStructDecoder25,
+  getStructEncoder as getStructEncoder25,
+  getU8Decoder as getU8Decoder16,
+  getU8Encoder as getU8Encoder16,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
+  SolanaError as SolanaError11,
+  transformEncoder as transformEncoder11
 } from "@solana/kit";
-import { getAccountMetaFactory as getAccountMetaFactory10 } from "@solana/program-client-core";
+import { getAccountMetaFactory as getAccountMetaFactory11 } from "@solana/program-client-core";
 var TRANSFER_FIXED_DISCRIMINATOR = 4;
 function getTransferFixedDiscriminatorBytes() {
-  return getU8Encoder15().encode(TRANSFER_FIXED_DISCRIMINATOR);
+  return getU8Encoder16().encode(TRANSFER_FIXED_DISCRIMINATOR);
 }
 function getTransferFixedInstructionDataEncoder() {
-  return transformEncoder10(
-    getStructEncoder24([
-      ["discriminator", getU8Encoder15()],
+  return transformEncoder11(
+    getStructEncoder25([
+      ["discriminator", getU8Encoder16()],
       ["transferData", getTransferDataEncoder()]
     ]),
     (value) => ({ ...value, discriminator: TRANSFER_FIXED_DISCRIMINATOR })
   );
 }
 function getTransferFixedInstructionDataDecoder() {
-  return getStructDecoder24([
-    ["discriminator", getU8Decoder15()],
+  return getStructDecoder25([
+    ["discriminator", getU8Decoder16()],
     ["transferData", getTransferDataDecoder()]
   ]);
 }
 function getTransferFixedInstructionDataCodec() {
-  return combineCodec26(getTransferFixedInstructionDataEncoder(), getTransferFixedInstructionDataDecoder());
+  return combineCodec27(getTransferFixedInstructionDataEncoder(), getTransferFixedInstructionDataDecoder());
 }
 function getTransferFixedInstruction(input, config) {
   const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
@@ -1781,7 +1902,7 @@ function getTransferFixedInstruction(input, config) {
   if (!accounts.selfProgram.value) {
     accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
   }
-  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory11(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("delegationPda", accounts.delegationPda),
@@ -1799,7 +1920,7 @@ function getTransferFixedInstruction(input, config) {
 }
 function parseTransferFixedInstruction(instruction) {
   if (instruction.accounts.length < 8) {
-    throw new SolanaError10(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10, {
+    throw new SolanaError11(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 8
     });
@@ -1828,37 +1949,37 @@ function parseTransferFixedInstruction(instruction) {
 
 // src/generated/instructions/transferRecurring.ts
 import {
-  combineCodec as combineCodec27,
-  getStructDecoder as getStructDecoder25,
-  getStructEncoder as getStructEncoder25,
-  getU8Decoder as getU8Decoder16,
-  getU8Encoder as getU8Encoder16,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
-  SolanaError as SolanaError11,
-  transformEncoder as transformEncoder11
+  combineCodec as combineCodec28,
+  getStructDecoder as getStructDecoder26,
+  getStructEncoder as getStructEncoder26,
+  getU8Decoder as getU8Decoder17,
+  getU8Encoder as getU8Encoder17,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
+  SolanaError as SolanaError12,
+  transformEncoder as transformEncoder12
 } from "@solana/kit";
-import { getAccountMetaFactory as getAccountMetaFactory11 } from "@solana/program-client-core";
+import { getAccountMetaFactory as getAccountMetaFactory12 } from "@solana/program-client-core";
 var TRANSFER_RECURRING_DISCRIMINATOR = 5;
 function getTransferRecurringDiscriminatorBytes() {
-  return getU8Encoder16().encode(TRANSFER_RECURRING_DISCRIMINATOR);
+  return getU8Encoder17().encode(TRANSFER_RECURRING_DISCRIMINATOR);
 }
 function getTransferRecurringInstructionDataEncoder() {
-  return transformEncoder11(
-    getStructEncoder25([
-      ["discriminator", getU8Encoder16()],
+  return transformEncoder12(
+    getStructEncoder26([
+      ["discriminator", getU8Encoder17()],
       ["transferData", getTransferDataEncoder()]
     ]),
     (value) => ({ ...value, discriminator: TRANSFER_RECURRING_DISCRIMINATOR })
   );
 }
 function getTransferRecurringInstructionDataDecoder() {
-  return getStructDecoder25([
-    ["discriminator", getU8Decoder16()],
+  return getStructDecoder26([
+    ["discriminator", getU8Decoder17()],
     ["transferData", getTransferDataDecoder()]
   ]);
 }
 function getTransferRecurringInstructionDataCodec() {
-  return combineCodec27(getTransferRecurringInstructionDataEncoder(), getTransferRecurringInstructionDataDecoder());
+  return combineCodec28(getTransferRecurringInstructionDataEncoder(), getTransferRecurringInstructionDataDecoder());
 }
 function getTransferRecurringInstruction(input, config) {
   const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
@@ -1880,7 +2001,7 @@ function getTransferRecurringInstruction(input, config) {
   if (!accounts.selfProgram.value) {
     accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
   }
-  const getAccountMeta = getAccountMetaFactory11(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("delegationPda", accounts.delegationPda),
@@ -1898,7 +2019,7 @@ function getTransferRecurringInstruction(input, config) {
 }
 function parseTransferRecurringInstruction(instruction) {
   if (instruction.accounts.length < 8) {
-    throw new SolanaError11(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11, {
+    throw new SolanaError12(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 8
     });
@@ -1927,37 +2048,37 @@ function parseTransferRecurringInstruction(instruction) {
 
 // src/generated/instructions/transferSubscription.ts
 import {
-  combineCodec as combineCodec28,
-  getStructDecoder as getStructDecoder26,
-  getStructEncoder as getStructEncoder26,
-  getU8Decoder as getU8Decoder17,
-  getU8Encoder as getU8Encoder17,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
-  SolanaError as SolanaError12,
-  transformEncoder as transformEncoder12
+  combineCodec as combineCodec29,
+  getStructDecoder as getStructDecoder27,
+  getStructEncoder as getStructEncoder27,
+  getU8Decoder as getU8Decoder18,
+  getU8Encoder as getU8Encoder18,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
+  SolanaError as SolanaError13,
+  transformEncoder as transformEncoder13
 } from "@solana/kit";
-import { getAccountMetaFactory as getAccountMetaFactory12 } from "@solana/program-client-core";
+import { getAccountMetaFactory as getAccountMetaFactory13 } from "@solana/program-client-core";
 var TRANSFER_SUBSCRIPTION_DISCRIMINATOR = 10;
 function getTransferSubscriptionDiscriminatorBytes() {
-  return getU8Encoder17().encode(TRANSFER_SUBSCRIPTION_DISCRIMINATOR);
+  return getU8Encoder18().encode(TRANSFER_SUBSCRIPTION_DISCRIMINATOR);
 }
 function getTransferSubscriptionInstructionDataEncoder() {
-  return transformEncoder12(
-    getStructEncoder26([
-      ["discriminator", getU8Encoder17()],
+  return transformEncoder13(
+    getStructEncoder27([
+      ["discriminator", getU8Encoder18()],
       ["transferData", getTransferDataEncoder()]
     ]),
     (value) => ({ ...value, discriminator: TRANSFER_SUBSCRIPTION_DISCRIMINATOR })
   );
 }
 function getTransferSubscriptionInstructionDataDecoder() {
-  return getStructDecoder26([
-    ["discriminator", getU8Decoder17()],
+  return getStructDecoder27([
+    ["discriminator", getU8Decoder18()],
     ["transferData", getTransferDataDecoder()]
   ]);
 }
 function getTransferSubscriptionInstructionDataCodec() {
-  return combineCodec28(
+  return combineCodec29(
     getTransferSubscriptionInstructionDataEncoder(),
     getTransferSubscriptionInstructionDataDecoder()
   );
@@ -1983,7 +2104,7 @@ function getTransferSubscriptionInstruction(input, config) {
   if (!accounts.selfProgram.value) {
     accounts.selfProgram.value = "De1egAFMkMWZSN5rYXRj9CAdheBamobVNubTsi9avR44";
   }
-  const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory13(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("subscriptionPda", accounts.subscriptionPda),
@@ -2002,7 +2123,7 @@ function getTransferSubscriptionInstruction(input, config) {
 }
 function parseTransferSubscriptionInstruction(instruction) {
   if (instruction.accounts.length < 9) {
-    throw new SolanaError12(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12, {
+    throw new SolanaError13(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 9
     });
@@ -2032,37 +2153,37 @@ function parseTransferSubscriptionInstruction(instruction) {
 
 // src/generated/instructions/updatePlan.ts
 import {
-  combineCodec as combineCodec29,
-  getStructDecoder as getStructDecoder27,
-  getStructEncoder as getStructEncoder27,
-  getU8Decoder as getU8Decoder18,
-  getU8Encoder as getU8Encoder18,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
-  SolanaError as SolanaError13,
-  transformEncoder as transformEncoder13
+  combineCodec as combineCodec30,
+  getStructDecoder as getStructDecoder28,
+  getStructEncoder as getStructEncoder28,
+  getU8Decoder as getU8Decoder19,
+  getU8Encoder as getU8Encoder19,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14,
+  SolanaError as SolanaError14,
+  transformEncoder as transformEncoder14
 } from "@solana/kit";
-import { getAccountMetaFactory as getAccountMetaFactory13 } from "@solana/program-client-core";
+import { getAccountMetaFactory as getAccountMetaFactory14 } from "@solana/program-client-core";
 var UPDATE_PLAN_DISCRIMINATOR = 8;
 function getUpdatePlanDiscriminatorBytes() {
-  return getU8Encoder18().encode(UPDATE_PLAN_DISCRIMINATOR);
+  return getU8Encoder19().encode(UPDATE_PLAN_DISCRIMINATOR);
 }
 function getUpdatePlanInstructionDataEncoder() {
-  return transformEncoder13(
-    getStructEncoder27([
-      ["discriminator", getU8Encoder18()],
+  return transformEncoder14(
+    getStructEncoder28([
+      ["discriminator", getU8Encoder19()],
       ["updatePlanData", getUpdatePlanDataEncoder()]
     ]),
     (value) => ({ ...value, discriminator: UPDATE_PLAN_DISCRIMINATOR })
   );
 }
 function getUpdatePlanInstructionDataDecoder() {
-  return getStructDecoder27([
-    ["discriminator", getU8Decoder18()],
+  return getStructDecoder28([
+    ["discriminator", getU8Decoder19()],
     ["updatePlanData", getUpdatePlanDataDecoder()]
   ]);
 }
 function getUpdatePlanInstructionDataCodec() {
-  return combineCodec29(getUpdatePlanInstructionDataEncoder(), getUpdatePlanInstructionDataDecoder());
+  return combineCodec30(getUpdatePlanInstructionDataEncoder(), getUpdatePlanInstructionDataDecoder());
 }
 function getUpdatePlanInstruction(input, config) {
   const programAddress = config?.programAddress ?? SUBSCRIPTIONS_PROGRAM_ADDRESS;
@@ -2072,7 +2193,7 @@ function getUpdatePlanInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory13(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory14(programAddress, "programId");
   return Object.freeze({
     accounts: [getAccountMeta("owner", accounts.owner), getAccountMeta("planPda", accounts.planPda)],
     data: getUpdatePlanInstructionDataEncoder().encode(args),
@@ -2081,7 +2202,7 @@ function getUpdatePlanInstruction(input, config) {
 }
 function parseUpdatePlanInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError13(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13, {
+    throw new SolanaError14(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14, {
       actualAccountMetas: instruction.accounts.length,
       expectedAccountMetas: 2
     });
@@ -2124,50 +2245,54 @@ var SubscriptionsInstruction = /* @__PURE__ */ ((SubscriptionsInstruction2) => {
   SubscriptionsInstruction2[SubscriptionsInstruction2["TransferSubscription"] = 10] = "TransferSubscription";
   SubscriptionsInstruction2[SubscriptionsInstruction2["Subscribe"] = 11] = "Subscribe";
   SubscriptionsInstruction2[SubscriptionsInstruction2["CancelSubscription"] = 12] = "CancelSubscription";
+  SubscriptionsInstruction2[SubscriptionsInstruction2["ResumeSubscription"] = 13] = "ResumeSubscription";
   return SubscriptionsInstruction2;
 })(SubscriptionsInstruction || {});
 function identifySubscriptionsInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
-  if (containsBytes(data, getU8Encoder19().encode(0), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(0), 0)) {
     return 0 /* InitSubscriptionAuthority */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(1), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(1), 0)) {
     return 1 /* CreateFixedDelegation */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(2), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(2), 0)) {
     return 2 /* CreateRecurringDelegation */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(3), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(3), 0)) {
     return 3 /* RevokeDelegation */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(4), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(4), 0)) {
     return 4 /* TransferFixed */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(5), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(5), 0)) {
     return 5 /* TransferRecurring */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(6), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(6), 0)) {
     return 6 /* CloseSubscriptionAuthority */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(7), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(7), 0)) {
     return 7 /* CreatePlan */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(8), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(8), 0)) {
     return 8 /* UpdatePlan */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(9), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(9), 0)) {
     return 9 /* DeletePlan */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(10), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(10), 0)) {
     return 10 /* TransferSubscription */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(11), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(11), 0)) {
     return 11 /* Subscribe */;
   }
-  if (containsBytes(data, getU8Encoder19().encode(12), 0)) {
+  if (containsBytes(data, getU8Encoder20().encode(12), 0)) {
     return 12 /* CancelSubscription */;
   }
-  throw new SolanaError14(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+  if (containsBytes(data, getU8Encoder20().encode(13), 0)) {
+    return 13 /* ResumeSubscription */;
+  }
+  throw new SolanaError15(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
     instructionData: data,
     programName: "subscriptions"
   });
@@ -2254,8 +2379,15 @@ function parseSubscriptionsInstruction(instruction) {
         ...parseCancelSubscriptionInstruction(instruction)
       };
     }
+    case 13 /* ResumeSubscription */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 13 /* ResumeSubscription */,
+        ...parseResumeSubscriptionInstruction(instruction)
+      };
+    }
     default:
-      throw new SolanaError14(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+      throw new SolanaError15(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
         instructionType,
         programName: "subscriptions"
       });
@@ -2286,7 +2418,8 @@ function subscriptionsProgram() {
           deletePlan: (input) => addSelfPlanAndSendFunctions(client, getDeletePlanInstruction(input)),
           transferSubscription: (input) => addSelfPlanAndSendFunctions(client, getTransferSubscriptionInstruction(input)),
           subscribe: (input) => addSelfPlanAndSendFunctions(client, getSubscribeInstructionAsync(input)),
-          cancelSubscription: (input) => addSelfPlanAndSendFunctions(client, getCancelSubscriptionInstructionAsync(input))
+          cancelSubscription: (input) => addSelfPlanAndSendFunctions(client, getCancelSubscriptionInstructionAsync(input)),
+          resumeSubscription: (input) => addSelfPlanAndSendFunctions(client, getResumeSubscriptionInstructionAsync(input))
         },
         pdas: {
           fixedDelegation: findFixedDelegationPda,
@@ -2444,7 +2577,7 @@ if (process.env["NODE_ENV"] !== "production") {
     [SUBSCRIPTIONS_ERROR__STALE_SUBSCRIPTION_AUTHORITY]: `Delegation init_id does not match current SubscriptionAuthority`,
     [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_ALREADY_CANCELLED]: `Subscription already cancelled`,
     [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_CANCELLED]: `Subscription cancelled and past valid period`,
-    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED]: `Subscription must be cancelled before revoke`,
+    [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_NOT_CANCELLED]: `Subscription is not cancelled`,
     [SUBSCRIPTIONS_ERROR__SUBSCRIPTION_PLAN_MISMATCH]: `Subscription does not belong to this plan`,
     [SUBSCRIPTIONS_ERROR__SUNSET_REQUIRES_END_TS]: `Sunset requires a non-zero end timestamp`,
     [SUBSCRIPTIONS_ERROR__UNAUTHORIZED]: `Caller not authorized for this action`,
@@ -2941,6 +3074,16 @@ function getCancelSubscriptionOverlayInstructionAsync(input) {
     pdaConfig(input.programAddress)
   );
 }
+function getResumeSubscriptionOverlayInstructionAsync(input) {
+  return getResumeSubscriptionInstructionAsync(
+    {
+      planPda: input.planPda,
+      subscriber: input.subscriber,
+      subscriptionPda: input.subscriptionPda
+    },
+    pdaConfig(input.programAddress)
+  );
+}
 function subscriptionsProgram2() {
   return (client) => {
     return pipe(client, subscriptionsProgram(), (c) => {
@@ -3019,6 +3162,13 @@ function subscriptionsProgram2() {
             payer: input.payer ?? (client.payer === client.identity ? void 0 : client.payer)
           })
         ),
+        resumeSubscription: (input) => addSelfPlanAndSendFunctions2(
+          client,
+          getResumeSubscriptionOverlayInstructionAsync({
+            ...input,
+            subscriber: input.subscriber ?? client.identity
+          })
+        ),
         revokeDelegation: (input) => addSelfPlanAndSendFunctions2(
           client,
           getRevokeDelegationOverlayInstruction({
@@ -3129,6 +3279,7 @@ export {
   PLAN_SIZE,
   PROGRAM_ID,
   PlanStatus,
+  RESUME_SUBSCRIPTION_DISCRIMINATOR,
   REVOKE_DELEGATION_DISCRIMINATOR,
   SUBSCRIBE_DISCRIMINATOR,
   SUBSCRIPTIONS_ERROR__ACCOUNT_NOT_WRITABLE,
@@ -3346,6 +3497,13 @@ export {
   getRecurringDelegationCodec,
   getRecurringDelegationDecoder,
   getRecurringDelegationEncoder,
+  getResumeSubscriptionDiscriminatorBytes,
+  getResumeSubscriptionInstruction,
+  getResumeSubscriptionInstructionAsync,
+  getResumeSubscriptionInstructionDataCodec,
+  getResumeSubscriptionInstructionDataDecoder,
+  getResumeSubscriptionInstructionDataEncoder,
+  getResumeSubscriptionOverlayInstructionAsync,
   getRevokeDelegationDiscriminatorBytes,
   getRevokeDelegationInstruction,
   getRevokeDelegationInstructionDataCodec,
@@ -3409,6 +3567,7 @@ export {
   parseCreateRecurringDelegationInstruction,
   parseDeletePlanInstruction,
   parseInitSubscriptionAuthorityInstruction,
+  parseResumeSubscriptionInstruction,
   parseRevokeDelegationInstruction,
   parseSubscribeInstruction,
   parseSubscriptionsInstruction,