@solana/token-acl-gate-sdk 0.0.0 → 0.3.0

package/dist/src/index.mjs

@@ -0,0 +1,838 @@
+import { getProgramDerivedAddress, getUtf8Encoder, getAddressEncoder, getU8Encoder, transformEncoder, getStructEncoder, getU64Encoder, getStructDecoder, getU8Decoder, getAddressDecoder, getU64Decoder, combineCodec, decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts, containsBytes, AccountRole, getEnumEncoder, getEnumDecoder, upgradeRoleToSigner, isTransactionSigner as isTransactionSigner$1 } from '@solana/kit';
+
+// src/generated/accounts/listConfig.ts
+async function findListConfigPda(seeds, config = {}) {
+  const {
+    programAddress = "GATEzzqxhJnsWF6vHRsgtixxSB8PaQdcqGEVTEHWiULz"
+  } = config;
+  return await getProgramDerivedAddress({
+    programAddress,
+    seeds: [
+      getUtf8Encoder().encode("list_config"),
+      getAddressEncoder().encode(seeds.authority),
+      getAddressEncoder().encode(seeds.seed)
+    ]
+  });
+}
+async function findWalletEntryPda(seeds, config = {}) {
+  const {
+    programAddress = "GATEzzqxhJnsWF6vHRsgtixxSB8PaQdcqGEVTEHWiULz"
+  } = config;
+  return await getProgramDerivedAddress({
+    programAddress,
+    seeds: [
+      getUtf8Encoder().encode("wallet_entry"),
+      getAddressEncoder().encode(seeds.listConfig),
+      getAddressEncoder().encode(seeds.wallet)
+    ]
+  });
+}
+
+// src/generated/accounts/listConfig.ts
+var LIST_CONFIG_DISCRIMINATOR = 1;
+function getListConfigDiscriminatorBytes() {
+  return getU8Encoder().encode(LIST_CONFIG_DISCRIMINATOR);
+}
+function getListConfigEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", getU8Encoder()],
+      ["authority", getAddressEncoder()],
+      ["seed", getAddressEncoder()],
+      ["mode", getU8Encoder()],
+      ["walletsCount", getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: value.discriminator ?? LIST_CONFIG_DISCRIMINATOR
+    })
+  );
+}
+function getListConfigDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU8Decoder()],
+    ["authority", getAddressDecoder()],
+    ["seed", getAddressDecoder()],
+    ["mode", getU8Decoder()],
+    ["walletsCount", getU64Decoder()]
+  ]);
+}
+function getListConfigCodec() {
+  return combineCodec(getListConfigEncoder(), getListConfigDecoder());
+}
+function decodeListConfig(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getListConfigDecoder()
+  );
+}
+async function fetchListConfig(rpc, address, config) {
+  const maybeAccount = await fetchMaybeListConfig(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeListConfig(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeListConfig(maybeAccount);
+}
+async function fetchAllListConfig(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeListConfig(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeListConfig(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeListConfig(maybeAccount));
+}
+function getListConfigSize() {
+  return 74;
+}
+async function fetchListConfigFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeListConfigFromSeeds(rpc, seeds, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeListConfigFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findListConfigPda(seeds, { programAddress });
+  return await fetchMaybeListConfig(rpc, address, fetchConfig);
+}
+var WALLET_ENTRY_DISCRIMINATOR = 2;
+function getWalletEntryDiscriminatorBytes() {
+  return getU8Encoder().encode(WALLET_ENTRY_DISCRIMINATOR);
+}
+function getWalletEntryEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", getU8Encoder()],
+      ["walletAddress", getAddressEncoder()],
+      ["listConfig", getAddressEncoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: value.discriminator ?? WALLET_ENTRY_DISCRIMINATOR
+    })
+  );
+}
+function getWalletEntryDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU8Decoder()],
+    ["walletAddress", getAddressDecoder()],
+    ["listConfig", getAddressDecoder()]
+  ]);
+}
+function getWalletEntryCodec() {
+  return combineCodec(getWalletEntryEncoder(), getWalletEntryDecoder());
+}
+function decodeWalletEntry(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getWalletEntryDecoder()
+  );
+}
+async function fetchWalletEntry(rpc, address, config) {
+  const maybeAccount = await fetchMaybeWalletEntry(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeWalletEntry(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeWalletEntry(maybeAccount);
+}
+async function fetchAllWalletEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeWalletEntry(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeWalletEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeWalletEntry(maybeAccount));
+}
+function getWalletEntrySize() {
+  return 65;
+}
+async function fetchWalletEntryFromSeeds(rpc, seeds, config = {}) {
+  const maybeAccount = await fetchMaybeWalletEntryFromSeeds(rpc, seeds, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeWalletEntryFromSeeds(rpc, seeds, config = {}) {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findWalletEntryPda(seeds, { programAddress });
+  return await fetchMaybeWalletEntry(rpc, address, fetchConfig);
+}
+var TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS = "GATEzzqxhJnsWF6vHRsgtixxSB8PaQdcqGEVTEHWiULz";
+var TokenAclGateProgramAccount = /* @__PURE__ */ ((TokenAclGateProgramAccount2) => {
+  TokenAclGateProgramAccount2[TokenAclGateProgramAccount2["ListConfig"] = 0] = "ListConfig";
+  TokenAclGateProgramAccount2[TokenAclGateProgramAccount2["WalletEntry"] = 1] = "WalletEntry";
+  return TokenAclGateProgramAccount2;
+})(TokenAclGateProgramAccount || {});
+function identifyTokenAclGateProgramAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if (containsBytes(data, getU8Encoder().encode(1), 0)) {
+    return 0 /* ListConfig */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(2), 0)) {
+    return 1 /* WalletEntry */;
+  }
+  throw new Error(
+    "The provided account could not be identified as a tokenAclGateProgram account."
+  );
+}
+var TokenAclGateProgramInstruction = /* @__PURE__ */ ((TokenAclGateProgramInstruction2) => {
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["CreateList"] = 0] = "CreateList";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["AddWallet"] = 1] = "AddWallet";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["RemoveWallet"] = 2] = "RemoveWallet";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["SetupExtraMetas"] = 3] = "SetupExtraMetas";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["DeleteList"] = 4] = "DeleteList";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["SetupFreezeExtraMetas"] = 5] = "SetupFreezeExtraMetas";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["CanThawPermissionless"] = 6] = "CanThawPermissionless";
+  TokenAclGateProgramInstruction2[TokenAclGateProgramInstruction2["CanFreezePermissionless"] = 7] = "CanFreezePermissionless";
+  return TokenAclGateProgramInstruction2;
+})(TokenAclGateProgramInstruction || {});
+function identifyTokenAclGateProgramInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (containsBytes(data, getU8Encoder().encode(1), 0)) {
+    return 0 /* CreateList */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(2), 0)) {
+    return 1 /* AddWallet */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(3), 0)) {
+    return 2 /* RemoveWallet */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(4), 0)) {
+    return 3 /* SetupExtraMetas */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(5), 0)) {
+    return 4 /* DeleteList */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(6), 0)) {
+    return 5 /* SetupFreezeExtraMetas */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(8), 0)) {
+    return 6 /* CanThawPermissionless */;
+  }
+  if (containsBytes(data, getU8Encoder().encode(214), 0)) {
+    return 7 /* CanFreezePermissionless */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a tokenAclGateProgram instruction."
+  );
+}
+function expectAddress(value) {
+  if (!value) {
+    throw new Error("Expected a Address.");
+  }
+  if (typeof value === "object" && "address" in value) {
+    return value.address;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (account) => {
+    if (!account.value) {
+      return Object.freeze({
+        address: programAddress,
+        role: AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && isTransactionSigner$1(value);
+}
+
+// src/generated/instructions/addWallet.ts
+var ADD_WALLET_DISCRIMINATOR = 2;
+function getAddWalletDiscriminatorBytes() {
+  return getU8Encoder().encode(ADD_WALLET_DISCRIMINATOR);
+}
+function getAddWalletInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: ADD_WALLET_DISCRIMINATOR })
+  );
+}
+function getAddWalletInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getAddWalletInstructionDataCodec() {
+  return combineCodec(
+    getAddWalletInstructionDataEncoder(),
+    getAddWalletInstructionDataDecoder()
+  );
+}
+function getAddWalletInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    listConfig: { value: input.listConfig ?? null, isWritable: true },
+    wallet: { value: input.wallet ?? null, isWritable: false },
+    walletEntry: { value: input.walletEntry ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.listConfig),
+      getAccountMeta(accounts.wallet),
+      getAccountMeta(accounts.walletEntry),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getAddWalletInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseAddWalletInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      payer: getNextAccount(),
+      listConfig: getNextAccount(),
+      wallet: getNextAccount(),
+      walletEntry: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getAddWalletInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR = 214;
+function getCanFreezePermissionlessDiscriminatorBytes() {
+  return getU8Encoder().encode(CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR);
+}
+function getCanFreezePermissionlessInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR
+    })
+  );
+}
+function getCanFreezePermissionlessInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getCanFreezePermissionlessInstructionDataCodec() {
+  return combineCodec(
+    getCanFreezePermissionlessInstructionDataEncoder(),
+    getCanFreezePermissionlessInstructionDataDecoder()
+  );
+}
+function getCanFreezePermissionlessInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    tokenAccount: { value: input.tokenAccount ?? null, isWritable: false },
+    mint: { value: input.mint ?? null, isWritable: false },
+    owner: { value: input.owner ?? null, isWritable: false },
+    flagAccount: { value: input.flagAccount ?? null, isWritable: false },
+    extraMetas: { value: input.extraMetas ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.tokenAccount),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.flagAccount),
+      getAccountMeta(accounts.extraMetas)
+    ],
+    data: getCanFreezePermissionlessInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseCanFreezePermissionlessInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      tokenAccount: getNextAccount(),
+      mint: getNextAccount(),
+      owner: getNextAccount(),
+      flagAccount: getNextAccount(),
+      extraMetas: getNextAccount()
+    },
+    data: getCanFreezePermissionlessInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var CAN_THAW_PERMISSIONLESS_DISCRIMINATOR = 8;
+function getCanThawPermissionlessDiscriminatorBytes() {
+  return getU8Encoder().encode(CAN_THAW_PERMISSIONLESS_DISCRIMINATOR);
+}
+function getCanThawPermissionlessInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: CAN_THAW_PERMISSIONLESS_DISCRIMINATOR
+    })
+  );
+}
+function getCanThawPermissionlessInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getCanThawPermissionlessInstructionDataCodec() {
+  return combineCodec(
+    getCanThawPermissionlessInstructionDataEncoder(),
+    getCanThawPermissionlessInstructionDataDecoder()
+  );
+}
+function getCanThawPermissionlessInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    tokenAccount: { value: input.tokenAccount ?? null, isWritable: false },
+    mint: { value: input.mint ?? null, isWritable: false },
+    owner: { value: input.owner ?? null, isWritable: false },
+    flagAccount: { value: input.flagAccount ?? null, isWritable: false },
+    extraMetas: { value: input.extraMetas ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const remainingAccounts = args.addresses.map((address) => ({
+    address,
+    role: AccountRole.READONLY
+  }));
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.tokenAccount),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.flagAccount),
+      getAccountMeta(accounts.extraMetas),
+      ...remainingAccounts
+    ],
+    data: getCanThawPermissionlessInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseCanThawPermissionlessInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      tokenAccount: getNextAccount(),
+      mint: getNextAccount(),
+      owner: getNextAccount(),
+      flagAccount: getNextAccount(),
+      extraMetas: getNextAccount()
+    },
+    data: getCanThawPermissionlessInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["Allow"] = 0] = "Allow";
+  Mode2[Mode2["Unused"] = 1] = "Unused";
+  Mode2[Mode2["Block"] = 2] = "Block";
+  return Mode2;
+})(Mode || {});
+function getModeEncoder() {
+  return getEnumEncoder(Mode);
+}
+function getModeDecoder() {
+  return getEnumDecoder(Mode);
+}
+function getModeCodec() {
+  return combineCodec(getModeEncoder(), getModeDecoder());
+}
+
+// src/generated/instructions/createList.ts
+var CREATE_LIST_DISCRIMINATOR = 1;
+function getCreateListDiscriminatorBytes() {
+  return getU8Encoder().encode(CREATE_LIST_DISCRIMINATOR);
+}
+function getCreateListInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", getU8Encoder()],
+      ["mode", getModeEncoder()],
+      ["seed", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_LIST_DISCRIMINATOR })
+  );
+}
+function getCreateListInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU8Decoder()],
+    ["mode", getModeDecoder()],
+    ["seed", getAddressDecoder()]
+  ]);
+}
+function getCreateListInstructionDataCodec() {
+  return combineCodec(
+    getCreateListInstructionDataEncoder(),
+    getCreateListInstructionDataDecoder()
+  );
+}
+function getCreateListInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    listConfig: { value: input.listConfig ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.listConfig),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCreateListInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCreateListInstruction(instruction) {
+  if (instruction.accounts.length < 4) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      payer: getNextAccount(),
+      listConfig: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreateListInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var DELETE_LIST_DISCRIMINATOR = 5;
+function getDeleteListDiscriminatorBytes() {
+  return getU8Encoder().encode(DELETE_LIST_DISCRIMINATOR);
+}
+function getDeleteListInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: DELETE_LIST_DISCRIMINATOR })
+  );
+}
+function getDeleteListInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getDeleteListInstructionDataCodec() {
+  return combineCodec(
+    getDeleteListInstructionDataEncoder(),
+    getDeleteListInstructionDataDecoder()
+  );
+}
+function getDeleteListInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    listConfig: { value: input.listConfig ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.listConfig)
+    ],
+    data: getDeleteListInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseDeleteListInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { authority: getNextAccount(), listConfig: getNextAccount() },
+    data: getDeleteListInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var REMOVE_WALLET_DISCRIMINATOR = 3;
+function getRemoveWalletDiscriminatorBytes() {
+  return getU8Encoder().encode(REMOVE_WALLET_DISCRIMINATOR);
+}
+function getRemoveWalletInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: REMOVE_WALLET_DISCRIMINATOR })
+  );
+}
+function getRemoveWalletInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getRemoveWalletInstructionDataCodec() {
+  return combineCodec(
+    getRemoveWalletInstructionDataEncoder(),
+    getRemoveWalletInstructionDataDecoder()
+  );
+}
+function getRemoveWalletInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    listConfig: { value: input.listConfig ?? null, isWritable: true },
+    walletEntry: { value: input.walletEntry ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.listConfig),
+      getAccountMeta(accounts.walletEntry)
+    ],
+    data: getRemoveWalletInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseRemoveWalletInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      listConfig: getNextAccount(),
+      walletEntry: getNextAccount()
+    },
+    data: getRemoveWalletInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SETUP_EXTRA_METAS_DISCRIMINATOR = 4;
+function getSetupExtraMetasDiscriminatorBytes() {
+  return getU8Encoder().encode(SETUP_EXTRA_METAS_DISCRIMINATOR);
+}
+function getSetupExtraMetasInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: SETUP_EXTRA_METAS_DISCRIMINATOR })
+  );
+}
+function getSetupExtraMetasInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getSetupExtraMetasInstructionDataCodec() {
+  return combineCodec(
+    getSetupExtraMetasInstructionDataEncoder(),
+    getSetupExtraMetasInstructionDataDecoder()
+  );
+}
+function getSetupExtraMetasInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenAclMintConfig: {
+      value: input.tokenAclMintConfig ?? null,
+      isWritable: false
+    },
+    mint: { value: input.mint ?? null, isWritable: false },
+    extraMetas: { value: input.extraMetas ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const remainingAccounts = args.addresses.map((address) => ({
+    address,
+    role: AccountRole.READONLY
+  }));
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.tokenAclMintConfig),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.extraMetas),
+      getAccountMeta(accounts.systemProgram),
+      ...remainingAccounts
+    ],
+    data: getSetupExtraMetasInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseSetupExtraMetasInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      payer: getNextAccount(),
+      tokenAclMintConfig: getNextAccount(),
+      mint: getNextAccount(),
+      extraMetas: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getSetupExtraMetasInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR = 6;
+function getSetupFreezeExtraMetasDiscriminatorBytes() {
+  return getU8Encoder().encode(SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR);
+}
+function getSetupFreezeExtraMetasInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR
+    })
+  );
+}
+function getSetupFreezeExtraMetasInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+function getSetupFreezeExtraMetasInstructionDataCodec() {
+  return combineCodec(
+    getSetupFreezeExtraMetasInstructionDataEncoder(),
+    getSetupFreezeExtraMetasInstructionDataDecoder()
+  );
+}
+function getSetupFreezeExtraMetasInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenAclMintConfig: {
+      value: input.tokenAclMintConfig ?? null,
+      isWritable: false
+    },
+    mint: { value: input.mint ?? null, isWritable: false },
+    extraMetas: { value: input.extraMetas ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.tokenAclMintConfig),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.extraMetas),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getSetupFreezeExtraMetasInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseSetupFreezeExtraMetasInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      payer: getNextAccount(),
+      tokenAclMintConfig: getNextAccount(),
+      mint: getNextAccount(),
+      extraMetas: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getSetupFreezeExtraMetasInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+export { ADD_WALLET_DISCRIMINATOR, CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR, CAN_THAW_PERMISSIONLESS_DISCRIMINATOR, CREATE_LIST_DISCRIMINATOR, DELETE_LIST_DISCRIMINATOR, LIST_CONFIG_DISCRIMINATOR, Mode, REMOVE_WALLET_DISCRIMINATOR, SETUP_EXTRA_METAS_DISCRIMINATOR, SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR, TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS, TokenAclGateProgramAccount, TokenAclGateProgramInstruction, WALLET_ENTRY_DISCRIMINATOR, decodeListConfig, decodeWalletEntry, fetchAllListConfig, fetchAllMaybeListConfig, fetchAllMaybeWalletEntry, fetchAllWalletEntry, fetchListConfig, fetchListConfigFromSeeds, fetchMaybeListConfig, fetchMaybeListConfigFromSeeds, fetchMaybeWalletEntry, fetchMaybeWalletEntryFromSeeds, fetchWalletEntry, fetchWalletEntryFromSeeds, findListConfigPda, findWalletEntryPda, getAddWalletDiscriminatorBytes, getAddWalletInstruction, getAddWalletInstructionDataCodec, getAddWalletInstructionDataDecoder, getAddWalletInstructionDataEncoder, getCanFreezePermissionlessDiscriminatorBytes, getCanFreezePermissionlessInstruction, getCanFreezePermissionlessInstructionDataCodec, getCanFreezePermissionlessInstructionDataDecoder, getCanFreezePermissionlessInstructionDataEncoder, getCanThawPermissionlessDiscriminatorBytes, getCanThawPermissionlessInstruction, getCanThawPermissionlessInstructionDataCodec, getCanThawPermissionlessInstructionDataDecoder, getCanThawPermissionlessInstructionDataEncoder, getCreateListDiscriminatorBytes, getCreateListInstruction, getCreateListInstructionDataCodec, getCreateListInstructionDataDecoder, getCreateListInstructionDataEncoder, getDeleteListDiscriminatorBytes, getDeleteListInstruction, getDeleteListInstructionDataCodec, getDeleteListInstructionDataDecoder, getDeleteListInstructionDataEncoder, getListConfigCodec, getListConfigDecoder, getListConfigDiscriminatorBytes, getListConfigEncoder, getListConfigSize, getModeCodec, getModeDecoder, getModeEncoder, getRemoveWalletDiscriminatorBytes, getRemoveWalletInstruction, getRemoveWalletInstructionDataCodec, getRemoveWalletInstructionDataDecoder, getRemoveWalletInstructionDataEncoder, getSetupExtraMetasDiscriminatorBytes, getSetupExtraMetasInstruction, getSetupExtraMetasInstructionDataCodec, getSetupExtraMetasInstructionDataDecoder, getSetupExtraMetasInstructionDataEncoder, getSetupFreezeExtraMetasDiscriminatorBytes, getSetupFreezeExtraMetasInstruction, getSetupFreezeExtraMetasInstructionDataCodec, getSetupFreezeExtraMetasInstructionDataDecoder, getSetupFreezeExtraMetasInstructionDataEncoder, getWalletEntryCodec, getWalletEntryDecoder, getWalletEntryDiscriminatorBytes, getWalletEntryEncoder, getWalletEntrySize, identifyTokenAclGateProgramAccount, identifyTokenAclGateProgramInstruction, parseAddWalletInstruction, parseCanFreezePermissionlessInstruction, parseCanThawPermissionlessInstruction, parseCreateListInstruction, parseDeleteListInstruction, parseRemoveWalletInstruction, parseSetupExtraMetasInstruction, parseSetupFreezeExtraMetasInstruction };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map