export type ShadowDriveUserStaking = {
  version: "2.0.0";
  name: "shadow_drive_user_staking";
  constants: [
    {
      name: "INITIAL_STORAGE_COST";
      type: "u64";
      value: "1_073_741_824";
    },
    {
      name: "MAX_IDENTIFIER_SIZE";
      type: {
        defined: "usize";
      };
      value: "64";
    },
    {
      name: "INITIAL_STORAGE_AVAILABLE";
      type: "u128";
      value: "109_951_162_777_600";
    },
    {
      name: "BYTES_PER_GIB";
      type: "u32";
      value: "1_073_741_824";
    },
    {
      name: "MAX_ACCOUNT_SIZE";
      type: "u64";
      value: "1_099_511_627_776";
    },
    {
      name: "MIN_ACCOUNT_SIZE";
      type: "u64";
      value: "1024";
    },
    {
      name: "MAX_FILENAME_SIZE";
      type: {
        defined: "usize";
      };
      value: "32";
    },
    {
      name: "SHA256_HASH_SIZE";
      type: {
        defined: "usize";
      };
      value: "256 / 8";
    },
    {
      name: "MAX_URL_SIZE";
      type: {
        defined: "usize";
      };
      value: "256";
    },
    {
      name: "DELETION_GRACE_PERIOD";
      type: "u8";
      value: "1";
    },
    {
      name: "UNSTAKE_TIME_PERIOD";
      type: "i64";
      value: "0 * 24 * 60 * 60";
    },
    {
      name: "UNSTAKE_EPOCH_PERIOD";
      type: "u64";
      value: "1";
    },
    {
      name: "INITIAL_CRANK_FEE_BPS";
      type: "u16";
      value: "100";
    }
  ];
  instructions: [
    {
      name: "initializeConfig";
      docs: [
        "Context: This is for admin use. This is to be called first, as this initializes Shadow Drive access on-chain!",
        "Function: The primary function of this is to initialize an account that stores the configuration/parameters of the storage program on-chain, e.g. admin pubkeys, storage cost."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds the SPL's staking and slashing policy.",
            "This is the account that signs transactions on behalf of the program to",
            "distribute staking rewards."
          ];
        },
        {
          name: "admin1";
          isMut: true;
          isSigner: true;
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority"
          ];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent Program"];
        }
      ];
      args: [
        {
          name: "uploader";
          type: "publicKey";
        },
        {
          name: "admin2";
          type: {
            option: "publicKey";
          };
        }
      ];
    },
    {
      name: "updateConfig";
      docs: [
        "Context: This is for admin use.",
        "Function: The primary function of this is update the storage_config account which stores Shadow Drive parameters on-chain, e.g. admin pubkeys, storage cost."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds storage config parameters and admin pubkeys."
          ];
        },
        {
          name: "admin";
          isMut: true;
          isSigner: true;
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority"
          ];
        }
      ];
      args: [
        {
          name: "newStorageCost";
          type: {
            option: "u64";
          };
        },
        {
          name: "newStorageAvailable";
          type: {
            option: "u128";
          };
        },
        {
          name: "newAdmin2";
          type: {
            option: "publicKey";
          };
        },
        {
          name: "newMaxAcctSize";
          type: {
            option: "u64";
          };
        },
        {
          name: "newMinAcctSize";
          type: {
            option: "u64";
          };
        },
        {
          name: "newShadesPerGbEpoch";
          type: {
            option: "u64";
          };
        }
      ];
    },
    {
      name: "mutableFees";
      docs: [
        "Context: This is for admin use.",
        "Function: The primary function of this is to toggle fees for mutable account storage on and off."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds the SPL's staking and slashing policy.",
            "This is the account that signs transactions on behalf of the program to",
            "distribute staking rewards."
          ];
        },
        {
          name: "admin";
          isMut: true;
          isSigner: true;
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority"
          ];
        }
      ];
      args: [
        {
          name: "shadesPerGbPerEpoch";
          type: {
            option: "u64";
          };
        },
        {
          name: "crankBps";
          type: {
            option: "u32";
          };
        }
      ];
    },
    {
      name: "initializeAccount";
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to initialize a storage account with some specified number of bytes."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds the storage configuration, including current cost per byte,"
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's `StorageAccount` information."
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["This is the token in question for staking."];
        },
        {
          name: "owner1";
          isMut: true;
          isSigner: true;
          docs: [
            "This is the user who is initializing the storage account",
            "and is automatically added as an admin"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: [
            "Uploader needs to sign as this txn",
            "needs to be fulfilled on the middleman server",
            "to create the ceph bucket"
          ];
        },
        {
          name: "owner1TokenAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent Program"];
        }
      ];
      args: [
        {
          name: "identifier";
          type: "string";
        },
        {
          name: "storage";
          type: "u64";
        },
        {
          name: "owner2";
          type: {
            option: "publicKey";
          };
        }
      ];
    },
    {
      name: "initializeAccount2";
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to initialize a storage account with some specified number of bytes."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds the storage configuration, including current cost per byte,"
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's storage account information.",
            "Upgraded to `StorageAccountV2`."
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["This is the token in question for staking."];
        },
        {
          name: "owner1";
          isMut: true;
          isSigner: true;
          docs: [
            "This is the user who is initializing the storage account",
            "and is automatically added as an admin"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: [
            "Uploader needs to sign as this txn",
            "needs to be fulfilled on the middleman server",
            "to create the ceph bucket"
          ];
        },
        {
          name: "owner1TokenAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent Program"];
        }
      ];
      args: [
        {
          name: "identifier";
          type: "string";
        },
        {
          name: "storage";
          type: "u64";
        }
      ];
    },
    {
      name: "updateAccount";
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to change the amount of storage they have for this storage account."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [
        {
          name: "identifier";
          type: {
            option: "string";
          };
        },
        {
          name: "owner2";
          type: {
            option: "publicKey";
          };
        }
      ];
    },
    {
      name: "updateAccount2";
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to change the amount of storage they have for this storage account."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [
        {
          name: "identifier";
          type: {
            option: "string";
          };
        }
      ];
    },
    {
      name: "requestDeleteAccount";
      docs: [
        "Context: This is user-facing. This is to be done after our upload server verifies all is well.",
        "Function: This stores the file metadata + location on-chain.",
        "Context: This is user-facing, but requires our uploader's signature. This is to be done after our upload server verifies all is well.",
        "Function: This updates the file metadata on-chain upon user edits.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if parent account is marked as immutable.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if account is marked as immutable."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [];
    },
    {
      name: "requestDeleteAccount2";
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if account is marked as immutable."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [];
    },
    {
      name: "unmarkDeleteAccount";
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if parent account is marked as immutable.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if account is marked as immutable."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: ["Stake account associated with storage account"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [];
    },
    {
      name: "unmarkDeleteAccount2";
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if account is marked as immutable."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: ["Stake account associated with storage account"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        }
      ];
      args: [];
    },
    {
      name: "redeemRent";
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `File` account and updates storage available in user's storage account.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period.",
        "Context: This is user-facing.",
        "Function: This deletes the corresponding `File` account, allowing user to redeem SOL rent in v1.5"
      ];
      accounts: [
        {
          name: "storageAccount";
          isMut: false;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "file";
          isMut: true;
          isSigner: false;
          docs: ["File account to be closed"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: ["File owner, user"];
        }
      ];
      args: [];
    },
    {
      name: "deleteAccount";
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `StorageAccount` account and return's user funds.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: false;
          docs: [
            "File owner, user",
            "Also, our uploader keys are signing this transaction so presuamably we would only provide a good key.",
            "We also may not need this account at all."
          ];
        },
        {
          name: "shdwPayer";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account, presumably with which they staked"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Admin/uploader"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "deleteAccount2";
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `StorageAccount` account and return's user funds.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: false;
          docs: [
            "File owner, user",
            "Also, our uploader keys are signing this transaction so presuamably we would only provide a good key.",
            "We also may not need this account at all."
          ];
        },
        {
          name: "shdwPayer";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account, presumably with which they staked"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Admin/uploader"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "makeAccountImmutable";
      docs: [
        "Context: This is user-facing.",
        "Function: This marks the corresponding `StorageAccount` account as immutable,",
        "and transfers all funds from `stake_account` to operator emissions wallet."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
            "Requires mutability to update global storage counter."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "Parent storage account.",
            "Requires mutability to update user storage account storage counter."
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token account is the SHDW operator emissions wallet"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on make immutable"];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: ["User's token account"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "associatedTokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Associated Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "makeAccountImmutable2";
      docs: [
        "Context: This is user-facing.",
        "Function: This marks the corresponding `StorageAccount` account as immutable,",
        "and transfers all funds from `stake_account` to operator emissions wallet."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
            "Requires mutability to update global storage counter."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "Parent storage account.",
            "Requires mutability to update user storage account storage counter."
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token account is the SHDW operator emissions wallet"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: ["User's token account"];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on make immutable"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "associatedTokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Associated Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "badCsam";
      docs: [
        "Context: This is for admin use.",
        "Function: Upon a bad csam scan, rugs user,",
        "deleting storage account and transferring funds to emissions wallet"
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "uploader";
          isMut: true;
          isSigner: true;
          docs: ["Admin/uploader"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageAvailable";
          type: "u64";
        }
      ];
    },
    {
      name: "badCsam2";
      docs: [
        "Context: This is for admin use.",
        "Function: Upon a bad csam scan, rugs user,",
        "deleting storage account and transferring funds to emissions wallet"
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "userInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account)."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "uploader";
          isMut: true;
          isSigner: true;
          docs: ["Admin/uploader"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageAvailable";
          type: "u64";
        }
      ];
    },
    {
      name: "increaseStorage";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on increase storage"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "additionalStorage";
          type: "u64";
        }
      ];
    },
    {
      name: "increaseStorage2";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on increase storage"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "additionalStorage";
          type: "u64";
        }
      ];
    },
    {
      name: "increaseImmutableStorage";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate, after having marked an account as immutable"
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["Wallet that receives storage fees"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on increase storage"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "additionalStorage";
          type: "u64";
        }
      ];
    },
    {
      name: "increaseImmutableStorage2";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate, after having marked an account as immutable"
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["Wallet that receives storage fees"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on increase storage"];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "additionalStorage";
          type: "u64";
        }
      ];
    },
    {
      name: "decreaseStorage";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to reduce storage, up to current available storage,",
        "and begins an unstake ticket."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "unstakeInfo";
          isMut: true;
          isSigner: false;
          docs: ["Account which stores time, epoch last unstaked"];
        },
        {
          name: "unstakeAccount";
          isMut: true;
          isSigner: false;
          docs: ["Account which stores SHDW when unstaking"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: ["User's ATA"];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on decrease storage"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["Token account holding operator emission funds"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent Program"];
        }
      ];
      args: [
        {
          name: "removeStorage";
          type: "u64";
        },
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "decreaseStorage2";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to reduce storage, up to current available storage,",
        "and begins an unstake ticket."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "unstakeInfo";
          isMut: true;
          isSigner: false;
          docs: ["Account which stores time, epoch last unstaked"];
        },
        {
          name: "unstakeAccount";
          isMut: true;
          isSigner: false;
          docs: ["Account which stores SHDW when unstaking"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: ["User's ATA"];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "uploader";
          isMut: false;
          isSigner: true;
          docs: ["Uploader needs to sign off on decrease storage"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["Token account holding operator emission funds"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        },
        {
          name: "rent";
          isMut: false;
          isSigner: false;
          docs: ["Rent Program"];
        }
      ];
      args: [
        {
          name: "removeStorage";
          type: "u64";
        },
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "claimStake";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to claim stake from unstake ticket.",
        "Fails if user has not waited an appropriate amount of time."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account. Only used here for the key"];
        },
        {
          name: "unstakeInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "Account which stores time, epoch last unstaked. Close upon successful unstake."
          ];
        },
        {
          name: "unstakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "Account which stores SHDW when unstaking.  Close upon successful unstake."
          ];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Programn"];
        }
      ];
      args: [];
    },
    {
      name: "claimStake2";
      docs: [
        "Context: This is user facing.",
        "Function: allows user to claim stake from unstake ticket.",
        "Fails if user has not waited an appropriate amount of time."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account. Only used here for the key"];
        },
        {
          name: "unstakeInfo";
          isMut: true;
          isSigner: false;
          docs: [
            "Account which stores time, epoch last unstaked. Close upon successful unstake."
          ];
        },
        {
          name: "unstakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "Account which stores SHDW when unstaking.  Close upon successful unstake."
          ];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Programn"];
        }
      ];
      args: [];
    },
    {
      name: "crank";
      docs: [
        "Context: This is a public function, callable by anyone.",
        "Function: collects fees from user stake account and",
        "sends it to the operator emissions wallet."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "cranker";
          isMut: true;
          isSigner: true;
          docs: ["Cranker"];
        },
        {
          name: "crankerAta";
          isMut: true;
          isSigner: false;
          docs: ["Cranker's ATA"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "crank2";
      docs: [
        "Context: This is a public function, callable by anyone.",
        "Function: collects fees from user stake account and",
        "sends it to the operator emissions wallet."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "cranker";
          isMut: true;
          isSigner: true;
          docs: ["Cranker"];
        },
        {
          name: "crankerAta";
          isMut: true;
          isSigner: false;
          docs: ["Cranker's ATA"];
        },
        {
          name: "emissionsWallet";
          isMut: true;
          isSigner: false;
          docs: ["This token accountis the SHDW operator emissions wallet"];
        },
        {
          name: "tokenMint";
          isMut: true;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [
        {
          name: "storageUsed";
          type: "u64";
        }
      ];
    },
    {
      name: "refreshStake";
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [];
    },
    {
      name: "refreshStake2";
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion."
      ];
      accounts: [
        {
          name: "storageConfig";
          isMut: false;
          isSigner: false;
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys."
          ];
        },
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Parent storage account."];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer."
          ];
        },
        {
          name: "ownerAta";
          isMut: true;
          isSigner: false;
          docs: [
            "This is the user's token account with which they are staking"
          ];
        },
        {
          name: "stakeAccount";
          isMut: true;
          isSigner: false;
          docs: [
            "This token account serves as the account which holds user's stake for file storage."
          ];
        },
        {
          name: "tokenMint";
          isMut: false;
          isSigner: false;
          docs: ["Token mint account"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
          docs: ["System Program"];
        },
        {
          name: "tokenProgram";
          isMut: false;
          isSigner: false;
          docs: ["Token Program"];
        }
      ];
      args: [];
    },
    {
      name: "migrateStep1";
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion."
      ];
      accounts: [
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["Account to be migrated"];
        },
        {
          name: "migration";
          isMut: true;
          isSigner: false;
          docs: ["Migration helper PDA"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: ["User that is migrating"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
        }
      ];
      args: [];
    },
    {
      name: "migrateStep2";
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion."
      ];
      accounts: [
        {
          name: "storageAccount";
          isMut: true;
          isSigner: false;
          docs: ["New account"];
        },
        {
          name: "migration";
          isMut: true;
          isSigner: false;
          docs: ["Migration helper PDA"];
        },
        {
          name: "owner";
          isMut: true;
          isSigner: true;
          docs: ["User that is migrating"];
        },
        {
          name: "systemProgram";
          isMut: false;
          isSigner: false;
        }
      ];
      args: [];
    }
  ];
  accounts: [
    {
      name: "unstakeInfo";
      type: {
        kind: "struct";
        fields: [
          {
            name: "timeLastUnstaked";
            type: "i64";
          },
          {
            name: "epochLastUnstaked";
            type: "u64";
          },
          {
            name: "unstaker";
            type: "publicKey";
          }
        ];
      };
    },
    {
      name: "storageAccount";
      type: {
        kind: "struct";
        fields: [
          {
            name: "isStatic";
            docs: [
              "Immutable boolean to track what kind of storage account this is.",
              "NOTE: Not used in current implementation w/ non-dynamic storage payments"
            ];
            type: "bool";
          },
          {
            name: "initCounter";
            docs: [
              "Flag on whether storage account is public (usable by anyone)",
              "Counter tracking how many files have been initialized"
            ];
            type: "u32";
          },
          {
            name: "delCounter";
            docs: ["Counter tracking how many files have been deleted"];
            type: "u32";
          },
          {
            name: "immutable";
            docs: [
              "Boolean to track whether storage account (and all child File accounts) are immutable"
            ];
            type: "bool";
          },
          {
            name: "toBeDeleted";
            docs: ["Delete flag"];
            type: "bool";
          },
          {
            name: "deleteRequestEpoch";
            docs: ["Delete request epoch"];
            type: "u32";
          },
          {
            name: "storage";
            docs: ["Number of bytes of storage associated with this account"];
            type: "u64";
          },
          {
            name: "storageAvailable";
            docs: ["Bytes available for use"];
            type: "u64";
          },
          {
            name: "owner1";
            docs: ["Primary owner of StorageAccount (immutable)"];
            type: "publicKey";
          },
          {
            name: "owner2";
            docs: ["Optional owner 2"];
            type: "publicKey";
          },
          {
            name: "shdwPayer";
            docs: ["Pubkey of the token account that staked SHDW"];
            type: "publicKey";
          },
          {
            name: "accountCounterSeed";
            docs: ["Counter at time of initialization"];
            type: "u32";
          },
          {
            name: "totalCostOfCurrentStorage";
            docs: ["Total shades paid for current box size"];
            type: "u64";
          },
          {
            name: "totalFeesPaid";
            type: "u64";
          },
          {
            name: "creationTime";
            docs: ["Time of storage account creation"];
            type: "u32";
          },
          {
            name: "creationEpoch";
            docs: ["Time of storage account creation"];
            type: "u32";
          },
          {
            name: "lastFeeEpoch";
            docs: ["The last epoch through which the user paid"];
            type: "u32";
          },
          {
            name: "identifier";
            docs: [
              "Some unique identifier that the user provides.",
              "Serves as a seed for storage account PDA."
            ];
            type: "string";
          }
        ];
      };
    },
    {
      name: "storageAccountV2";
      type: {
        kind: "struct";
        fields: [
          {
            name: "immutable";
            docs: [
              "Boolean to track whether storage account (and all child File accounts) are immutable"
            ];
            type: "bool";
          },
          {
            name: "toBeDeleted";
            docs: ["Delete flag"];
            type: "bool";
          },
          {
            name: "deleteRequestEpoch";
            docs: ["Delete request epoch"];
            type: "u32";
          },
          {
            name: "storage";
            docs: ["Number of bytes of storage associated with this account"];
            type: "u64";
          },
          {
            name: "owner1";
            docs: ["Primary owner of StorageAccount (immutable)"];
            type: "publicKey";
          },
          {
            name: "accountCounterSeed";
            docs: [
              "Pubkey of the token account that staked SHDW",
              "Counter at time of initialization"
            ];
            type: "u32";
          },
          {
            name: "creationTime";
            docs: ["Time of storage account creation"];
            type: "u32";
          },
          {
            name: "creationEpoch";
            docs: ["Time of storage account creation"];
            type: "u32";
          },
          {
            name: "lastFeeEpoch";
            docs: ["The last epoch through which the user paid"];
            type: "u32";
          },
          {
            name: "identifier";
            docs: [
              "Some unique identifier that the user provides.",
              "Serves as a seed for storage account PDA."
            ];
            type: "string";
          }
        ];
      };
    },
    {
      name: "userInfo";
      type: {
        kind: "struct";
        fields: [
          {
            name: "accountCounter";
            docs: ["Total number of storage accounts the user has with us"];
            type: "u32";
          },
          {
            name: "delCounter";
            docs: ["Total number of storage accounts that have been deleted"];
            type: "u32";
          },
          {
            name: "agreedToTos";
            docs: ["Boolean denoting that the user agreed to terms of service"];
            type: "bool";
          },
          {
            name: "lifetimeBadCsam";
            docs: [
              "Boolean denoting whether this pubkey has ever had a bad scam scan"
            ];
            type: "bool";
          }
        ];
      };
    },
    {
      name: "storageConfig";
      type: {
        kind: "struct";
        fields: [
          {
            name: "shadesPerGib";
            docs: ["Storage costs in shades per GiB"];
            type: "u64";
          },
          {
            name: "storageAvailable";
            docs: ["Total storage available (or remaining)"];
            type: "u128";
          },
          {
            name: "tokenAccount";
            docs: [
              "Pubkey of SHDW token account that holds storage fees/stake"
            ];
            type: "publicKey";
          },
          {
            name: "admin2";
            docs: ["Optional Admin 2"];
            type: "publicKey";
          },
          {
            name: "uploader";
            docs: [
              "Uploader key, used to sign off on successful storage + CSAM scan"
            ];
            type: "publicKey";
          },
          {
            name: "mutableFeeStartEpoch";
            docs: ["Epoch at which mutable_account_fees turned on"];
            type: {
              option: "u32";
            };
          },
          {
            name: "shadesPerGibPerEpoch";
            docs: ["Mutable fee rate"];
            type: "u64";
          },
          {
            name: "crankBps";
            docs: ["Basis points cranker gets from cranking"];
            type: "u16";
          },
          {
            name: "maxAccountSize";
            docs: ["Maximum size of a storage account"];
            type: "u64";
          },
          {
            name: "minAccountSize";
            docs: ["Minimum size of a storage account"];
            type: "u64";
          }
        ];
      };
    },
    {
      name: "file";
      type: {
        kind: "struct";
        fields: [
          {
            name: "immutable";
            docs: ["Mutability"];
            type: "bool";
          },
          {
            name: "toBeDeleted";
            docs: ["Delete flag"];
            type: "bool";
          },
          {
            name: "deleteRequestEpoch";
            docs: ["Delete request epoch"];
            type: "u32";
          },
          {
            name: "size";
            docs: ["File size (bytes)"];
            type: "u64";
          },
          {
            name: "sha256Hash";
            docs: ["File hash (sha256)"];
            type: {
              array: ["u8", 32];
            };
          },
          {
            name: "initCounterSeed";
            docs: ["File counter seed"];
            type: "u32";
          },
          {
            name: "storageAccount";
            docs: ["Storage accout"];
            type: "publicKey";
          },
          {
            name: "name";
            docs: ["File name"];
            type: "string";
          }
        ];
      };
    },
    {
      name: "file";
      type: {
        kind: "struct";
        fields: [
          {
            name: "immutable";
            docs: ["Mutability"];
            type: "bool";
          },
          {
            name: "toBeDeleted";
            docs: ["Delete flag"];
            type: "bool";
          },
          {
            name: "deleteRequestEpoch";
            docs: ["Delete request epoch"];
            type: "u32";
          },
          {
            name: "size";
            docs: ["File size (bytes)"];
            type: "u64";
          },
          {
            name: "sha256Hash";
            docs: ["File hash (sha256)"];
            type: {
              array: ["u8", 32];
            };
          },
          {
            name: "initCounterSeed";
            docs: ["File counter seed"];
            type: "u32";
          },
          {
            name: "storageAccount";
            docs: ["Storage accout"];
            type: "publicKey";
          },
          {
            name: "name";
            docs: ["File name"];
            type: "string";
          }
        ];
      };
    }
  ];
  types: [
    {
      name: "Mode";
      type: {
        kind: "enum";
        variants: [
          {
            name: "Increment";
          },
          {
            name: "Decrement";
          },
          {
            name: "Initialize";
          }
        ];
      };
    }
  ];
  events: [
    {
      name: "StakeRefreshed";
      fields: [
        {
          name: "refreshed";
          type: "bool";
          index: false;
        },
        {
          name: "account";
          type: "publicKey";
          index: false;
        }
      ];
    }
  ];
  errors: [
    {
      code: 6000;
      name: "NotEnoughStorage";
      msg: "Not enough storage available on this Storage Account";
    },
    {
      code: 6001;
      name: "FileNameLengthExceedsLimit";
      msg: "The length of the file name exceeds the limit of 32 bytes";
    },
    {
      code: 6002;
      name: "InvalidSha256Hash";
      msg: "Invalid sha256 hash";
    },
    {
      code: 6003;
      name: "HasHadBadCsam";
      msg: "User at some point had a bad csam scan";
    },
    {
      code: 6004;
      name: "StorageAccountMarkedImmutable";
      msg: "Storage account is marked as immutable";
    },
    {
      code: 6005;
      name: "ClaimingStakeTooSoon";
      msg: "User has not waited enough time to claim stake";
    },
    {
      code: 6006;
      name: "SolanaStorageAccountNotMutable";
      msg: "The storage account needs to be marked as mutable to update last fee collection epoch";
    },
    {
      code: 6007;
      name: "RemovingTooMuchStorage";
      msg: "Attempting to decrease storage by more than is available";
    },
    {
      code: 6008;
      name: "UnsignedIntegerCastFailed";
      msg: "u128 -> u64 cast failed";
    },
    {
      code: 6009;
      name: "NonzeroRemainingFileAccounts";
      msg: "This storage account still has some file accounts associated with it that have not been deleted";
    },
    {
      code: 6010;
      name: "AccountStillInGracePeriod";
      msg: "This account is still within deletion grace period";
    },
    {
      code: 6011;
      name: "AccountNotMarkedToBeDeleted";
      msg: "This account is not marked to be deleted";
    },
    {
      code: 6012;
      name: "FileStillInGracePeriod";
      msg: "This file is still within deletion grace period";
    },
    {
      code: 6013;
      name: "FileNotMarkedToBeDeleted";
      msg: "This file is not marked to be deleted";
    },
    {
      code: 6014;
      name: "FileMarkedImmutable";
      msg: "File has been marked as immutable and cannot be edited";
    },
    {
      code: 6015;
      name: "NoStorageIncrease";
      msg: "User requested an increase of zero bytes";
    },
    {
      code: 6016;
      name: "ExceededStorageLimit";
      msg: "Requested a storage account with storage over the limit";
    },
    {
      code: 6017;
      name: "InsufficientFunds";
      msg: "User does not have enough funds to store requested number of bytes.";
    },
    {
      code: 6018;
      name: "NotEnoughStorageOnShadowDrive";
      msg: "There is not available storage on Shadow Drive. Good job!";
    },
    {
      code: 6019;
      name: "AccountTooSmall";
      msg: "Requested a storage account with storage under the limit";
    },
    {
      code: 6020;
      name: "DidNotAgreeToToS";
      msg: "User did not agree to terms of service";
    },
    {
      code: 6021;
      name: "InvalidTokenTransferAmounts";
      msg: "Invalid token transfers. Stake account nonempty.";
    },
    {
      code: 6022;
      name: "FailedToCloseAccount";
      msg: "Failed to close spl token account";
    },
    {
      code: 6023;
      name: "FailedToTransferToEmissionsWallet";
      msg: "Failed to transfer to emissions wallet";
    },
    {
      code: 6024;
      name: "FailedToTransferToEmissionsWalletFromUser";
      msg: "Failed to transfer to emissions wallet from user";
    },
    {
      code: 6025;
      name: "FailedToReturnUserFunds";
      msg: "Failed to return user funds";
    },
    {
      code: 6026;
      name: "NeedSomeFees";
      msg: "Turning on fees and passing in None for storage cost per epoch";
    },
    {
      code: 6027;
      name: "NeedSomeCrankBps";
      msg: "Turning on fees and passing in None for crank bps";
    },
    {
      code: 6028;
      name: "AlreadyMarkedForDeletion";
      msg: "This account is already marked to be deleted";
    },
    {
      code: 6029;
      name: "EmptyStakeAccount";
      msg: "User has an empty stake account and must refresh stake account before unmarking account for deletion";
    },
    {
      code: 6030;
      name: "IdentifierExceededMaxLength";
      msg: "New identifier exceeds maximum length of 64 bytes";
    },
    {
      code: 6031;
      name: "OnlyAdmin1CanChangeAdmins";
      msg: "Only admin1 can change admins";
    },
    {
      code: 6032;
      name: "OnlyOneOwnerAllowedInV1_5";
      msg: "(As part of on-chain storage optimizations, only one owner is allowed in Shadow Drive v1.5)";
    }
  ];
};

