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

package/dist/src/index.js

@@ -0,0 +1,932 @@
+'use strict';
+
+var kit = require('@solana/kit');
+
+// src/generated/accounts/listConfig.ts
+async function findListConfigPda(seeds, config = {}) {
+  const {
+    programAddress = "GATEzzqxhJnsWF6vHRsgtixxSB8PaQdcqGEVTEHWiULz"
+  } = config;
+  return await kit.getProgramDerivedAddress({
+    programAddress,
+    seeds: [
+      kit.getUtf8Encoder().encode("list_config"),
+      kit.getAddressEncoder().encode(seeds.authority),
+      kit.getAddressEncoder().encode(seeds.seed)
+    ]
+  });
+}
+async function findWalletEntryPda(seeds, config = {}) {
+  const {
+    programAddress = "GATEzzqxhJnsWF6vHRsgtixxSB8PaQdcqGEVTEHWiULz"
+  } = config;
+  return await kit.getProgramDerivedAddress({
+    programAddress,
+    seeds: [
+      kit.getUtf8Encoder().encode("wallet_entry"),
+      kit.getAddressEncoder().encode(seeds.listConfig),
+      kit.getAddressEncoder().encode(seeds.wallet)
+    ]
+  });
+}
+
+// src/generated/accounts/listConfig.ts
+var LIST_CONFIG_DISCRIMINATOR = 1;
+function getListConfigDiscriminatorBytes() {
+  return kit.getU8Encoder().encode(LIST_CONFIG_DISCRIMINATOR);
+}
+function getListConfigEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.getU8Encoder()],
+      ["authority", kit.getAddressEncoder()],
+      ["seed", kit.getAddressEncoder()],
+      ["mode", kit.getU8Encoder()],
+      ["walletsCount", kit.getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: value.discriminator ?? LIST_CONFIG_DISCRIMINATOR
+    })
+  );
+}
+function getListConfigDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.getU8Decoder()],
+    ["authority", kit.getAddressDecoder()],
+    ["seed", kit.getAddressDecoder()],
+    ["mode", kit.getU8Decoder()],
+    ["walletsCount", kit.getU64Decoder()]
+  ]);
+}
+function getListConfigCodec() {
+  return kit.combineCodec(getListConfigEncoder(), getListConfigDecoder());
+}
+function decodeListConfig(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getListConfigDecoder()
+  );
+}
+async function fetchListConfig(rpc, address, config) {
+  const maybeAccount = await fetchMaybeListConfig(rpc, address, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeListConfig(rpc, address, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
+  return decodeListConfig(maybeAccount);
+}
+async function fetchAllListConfig(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeListConfig(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeListConfig(rpc, addresses, config) {
+  const maybeAccounts = await kit.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);
+  kit.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 kit.getU8Encoder().encode(WALLET_ENTRY_DISCRIMINATOR);
+}
+function getWalletEntryEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.getU8Encoder()],
+      ["walletAddress", kit.getAddressEncoder()],
+      ["listConfig", kit.getAddressEncoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: value.discriminator ?? WALLET_ENTRY_DISCRIMINATOR
+    })
+  );
+}
+function getWalletEntryDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.getU8Decoder()],
+    ["walletAddress", kit.getAddressDecoder()],
+    ["listConfig", kit.getAddressDecoder()]
+  ]);
+}
+function getWalletEntryCodec() {
+  return kit.combineCodec(getWalletEntryEncoder(), getWalletEntryDecoder());
+}
+function decodeWalletEntry(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getWalletEntryDecoder()
+  );
+}
+async function fetchWalletEntry(rpc, address, config) {
+  const maybeAccount = await fetchMaybeWalletEntry(rpc, address, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeWalletEntry(rpc, address, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
+  return decodeWalletEntry(maybeAccount);
+}
+async function fetchAllWalletEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeWalletEntry(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeWalletEntry(rpc, addresses, config) {
+  const maybeAccounts = await kit.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);
+  kit.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 (kit.containsBytes(data, kit.getU8Encoder().encode(1), 0)) {
+    return 0 /* ListConfig */;
+  }
+  if (kit.containsBytes(data, kit.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 (kit.containsBytes(data, kit.getU8Encoder().encode(1), 0)) {
+    return 0 /* CreateList */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(2), 0)) {
+    return 1 /* AddWallet */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(3), 0)) {
+    return 2 /* RemoveWallet */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(4), 0)) {
+    return 3 /* SetupExtraMetas */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(5), 0)) {
+    return 4 /* DeleteList */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(6), 0)) {
+    return 5 /* SetupFreezeExtraMetas */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(8), 0)) {
+    return 6 /* CanThawPermissionless */;
+  }
+  if (kit.containsBytes(data, kit.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: kit.AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? kit.AccountRole.WRITABLE : kit.AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? kit.upgradeRoleToSigner(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
+}
+
+// src/generated/instructions/addWallet.ts
+var ADD_WALLET_DISCRIMINATOR = 2;
+function getAddWalletDiscriminatorBytes() {
+  return kit.getU8Encoder().encode(ADD_WALLET_DISCRIMINATOR);
+}
+function getAddWalletInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: ADD_WALLET_DISCRIMINATOR })
+  );
+}
+function getAddWalletInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getAddWalletInstructionDataCodec() {
+  return kit.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 kit.getU8Encoder().encode(CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR);
+}
+function getCanFreezePermissionlessInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR
+    })
+  );
+}
+function getCanFreezePermissionlessInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getCanFreezePermissionlessInstructionDataCodec() {
+  return kit.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 kit.getU8Encoder().encode(CAN_THAW_PERMISSIONLESS_DISCRIMINATOR);
+}
+function getCanThawPermissionlessInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: CAN_THAW_PERMISSIONLESS_DISCRIMINATOR
+    })
+  );
+}
+function getCanThawPermissionlessInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getCanThawPermissionlessInstructionDataCodec() {
+  return kit.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: kit.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 kit.getEnumEncoder(Mode);
+}
+function getModeDecoder() {
+  return kit.getEnumDecoder(Mode);
+}
+function getModeCodec() {
+  return kit.combineCodec(getModeEncoder(), getModeDecoder());
+}
+
+// src/generated/instructions/createList.ts
+var CREATE_LIST_DISCRIMINATOR = 1;
+function getCreateListDiscriminatorBytes() {
+  return kit.getU8Encoder().encode(CREATE_LIST_DISCRIMINATOR);
+}
+function getCreateListInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.getU8Encoder()],
+      ["mode", getModeEncoder()],
+      ["seed", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_LIST_DISCRIMINATOR })
+  );
+}
+function getCreateListInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.getU8Decoder()],
+    ["mode", getModeDecoder()],
+    ["seed", kit.getAddressDecoder()]
+  ]);
+}
+function getCreateListInstructionDataCodec() {
+  return kit.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 kit.getU8Encoder().encode(DELETE_LIST_DISCRIMINATOR);
+}
+function getDeleteListInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: DELETE_LIST_DISCRIMINATOR })
+  );
+}
+function getDeleteListInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getDeleteListInstructionDataCodec() {
+  return kit.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 kit.getU8Encoder().encode(REMOVE_WALLET_DISCRIMINATOR);
+}
+function getRemoveWalletInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: REMOVE_WALLET_DISCRIMINATOR })
+  );
+}
+function getRemoveWalletInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getRemoveWalletInstructionDataCodec() {
+  return kit.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 kit.getU8Encoder().encode(SETUP_EXTRA_METAS_DISCRIMINATOR);
+}
+function getSetupExtraMetasInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: SETUP_EXTRA_METAS_DISCRIMINATOR })
+  );
+}
+function getSetupExtraMetasInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getSetupExtraMetasInstructionDataCodec() {
+  return kit.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: kit.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 kit.getU8Encoder().encode(SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR);
+}
+function getSetupFreezeExtraMetasInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR
+    })
+  );
+}
+function getSetupFreezeExtraMetasInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getSetupFreezeExtraMetasInstructionDataCodec() {
+  return kit.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
+    )
+  };
+}
+
+exports.ADD_WALLET_DISCRIMINATOR = ADD_WALLET_DISCRIMINATOR;
+exports.CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR = CAN_FREEZE_PERMISSIONLESS_DISCRIMINATOR;
+exports.CAN_THAW_PERMISSIONLESS_DISCRIMINATOR = CAN_THAW_PERMISSIONLESS_DISCRIMINATOR;
+exports.CREATE_LIST_DISCRIMINATOR = CREATE_LIST_DISCRIMINATOR;
+exports.DELETE_LIST_DISCRIMINATOR = DELETE_LIST_DISCRIMINATOR;
+exports.LIST_CONFIG_DISCRIMINATOR = LIST_CONFIG_DISCRIMINATOR;
+exports.Mode = Mode;
+exports.REMOVE_WALLET_DISCRIMINATOR = REMOVE_WALLET_DISCRIMINATOR;
+exports.SETUP_EXTRA_METAS_DISCRIMINATOR = SETUP_EXTRA_METAS_DISCRIMINATOR;
+exports.SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR = SETUP_FREEZE_EXTRA_METAS_DISCRIMINATOR;
+exports.TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS = TOKEN_ACL_GATE_PROGRAM_PROGRAM_ADDRESS;
+exports.TokenAclGateProgramAccount = TokenAclGateProgramAccount;
+exports.TokenAclGateProgramInstruction = TokenAclGateProgramInstruction;
+exports.WALLET_ENTRY_DISCRIMINATOR = WALLET_ENTRY_DISCRIMINATOR;
+exports.decodeListConfig = decodeListConfig;
+exports.decodeWalletEntry = decodeWalletEntry;
+exports.fetchAllListConfig = fetchAllListConfig;
+exports.fetchAllMaybeListConfig = fetchAllMaybeListConfig;
+exports.fetchAllMaybeWalletEntry = fetchAllMaybeWalletEntry;
+exports.fetchAllWalletEntry = fetchAllWalletEntry;
+exports.fetchListConfig = fetchListConfig;
+exports.fetchListConfigFromSeeds = fetchListConfigFromSeeds;
+exports.fetchMaybeListConfig = fetchMaybeListConfig;
+exports.fetchMaybeListConfigFromSeeds = fetchMaybeListConfigFromSeeds;
+exports.fetchMaybeWalletEntry = fetchMaybeWalletEntry;
+exports.fetchMaybeWalletEntryFromSeeds = fetchMaybeWalletEntryFromSeeds;
+exports.fetchWalletEntry = fetchWalletEntry;
+exports.fetchWalletEntryFromSeeds = fetchWalletEntryFromSeeds;
+exports.findListConfigPda = findListConfigPda;
+exports.findWalletEntryPda = findWalletEntryPda;
+exports.getAddWalletDiscriminatorBytes = getAddWalletDiscriminatorBytes;
+exports.getAddWalletInstruction = getAddWalletInstruction;
+exports.getAddWalletInstructionDataCodec = getAddWalletInstructionDataCodec;
+exports.getAddWalletInstructionDataDecoder = getAddWalletInstructionDataDecoder;
+exports.getAddWalletInstructionDataEncoder = getAddWalletInstructionDataEncoder;
+exports.getCanFreezePermissionlessDiscriminatorBytes = getCanFreezePermissionlessDiscriminatorBytes;
+exports.getCanFreezePermissionlessInstruction = getCanFreezePermissionlessInstruction;
+exports.getCanFreezePermissionlessInstructionDataCodec = getCanFreezePermissionlessInstructionDataCodec;
+exports.getCanFreezePermissionlessInstructionDataDecoder = getCanFreezePermissionlessInstructionDataDecoder;
+exports.getCanFreezePermissionlessInstructionDataEncoder = getCanFreezePermissionlessInstructionDataEncoder;
+exports.getCanThawPermissionlessDiscriminatorBytes = getCanThawPermissionlessDiscriminatorBytes;
+exports.getCanThawPermissionlessInstruction = getCanThawPermissionlessInstruction;
+exports.getCanThawPermissionlessInstructionDataCodec = getCanThawPermissionlessInstructionDataCodec;
+exports.getCanThawPermissionlessInstructionDataDecoder = getCanThawPermissionlessInstructionDataDecoder;
+exports.getCanThawPermissionlessInstructionDataEncoder = getCanThawPermissionlessInstructionDataEncoder;
+exports.getCreateListDiscriminatorBytes = getCreateListDiscriminatorBytes;
+exports.getCreateListInstruction = getCreateListInstruction;
+exports.getCreateListInstructionDataCodec = getCreateListInstructionDataCodec;
+exports.getCreateListInstructionDataDecoder = getCreateListInstructionDataDecoder;
+exports.getCreateListInstructionDataEncoder = getCreateListInstructionDataEncoder;
+exports.getDeleteListDiscriminatorBytes = getDeleteListDiscriminatorBytes;
+exports.getDeleteListInstruction = getDeleteListInstruction;
+exports.getDeleteListInstructionDataCodec = getDeleteListInstructionDataCodec;
+exports.getDeleteListInstructionDataDecoder = getDeleteListInstructionDataDecoder;
+exports.getDeleteListInstructionDataEncoder = getDeleteListInstructionDataEncoder;
+exports.getListConfigCodec = getListConfigCodec;
+exports.getListConfigDecoder = getListConfigDecoder;
+exports.getListConfigDiscriminatorBytes = getListConfigDiscriminatorBytes;
+exports.getListConfigEncoder = getListConfigEncoder;
+exports.getListConfigSize = getListConfigSize;
+exports.getModeCodec = getModeCodec;
+exports.getModeDecoder = getModeDecoder;
+exports.getModeEncoder = getModeEncoder;
+exports.getRemoveWalletDiscriminatorBytes = getRemoveWalletDiscriminatorBytes;
+exports.getRemoveWalletInstruction = getRemoveWalletInstruction;
+exports.getRemoveWalletInstructionDataCodec = getRemoveWalletInstructionDataCodec;
+exports.getRemoveWalletInstructionDataDecoder = getRemoveWalletInstructionDataDecoder;
+exports.getRemoveWalletInstructionDataEncoder = getRemoveWalletInstructionDataEncoder;
+exports.getSetupExtraMetasDiscriminatorBytes = getSetupExtraMetasDiscriminatorBytes;
+exports.getSetupExtraMetasInstruction = getSetupExtraMetasInstruction;
+exports.getSetupExtraMetasInstructionDataCodec = getSetupExtraMetasInstructionDataCodec;
+exports.getSetupExtraMetasInstructionDataDecoder = getSetupExtraMetasInstructionDataDecoder;
+exports.getSetupExtraMetasInstructionDataEncoder = getSetupExtraMetasInstructionDataEncoder;
+exports.getSetupFreezeExtraMetasDiscriminatorBytes = getSetupFreezeExtraMetasDiscriminatorBytes;
+exports.getSetupFreezeExtraMetasInstruction = getSetupFreezeExtraMetasInstruction;
+exports.getSetupFreezeExtraMetasInstructionDataCodec = getSetupFreezeExtraMetasInstructionDataCodec;
+exports.getSetupFreezeExtraMetasInstructionDataDecoder = getSetupFreezeExtraMetasInstructionDataDecoder;
+exports.getSetupFreezeExtraMetasInstructionDataEncoder = getSetupFreezeExtraMetasInstructionDataEncoder;
+exports.getWalletEntryCodec = getWalletEntryCodec;
+exports.getWalletEntryDecoder = getWalletEntryDecoder;
+exports.getWalletEntryDiscriminatorBytes = getWalletEntryDiscriminatorBytes;
+exports.getWalletEntryEncoder = getWalletEntryEncoder;
+exports.getWalletEntrySize = getWalletEntrySize;
+exports.identifyTokenAclGateProgramAccount = identifyTokenAclGateProgramAccount;
+exports.identifyTokenAclGateProgramInstruction = identifyTokenAclGateProgramInstruction;
+exports.parseAddWalletInstruction = parseAddWalletInstruction;
+exports.parseCanFreezePermissionlessInstruction = parseCanFreezePermissionlessInstruction;
+exports.parseCanThawPermissionlessInstruction = parseCanThawPermissionlessInstruction;
+exports.parseCreateListInstruction = parseCreateListInstruction;
+exports.parseDeleteListInstruction = parseDeleteListInstruction;
+exports.parseRemoveWalletInstruction = parseRemoveWalletInstruction;
+exports.parseSetupExtraMetasInstruction = parseSetupExtraMetasInstruction;
+exports.parseSetupFreezeExtraMetasInstruction = parseSetupFreezeExtraMetasInstruction;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map