export const IDL: ShadowDriveUserStaking = {
  version: "2.0.0",
  name: "shadow_drive_user_staking",
  constants: [
    {
      name: "INITIAL_STORAGE_COST",
      type: "u64",
      value: "1_073_741_824",
    },
    {
      name: "MAX_IDENTIFIER_SIZE",
      type: {
        defined: "usize",
      },
      value: "64",
    },
    {
      name: "INITIAL_STORAGE_AVAILABLE",
      type: "u128",
      value: "109_951_162_777_600",
    },
    {
      name: "BYTES_PER_GIB",
      type: "u32",
      value: "1_073_741_824",
    },
    {
      name: "MAX_ACCOUNT_SIZE",
      type: "u64",
      value: "1_099_511_627_776",
    },
    {
      name: "MIN_ACCOUNT_SIZE",
      type: "u64",
      value: "1024",
    },
    {
      name: "MAX_FILENAME_SIZE",
      type: {
        defined: "usize",
      },
      value: "32",
    },
    {
      name: "SHA256_HASH_SIZE",
      type: {
        defined: "usize",
      },
      value: "256 / 8",
    },
    {
      name: "MAX_URL_SIZE",
      type: {
        defined: "usize",
      },
      value: "256",
    },
    {
      name: "DELETION_GRACE_PERIOD",
      type: "u8",
      value: "1",
    },
    {
      name: "UNSTAKE_TIME_PERIOD",
      type: "i64",
      value: "0 * 24 * 60 * 60",
    },
    {
      name: "UNSTAKE_EPOCH_PERIOD",
      type: "u64",
      value: "1",
    },
    {
      name: "INITIAL_CRANK_FEE_BPS",
      type: "u16",
      value: "100",
    },
  ],
  instructions: [
    {
      name: "initializeConfig",
      docs: [
        "Context: This is for admin use. This is to be called first, as this initializes Shadow Drive access on-chain!",
        "Function: The primary function of this is to initialize an account that stores the configuration/parameters of the storage program on-chain, e.g. admin pubkeys, storage cost.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds the SPL's staking and slashing policy.",
            "This is the account that signs transactions on behalf of the program to",
            "distribute staking rewards.",
          ],
        },
        {
          name: "admin1",
          isMut: true,
          isSigner: true,
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority",
          ],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent Program"],
        },
      ],
      args: [
        {
          name: "uploader",
          type: "publicKey",
        },
        {
          name: "admin2",
          type: {
            option: "publicKey",
          },
        },
      ],
    },
    {
      name: "updateConfig",
      docs: [
        "Context: This is for admin use.",
        "Function: The primary function of this is update the storage_config account which stores Shadow Drive parameters on-chain, e.g. admin pubkeys, storage cost.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds storage config parameters and admin pubkeys.",
          ],
        },
        {
          name: "admin",
          isMut: true,
          isSigner: true,
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority",
          ],
        },
      ],
      args: [
        {
          name: "newStorageCost",
          type: {
            option: "u64",
          },
        },
        {
          name: "newStorageAvailable",
          type: {
            option: "u128",
          },
        },
        {
          name: "newAdmin2",
          type: {
            option: "publicKey",
          },
        },
        {
          name: "newMaxAcctSize",
          type: {
            option: "u64",
          },
        },
        {
          name: "newMinAcctSize",
          type: {
            option: "u64",
          },
        },
        {
          name: "newShadesPerGbEpoch",
          type: {
            option: "u64",
          },
        },
      ],
    },
    {
      name: "mutableFees",
      docs: [
        "Context: This is for admin use.",
        "Function: The primary function of this is to toggle fees for mutable account storage on and off.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds the SPL's staking and slashing policy.",
            "This is the account that signs transactions on behalf of the program to",
            "distribute staking rewards.",
          ],
        },
        {
          name: "admin",
          isMut: true,
          isSigner: true,
          docs: [
            "This account is the SPL's staking policy admin.",
            "Must be either freeze or mint authority",
          ],
        },
      ],
      args: [
        {
          name: "shadesPerGbPerEpoch",
          type: {
            option: "u64",
          },
        },
        {
          name: "crankBps",
          type: {
            option: "u32",
          },
        },
      ],
    },
    {
      name: "initializeAccount",
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to initialize a storage account with some specified number of bytes.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds the storage configuration, including current cost per byte,",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's `StorageAccount` information.",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["This is the token in question for staking."],
        },
        {
          name: "owner1",
          isMut: true,
          isSigner: true,
          docs: [
            "This is the user who is initializing the storage account",
            "and is automatically added as an admin",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: [
            "Uploader needs to sign as this txn",
            "needs to be fulfilled on the middleman server",
            "to create the ceph bucket",
          ],
        },
        {
          name: "owner1TokenAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent Program"],
        },
      ],
      args: [
        {
          name: "identifier",
          type: "string",
        },
        {
          name: "storage",
          type: "u64",
        },
        {
          name: "owner2",
          type: {
            option: "publicKey",
          },
        },
      ],
    },
    {
      name: "initializeAccount2",
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to initialize a storage account with some specified number of bytes.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds the storage configuration, including current cost per byte,",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's storage account information.",
            "Upgraded to `StorageAccountV2`.",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["This is the token in question for staking."],
        },
        {
          name: "owner1",
          isMut: true,
          isSigner: true,
          docs: [
            "This is the user who is initializing the storage account",
            "and is automatically added as an admin",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: [
            "Uploader needs to sign as this txn",
            "needs to be fulfilled on the middleman server",
            "to create the ceph bucket",
          ],
        },
        {
          name: "owner1TokenAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent Program"],
        },
      ],
      args: [
        {
          name: "identifier",
          type: "string",
        },
        {
          name: "storage",
          type: "u64",
        },
      ],
    },
    {
      name: "updateAccount",
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to change the amount of storage they have for this storage account.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [
        {
          name: "identifier",
          type: {
            option: "string",
          },
        },
        {
          name: "owner2",
          type: {
            option: "publicKey",
          },
        },
      ],
    },
    {
      name: "updateAccount2",
      docs: [
        "Context: This is user-facing. This is to be done whenever the user decides.",
        "Function: This allows the user to change the amount of storage they have for this storage account.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [
        {
          name: "identifier",
          type: {
            option: "string",
          },
        },
      ],
    },
    {
      name: "requestDeleteAccount",
      docs: [
        "Context: This is user-facing. This is to be done after our upload server verifies all is well.",
        "Function: This stores the file metadata + location on-chain.",
        "Context: This is user-facing, but requires our uploader's signature. This is to be done after our upload server verifies all is well.",
        "Function: This updates the file metadata on-chain upon user edits.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if parent account is marked as immutable.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if account is marked as immutable.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [],
    },
    {
      name: "requestDeleteAccount2",
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and records the request time. Fails if account is marked as immutable.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [],
    },
    {
      name: "unmarkDeleteAccount",
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if parent account is marked as immutable.",
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if account is marked as immutable.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: ["Stake account associated with storage account"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [],
    },
    {
      name: "unmarkDeleteAccount2",
      docs: [
        "Context: This is user-facing.",
        "Function: This updates a boolean flag and resets the request time. Fails if account is marked as immutable.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: ["Stake account associated with storage account"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
      ],
      args: [],
    },
    {
      name: "redeemRent",
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `File` account and updates storage available in user's storage account.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period.",
        "Context: This is user-facing.",
        "Function: This deletes the corresponding `File` account, allowing user to redeem SOL rent in v1.5",
      ],
      accounts: [
        {
          name: "storageAccount",
          isMut: false,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "file",
          isMut: true,
          isSigner: false,
          docs: ["File account to be closed"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: ["File owner, user"],
        },
      ],
      args: [],
    },
    {
      name: "deleteAccount",
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `StorageAccount` account and return's user funds.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: false,
          docs: [
            "File owner, user",
            "Also, our uploader keys are signing this transaction so presuamably we would only provide a good key.",
            "We also may not need this account at all.",
          ],
        },
        {
          name: "shdwPayer",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account, presumably with which they staked",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Admin/uploader"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "deleteAccount2",
      docs: [
        "Context: This is for admin use.",
        "Function: This deletes the corresponding `StorageAccount` account and return's user funds.",
        "Fails if file is marked as immutable, or if time elapsed since request is less than the grace period.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: false,
          docs: [
            "File owner, user",
            "Also, our uploader keys are signing this transaction so presuamably we would only provide a good key.",
            "We also may not need this account at all.",
          ],
        },
        {
          name: "shdwPayer",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account, presumably with which they staked",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Admin/uploader"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "makeAccountImmutable",
      docs: [
        "Context: This is user-facing.",
        "Function: This marks the corresponding `StorageAccount` account as immutable,",
        "and transfers all funds from `stake_account` to operator emissions wallet.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
            "Requires mutability to update global storage counter.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "Parent storage account.",
            "Requires mutability to update user storage account storage counter.",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token account is the SHDW operator emissions wallet"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on make immutable"],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: ["User's token account"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "associatedTokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Associated Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "makeAccountImmutable2",
      docs: [
        "Context: This is user-facing.",
        "Function: This marks the corresponding `StorageAccount` account as immutable,",
        "and transfers all funds from `stake_account` to operator emissions wallet.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
            "Requires mutability to update global storage counter.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "Parent storage account.",
            "Requires mutability to update user storage account storage counter.",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token account is the SHDW operator emissions wallet"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: ["User's token account"],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on make immutable"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "associatedTokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Associated Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "badCsam",
      docs: [
        "Context: This is for admin use.",
        "Function: Upon a bad csam scan, rugs user,",
        "deleting storage account and transferring funds to emissions wallet",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "uploader",
          isMut: true,
          isSigner: true,
          docs: ["Admin/uploader"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageAvailable",
          type: "u64",
        },
      ],
    },
    {
      name: "badCsam2",
      docs: [
        "Context: This is for admin use.",
        "Function: Upon a bad csam scan, rugs user,",
        "deleting storage account and transferring funds to emissions wallet",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "userInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "This account is a PDA that holds a user's info (not specific to one storage account).",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "uploader",
          isMut: true,
          isSigner: true,
          docs: ["Admin/uploader"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageAvailable",
          type: "u64",
        },
      ],
    },
    {
      name: "increaseStorage",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on increase storage"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "additionalStorage",
          type: "u64",
        },
      ],
    },
    {
      name: "increaseStorage2",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on increase storage"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "additionalStorage",
          type: "u64",
        },
      ],
    },
    {
      name: "increaseImmutableStorage",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate, after having marked an account as immutable",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["Wallet that receives storage fees"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on increase storage"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "additionalStorage",
          type: "u64",
        },
      ],
    },
    {
      name: "increaseImmutableStorage2",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to pay for more storage at current rate, after having marked an account as immutable",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["Wallet that receives storage fees"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on increase storage"],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "additionalStorage",
          type: "u64",
        },
      ],
    },
    {
      name: "decreaseStorage",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to reduce storage, up to current available storage,",
        "and begins an unstake ticket.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "unstakeInfo",
          isMut: true,
          isSigner: false,
          docs: ["Account which stores time, epoch last unstaked"],
        },
        {
          name: "unstakeAccount",
          isMut: true,
          isSigner: false,
          docs: ["Account which stores SHDW when unstaking"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: ["User's ATA"],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on decrease storage"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["Token account holding operator emission funds"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent Program"],
        },
      ],
      args: [
        {
          name: "removeStorage",
          type: "u64",
        },
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "decreaseStorage2",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to reduce storage, up to current available storage,",
        "and begins an unstake ticket.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "unstakeInfo",
          isMut: true,
          isSigner: false,
          docs: ["Account which stores time, epoch last unstaked"],
        },
        {
          name: "unstakeAccount",
          isMut: true,
          isSigner: false,
          docs: ["Account which stores SHDW when unstaking"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: ["User's ATA"],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "uploader",
          isMut: false,
          isSigner: true,
          docs: ["Uploader needs to sign off on decrease storage"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["Token account holding operator emission funds"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
        {
          name: "rent",
          isMut: false,
          isSigner: false,
          docs: ["Rent Program"],
        },
      ],
      args: [
        {
          name: "removeStorage",
          type: "u64",
        },
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "claimStake",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to claim stake from unstake ticket.",
        "Fails if user has not waited an appropriate amount of time.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account. Only used here for the key"],
        },
        {
          name: "unstakeInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "Account which stores time, epoch last unstaked. Close upon successful unstake.",
          ],
        },
        {
          name: "unstakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "Account which stores SHDW when unstaking.  Close upon successful unstake.",
          ],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Programn"],
        },
      ],
      args: [],
    },
    {
      name: "claimStake2",
      docs: [
        "Context: This is user facing.",
        "Function: allows user to claim stake from unstake ticket.",
        "Fails if user has not waited an appropriate amount of time.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account. Only used here for the key"],
        },
        {
          name: "unstakeInfo",
          isMut: true,
          isSigner: false,
          docs: [
            "Account which stores time, epoch last unstaked. Close upon successful unstake.",
          ],
        },
        {
          name: "unstakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "Account which stores SHDW when unstaking.  Close upon successful unstake.",
          ],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Programn"],
        },
      ],
      args: [],
    },
    {
      name: "crank",
      docs: [
        "Context: This is a public function, callable by anyone.",
        "Function: collects fees from user stake account and",
        "sends it to the operator emissions wallet.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "cranker",
          isMut: true,
          isSigner: true,
          docs: ["Cranker"],
        },
        {
          name: "crankerAta",
          isMut: true,
          isSigner: false,
          docs: ["Cranker's ATA"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "crank2",
      docs: [
        "Context: This is a public function, callable by anyone.",
        "Function: collects fees from user stake account and",
        "sends it to the operator emissions wallet.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "cranker",
          isMut: true,
          isSigner: true,
          docs: ["Cranker"],
        },
        {
          name: "crankerAta",
          isMut: true,
          isSigner: false,
          docs: ["Cranker's ATA"],
        },
        {
          name: "emissionsWallet",
          isMut: true,
          isSigner: false,
          docs: ["This token accountis the SHDW operator emissions wallet"],
        },
        {
          name: "tokenMint",
          isMut: true,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [
        {
          name: "storageUsed",
          type: "u64",
        },
      ],
    },
    {
      name: "refreshStake",
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [],
    },
    {
      name: "refreshStake2",
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion.",
      ],
      accounts: [
        {
          name: "storageConfig",
          isMut: false,
          isSigner: false,
          docs: [
            "This is the `StorageConfig` accounts that holds all of the admin, uploader keys.",
          ],
        },
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Parent storage account."],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: [
            "File owner, user, fee-payer",
            "Requires mutability since owner/user is fee payer.",
          ],
        },
        {
          name: "ownerAta",
          isMut: true,
          isSigner: false,
          docs: [
            "This is the user's token account with which they are staking",
          ],
        },
        {
          name: "stakeAccount",
          isMut: true,
          isSigner: false,
          docs: [
            "This token account serves as the account which holds user's stake for file storage.",
          ],
        },
        {
          name: "tokenMint",
          isMut: false,
          isSigner: false,
          docs: ["Token mint account"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
          docs: ["System Program"],
        },
        {
          name: "tokenProgram",
          isMut: false,
          isSigner: false,
          docs: ["Token Program"],
        },
      ],
      args: [],
    },
    {
      name: "migrateStep1",
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion.",
      ],
      accounts: [
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["Account to be migrated"],
        },
        {
          name: "migration",
          isMut: true,
          isSigner: false,
          docs: ["Migration helper PDA"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: ["User that is migrating"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
        },
      ],
      args: [],
    },
    {
      name: "migrateStep2",
      docs: [
        "Context: This is user-facing.",
        "Function: allows user to top off stake account, and unmarks deletion.",
      ],
      accounts: [
        {
          name: "storageAccount",
          isMut: true,
          isSigner: false,
          docs: ["New account"],
        },
        {
          name: "migration",
          isMut: true,
          isSigner: false,
          docs: ["Migration helper PDA"],
        },
        {
          name: "owner",
          isMut: true,
          isSigner: true,
          docs: ["User that is migrating"],
        },
        {
          name: "systemProgram",
          isMut: false,
          isSigner: false,
        },
      ],
      args: [],
    },
  ],
  accounts: [
    {
      name: "unstakeInfo",
      type: {
        kind: "struct",
        fields: [
          {
            name: "timeLastUnstaked",
            type: "i64",
          },
          {
            name: "epochLastUnstaked",
            type: "u64",
          },
          {
            name: "unstaker",
            type: "publicKey",
          },
        ],
      },
    },
    {
      name: "storageAccount",
      type: {
        kind: "struct",
        fields: [
          {
            name: "isStatic",
            docs: [
              "Immutable boolean to track what kind of storage account this is.",
              "NOTE: Not used in current implementation w/ non-dynamic storage payments",
            ],
            type: "bool",
          },
          {
            name: "initCounter",
            docs: [
              "Flag on whether storage account is public (usable by anyone)",
              "Counter tracking how many files have been initialized",
            ],
            type: "u32",
          },
          {
            name: "delCounter",
            docs: ["Counter tracking how many files have been deleted"],
            type: "u32",
          },
          {
            name: "immutable",
            docs: [
              "Boolean to track whether storage account (and all child File accounts) are immutable",
            ],
            type: "bool",
          },
          {
            name: "toBeDeleted",
            docs: ["Delete flag"],
            type: "bool",
          },
          {
            name: "deleteRequestEpoch",
            docs: ["Delete request epoch"],
            type: "u32",
          },
          {
            name: "storage",
            docs: ["Number of bytes of storage associated with this account"],
            type: "u64",
          },
          {
            name: "storageAvailable",
            docs: ["Bytes available for use"],
            type: "u64",
          },
          {
            name: "owner1",
            docs: ["Primary owner of StorageAccount (immutable)"],
            type: "publicKey",
          },
          {
            name: "owner2",
            docs: ["Optional owner 2"],
            type: "publicKey",
          },
          {
            name: "shdwPayer",
            docs: ["Pubkey of the token account that staked SHDW"],
            type: "publicKey",
          },
          {
            name: "accountCounterSeed",
            docs: ["Counter at time of initialization"],
            type: "u32",
          },
          {
            name: "totalCostOfCurrentStorage",
            docs: ["Total shades paid for current box size"],
            type: "u64",
          },
          {
            name: "totalFeesPaid",
            type: "u64",
          },
          {
            name: "creationTime",
            docs: ["Time of storage account creation"],
            type: "u32",
          },
          {
            name: "creationEpoch",
            docs: ["Time of storage account creation"],
            type: "u32",
          },
          {
            name: "lastFeeEpoch",
            docs: ["The last epoch through which the user paid"],
            type: "u32",
          },
          {
            name: "identifier",
            docs: [
              "Some unique identifier that the user provides.",
              "Serves as a seed for storage account PDA.",
            ],
            type: "string",
          },
        ],
      },
    },
    {
      name: "storageAccountV2",
      type: {
        kind: "struct",
        fields: [
          {
            name: "immutable",
            docs: [
              "Boolean to track whether storage account (and all child File accounts) are immutable",
            ],
            type: "bool",
          },
          {
            name: "toBeDeleted",
            docs: ["Delete flag"],
            type: "bool",
          },
          {
            name: "deleteRequestEpoch",
            docs: ["Delete request epoch"],
            type: "u32",
          },
          {
            name: "storage",
            docs: ["Number of bytes of storage associated with this account"],
            type: "u64",
          },
          {
            name: "owner1",
            docs: ["Primary owner of StorageAccount (immutable)"],
            type: "publicKey",
          },
          {
            name: "accountCounterSeed",
            docs: [
              "Pubkey of the token account that staked SHDW",
              "Counter at time of initialization",
            ],
            type: "u32",
          },
          {
            name: "creationTime",
            docs: ["Time of storage account creation"],
            type: "u32",
          },
          {
            name: "creationEpoch",
            docs: ["Time of storage account creation"],
            type: "u32",
          },
          {
            name: "lastFeeEpoch",
            docs: ["The last epoch through which the user paid"],
            type: "u32",
          },
          {
            name: "identifier",
            docs: [
              "Some unique identifier that the user provides.",
              "Serves as a seed for storage account PDA.",
            ],
            type: "string",
          },
        ],
      },
    },
    {
      name: "userInfo",
      type: {
        kind: "struct",
        fields: [
          {
            name: "accountCounter",
            docs: ["Total number of storage accounts the user has with us"],
            type: "u32",
          },
          {
            name: "delCounter",
            docs: ["Total number of storage accounts that have been deleted"],
            type: "u32",
          },
          {
            name: "agreedToTos",
            docs: ["Boolean denoting that the user agreed to terms of service"],
            type: "bool",
          },
          {
            name: "lifetimeBadCsam",
            docs: [
              "Boolean denoting whether this pubkey has ever had a bad scam scan",
            ],
            type: "bool",
          },
        ],
      },
    },
    {
      name: "storageConfig",
      type: {
        kind: "struct",
        fields: [
          {
            name: "shadesPerGib",
            docs: ["Storage costs in shades per GiB"],
            type: "u64",
          },
          {
            name: "storageAvailable",
            docs: ["Total storage available (or remaining)"],
            type: "u128",
          },
          {
            name: "tokenAccount",
            docs: [
              "Pubkey of SHDW token account that holds storage fees/stake",
            ],
            type: "publicKey",
          },
          {
            name: "admin2",
            docs: ["Optional Admin 2"],
            type: "publicKey",
          },
          {
            name: "uploader",
            docs: [
              "Uploader key, used to sign off on successful storage + CSAM scan",
            ],
            type: "publicKey",
          },
          {
            name: "mutableFeeStartEpoch",
            docs: ["Epoch at which mutable_account_fees turned on"],
            type: {
              option: "u32",
            },
          },
          {
            name: "shadesPerGibPerEpoch",
            docs: ["Mutable fee rate"],
            type: "u64",
          },
          {
            name: "crankBps",
            docs: ["Basis points cranker gets from cranking"],
            type: "u16",
          },
          {
            name: "maxAccountSize",
            docs: ["Maximum size of a storage account"],
            type: "u64",
          },
          {
            name: "minAccountSize",
            docs: ["Minimum size of a storage account"],
            type: "u64",
          },
        ],
      },
    },
    {
      name: "file",
      type: {
        kind: "struct",
        fields: [
          {
            name: "immutable",
            docs: ["Mutability"],
            type: "bool",
          },
          {
            name: "toBeDeleted",
            docs: ["Delete flag"],
            type: "bool",
          },
          {
            name: "deleteRequestEpoch",
            docs: ["Delete request epoch"],
            type: "u32",
          },
          {
            name: "size",
            docs: ["File size (bytes)"],
            type: "u64",
          },
          {
            name: "sha256Hash",
            docs: ["File hash (sha256)"],
            type: {
              array: ["u8", 32],
            },
          },
          {
            name: "initCounterSeed",
            docs: ["File counter seed"],
            type: "u32",
          },
          {
            name: "storageAccount",
            docs: ["Storage accout"],
            type: "publicKey",
          },
          {
            name: "name",
            docs: ["File name"],
            type: "string",
          },
        ],
      },
    },
    {
      name: "file",
      type: {
        kind: "struct",
        fields: [
          {
            name: "immutable",
            docs: ["Mutability"],
            type: "bool",
          },
          {
            name: "toBeDeleted",
            docs: ["Delete flag"],
            type: "bool",
          },
          {
            name: "deleteRequestEpoch",
            docs: ["Delete request epoch"],
            type: "u32",
          },
          {
            name: "size",
            docs: ["File size (bytes)"],
            type: "u64",
          },
          {
            name: "sha256Hash",
            docs: ["File hash (sha256)"],
            type: {
              array: ["u8", 32],
            },
          },
          {
            name: "initCounterSeed",
            docs: ["File counter seed"],
            type: "u32",
          },
          {
            name: "storageAccount",
            docs: ["Storage accout"],
            type: "publicKey",
          },
          {
            name: "name",
            docs: ["File name"],
            type: "string",
          },
        ],
      },
    },
  ],
  types: [
    {
      name: "Mode",
      type: {
        kind: "enum",
        variants: [
          {
            name: "Increment",
          },
          {
            name: "Decrement",
          },
          {
            name: "Initialize",
          },
        ],
      },
    },
  ],
  events: [
    {
      name: "StakeRefreshed",
      fields: [
        {
          name: "refreshed",
          type: "bool",
          index: false,
        },
        {
          name: "account",
          type: "publicKey",
          index: false,
        },
      ],
    },
  ],
  errors: [
    {
      code: 6000,
      name: "NotEnoughStorage",
      msg: "Not enough storage available on this Storage Account",
    },
    {
      code: 6001,
      name: "FileNameLengthExceedsLimit",
      msg: "The length of the file name exceeds the limit of 32 bytes",
    },
    {
      code: 6002,
      name: "InvalidSha256Hash",
      msg: "Invalid sha256 hash",
    },
    {
      code: 6003,
      name: "HasHadBadCsam",
      msg: "User at some point had a bad csam scan",
    },
    {
      code: 6004,
      name: "StorageAccountMarkedImmutable",
      msg: "Storage account is marked as immutable",
    },
    {
      code: 6005,
      name: "ClaimingStakeTooSoon",
      msg: "User has not waited enough time to claim stake",
    },
    {
      code: 6006,
      name: "SolanaStorageAccountNotMutable",
      msg: "The storage account needs to be marked as mutable to update last fee collection epoch",
    },
    {
      code: 6007,
      name: "RemovingTooMuchStorage",
      msg: "Attempting to decrease storage by more than is available",
    },
    {
      code: 6008,
      name: "UnsignedIntegerCastFailed",
      msg: "u128 -> u64 cast failed",
    },
    {
      code: 6009,
      name: "NonzeroRemainingFileAccounts",
      msg: "This storage account still has some file accounts associated with it that have not been deleted",
    },
    {
      code: 6010,
      name: "AccountStillInGracePeriod",
      msg: "This account is still within deletion grace period",
    },
    {
      code: 6011,
      name: "AccountNotMarkedToBeDeleted",
      msg: "This account is not marked to be deleted",
    },
    {
      code: 6012,
      name: "FileStillInGracePeriod",
      msg: "This file is still within deletion grace period",
    },
    {
      code: 6013,
      name: "FileNotMarkedToBeDeleted",
      msg: "This file is not marked to be deleted",
    },
    {
      code: 6014,
      name: "FileMarkedImmutable",
      msg: "File has been marked as immutable and cannot be edited",
    },
    {
      code: 6015,
      name: "NoStorageIncrease",
      msg: "User requested an increase of zero bytes",
    },
    {
      code: 6016,
      name: "ExceededStorageLimit",
      msg: "Requested a storage account with storage over the limit",
    },
    {
      code: 6017,
      name: "InsufficientFunds",
      msg: "User does not have enough funds to store requested number of bytes.",
    },
    {
      code: 6018,
      name: "NotEnoughStorageOnShadowDrive",
      msg: "There is not available storage on Shadow Drive. Good job!",
    },
    {
      code: 6019,
      name: "AccountTooSmall",
      msg: "Requested a storage account with storage under the limit",
    },
    {
      code: 6020,
      name: "DidNotAgreeToToS",
      msg: "User did not agree to terms of service",
    },
    {
      code: 6021,
      name: "InvalidTokenTransferAmounts",
      msg: "Invalid token transfers. Stake account nonempty.",
    },
    {
      code: 6022,
      name: "FailedToCloseAccount",
      msg: "Failed to close spl token account",
    },
    {
      code: 6023,
      name: "FailedToTransferToEmissionsWallet",
      msg: "Failed to transfer to emissions wallet",
    },
    {
      code: 6024,
      name: "FailedToTransferToEmissionsWalletFromUser",
      msg: "Failed to transfer to emissions wallet from user",
    },
    {
      code: 6025,
      name: "FailedToReturnUserFunds",
      msg: "Failed to return user funds",
    },
    {
      code: 6026,
      name: "NeedSomeFees",
      msg: "Turning on fees and passing in None for storage cost per epoch",
    },
    {
      code: 6027,
      name: "NeedSomeCrankBps",
      msg: "Turning on fees and passing in None for crank bps",
    },
    {
      code: 6028,
      name: "AlreadyMarkedForDeletion",
      msg: "This account is already marked to be deleted",
    },
    {
      code: 6029,
      name: "EmptyStakeAccount",
      msg: "User has an empty stake account and must refresh stake account before unmarking account for deletion",
    },
    {
      code: 6030,
      name: "IdentifierExceededMaxLength",
      msg: "New identifier exceeds maximum length of 64 bytes",
    },
    {
      code: 6031,
      name: "OnlyAdmin1CanChangeAdmins",
      msg: "Only admin1 can change admins",
    },
    {
      code: 6032,
      name: "OnlyOneOwnerAllowedInV1_5",
      msg: "(As part of on-chain storage optimizations, only one owner is allowed in Shadow Drive v1.5)",
    },
  ],
};