@loyal-labs/loyal-smart-accounts-core 0.1.1

package/dist/src/generated/errors/index.js

@@ -0,0 +1,2312 @@
+/**
+ * This code was GENERATED using the solita package.
+ * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
+ *
+ * See: https://github.com/metaplex-foundation/solita
+ */
+const createErrorFromCodeLookup = new Map();
+const createErrorFromNameLookup = new Map();
+/**
+ * AccountNotEmpty: 'Account is not empty'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class AccountNotEmptyError extends Error {
+    code = 0x1770;
+    name = 'AccountNotEmpty';
+    constructor() {
+        super('Account is not empty');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, AccountNotEmptyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1770, () => new AccountNotEmptyError());
+createErrorFromNameLookup.set('AccountNotEmpty', () => new AccountNotEmptyError());
+/**
+ * DuplicateSigner: 'Found multiple signers with the same pubkey'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class DuplicateSignerError extends Error {
+    code = 0x1771;
+    name = 'DuplicateSigner';
+    constructor() {
+        super('Found multiple signers with the same pubkey');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, DuplicateSignerError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1771, () => new DuplicateSignerError());
+createErrorFromNameLookup.set('DuplicateSigner', () => new DuplicateSignerError());
+/**
+ * EmptySigners: 'Signers array is empty'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class EmptySignersError extends Error {
+    code = 0x1772;
+    name = 'EmptySigners';
+    constructor() {
+        super('Signers array is empty');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, EmptySignersError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1772, () => new EmptySignersError());
+createErrorFromNameLookup.set('EmptySigners', () => new EmptySignersError());
+/**
+ * TooManySigners: 'Too many signers, can be up to 65535'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TooManySignersError extends Error {
+    code = 0x1773;
+    name = 'TooManySigners';
+    constructor() {
+        super('Too many signers, can be up to 65535');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TooManySignersError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1773, () => new TooManySignersError());
+createErrorFromNameLookup.set('TooManySigners', () => new TooManySignersError());
+/**
+ * InvalidThreshold: 'Invalid threshold, must be between 1 and number of signers with vote permissions'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidThresholdError extends Error {
+    code = 0x1774;
+    name = 'InvalidThreshold';
+    constructor() {
+        super('Invalid threshold, must be between 1 and number of signers with vote permissions');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidThresholdError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1774, () => new InvalidThresholdError());
+createErrorFromNameLookup.set('InvalidThreshold', () => new InvalidThresholdError());
+/**
+ * Unauthorized: 'Attempted to perform an unauthorized action'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class UnauthorizedError extends Error {
+    code = 0x1775;
+    name = 'Unauthorized';
+    constructor() {
+        super('Attempted to perform an unauthorized action');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, UnauthorizedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1775, () => new UnauthorizedError());
+createErrorFromNameLookup.set('Unauthorized', () => new UnauthorizedError());
+/**
+ * NotASigner: 'Provided pubkey is not a signer of the smart account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NotASignerError extends Error {
+    code = 0x1776;
+    name = 'NotASigner';
+    constructor() {
+        super('Provided pubkey is not a signer of the smart account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NotASignerError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1776, () => new NotASignerError());
+createErrorFromNameLookup.set('NotASigner', () => new NotASignerError());
+/**
+ * InvalidTransactionMessage: 'TransactionMessage is malformed.'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidTransactionMessageError extends Error {
+    code = 0x1777;
+    name = 'InvalidTransactionMessage';
+    constructor() {
+        super('TransactionMessage is malformed.');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidTransactionMessageError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1777, () => new InvalidTransactionMessageError());
+createErrorFromNameLookup.set('InvalidTransactionMessage', () => new InvalidTransactionMessageError());
+/**
+ * StaleProposal: 'Proposal is stale'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class StaleProposalError extends Error {
+    code = 0x1778;
+    name = 'StaleProposal';
+    constructor() {
+        super('Proposal is stale');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, StaleProposalError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1778, () => new StaleProposalError());
+createErrorFromNameLookup.set('StaleProposal', () => new StaleProposalError());
+/**
+ * InvalidProposalStatus: 'Invalid proposal status'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidProposalStatusError extends Error {
+    code = 0x1779;
+    name = 'InvalidProposalStatus';
+    constructor() {
+        super('Invalid proposal status');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidProposalStatusError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1779, () => new InvalidProposalStatusError());
+createErrorFromNameLookup.set('InvalidProposalStatus', () => new InvalidProposalStatusError());
+/**
+ * InvalidTransactionIndex: 'Invalid transaction index'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidTransactionIndexError extends Error {
+    code = 0x177a;
+    name = 'InvalidTransactionIndex';
+    constructor() {
+        super('Invalid transaction index');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidTransactionIndexError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177a, () => new InvalidTransactionIndexError());
+createErrorFromNameLookup.set('InvalidTransactionIndex', () => new InvalidTransactionIndexError());
+/**
+ * AlreadyApproved: 'Signer already approved the transaction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class AlreadyApprovedError extends Error {
+    code = 0x177b;
+    name = 'AlreadyApproved';
+    constructor() {
+        super('Signer already approved the transaction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, AlreadyApprovedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177b, () => new AlreadyApprovedError());
+createErrorFromNameLookup.set('AlreadyApproved', () => new AlreadyApprovedError());
+/**
+ * AlreadyRejected: 'Signer already rejected the transaction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class AlreadyRejectedError extends Error {
+    code = 0x177c;
+    name = 'AlreadyRejected';
+    constructor() {
+        super('Signer already rejected the transaction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, AlreadyRejectedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177c, () => new AlreadyRejectedError());
+createErrorFromNameLookup.set('AlreadyRejected', () => new AlreadyRejectedError());
+/**
+ * AlreadyCancelled: 'Signer already cancelled the transaction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class AlreadyCancelledError extends Error {
+    code = 0x177d;
+    name = 'AlreadyCancelled';
+    constructor() {
+        super('Signer already cancelled the transaction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, AlreadyCancelledError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177d, () => new AlreadyCancelledError());
+createErrorFromNameLookup.set('AlreadyCancelled', () => new AlreadyCancelledError());
+/**
+ * InvalidNumberOfAccounts: 'Wrong number of accounts provided'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidNumberOfAccountsError extends Error {
+    code = 0x177e;
+    name = 'InvalidNumberOfAccounts';
+    constructor() {
+        super('Wrong number of accounts provided');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidNumberOfAccountsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177e, () => new InvalidNumberOfAccountsError());
+createErrorFromNameLookup.set('InvalidNumberOfAccounts', () => new InvalidNumberOfAccountsError());
+/**
+ * InvalidAccount: 'Invalid account provided'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidAccountError extends Error {
+    code = 0x177f;
+    name = 'InvalidAccount';
+    constructor() {
+        super('Invalid account provided');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x177f, () => new InvalidAccountError());
+createErrorFromNameLookup.set('InvalidAccount', () => new InvalidAccountError());
+/**
+ * RemoveLastSigner: 'Cannot remove last signer'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class RemoveLastSignerError extends Error {
+    code = 0x1780;
+    name = 'RemoveLastSigner';
+    constructor() {
+        super('Cannot remove last signer');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, RemoveLastSignerError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1780, () => new RemoveLastSignerError());
+createErrorFromNameLookup.set('RemoveLastSigner', () => new RemoveLastSignerError());
+/**
+ * NoVoters: 'Signers don't include any voters'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NoVotersError extends Error {
+    code = 0x1781;
+    name = 'NoVoters';
+    constructor() {
+        super("Signers don't include any voters");
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NoVotersError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1781, () => new NoVotersError());
+createErrorFromNameLookup.set('NoVoters', () => new NoVotersError());
+/**
+ * NoProposers: 'Signers don't include any proposers'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NoProposersError extends Error {
+    code = 0x1782;
+    name = 'NoProposers';
+    constructor() {
+        super("Signers don't include any proposers");
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NoProposersError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1782, () => new NoProposersError());
+createErrorFromNameLookup.set('NoProposers', () => new NoProposersError());
+/**
+ * NoExecutors: 'Signers don't include any executors'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NoExecutorsError extends Error {
+    code = 0x1783;
+    name = 'NoExecutors';
+    constructor() {
+        super("Signers don't include any executors");
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NoExecutorsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1783, () => new NoExecutorsError());
+createErrorFromNameLookup.set('NoExecutors', () => new NoExecutorsError());
+/**
+ * InvalidStaleTransactionIndex: '`stale_transaction_index` must be <= `transaction_index`'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidStaleTransactionIndexError extends Error {
+    code = 0x1784;
+    name = 'InvalidStaleTransactionIndex';
+    constructor() {
+        super('`stale_transaction_index` must be <= `transaction_index`');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidStaleTransactionIndexError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1784, () => new InvalidStaleTransactionIndexError());
+createErrorFromNameLookup.set('InvalidStaleTransactionIndex', () => new InvalidStaleTransactionIndexError());
+/**
+ * NotSupportedForControlled: 'Instruction not supported for controlled smart account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NotSupportedForControlledError extends Error {
+    code = 0x1785;
+    name = 'NotSupportedForControlled';
+    constructor() {
+        super('Instruction not supported for controlled smart account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NotSupportedForControlledError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1785, () => new NotSupportedForControlledError());
+createErrorFromNameLookup.set('NotSupportedForControlled', () => new NotSupportedForControlledError());
+/**
+ * TimeLockNotReleased: 'Proposal time lock has not been released'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TimeLockNotReleasedError extends Error {
+    code = 0x1786;
+    name = 'TimeLockNotReleased';
+    constructor() {
+        super('Proposal time lock has not been released');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TimeLockNotReleasedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1786, () => new TimeLockNotReleasedError());
+createErrorFromNameLookup.set('TimeLockNotReleased', () => new TimeLockNotReleasedError());
+/**
+ * NoActions: 'Config transaction must have at least one action'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NoActionsError extends Error {
+    code = 0x1787;
+    name = 'NoActions';
+    constructor() {
+        super('Config transaction must have at least one action');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NoActionsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1787, () => new NoActionsError());
+createErrorFromNameLookup.set('NoActions', () => new NoActionsError());
+/**
+ * MissingAccount: 'Missing account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MissingAccountError extends Error {
+    code = 0x1788;
+    name = 'MissingAccount';
+    constructor() {
+        super('Missing account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, MissingAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1788, () => new MissingAccountError());
+createErrorFromNameLookup.set('MissingAccount', () => new MissingAccountError());
+/**
+ * InvalidMint: 'Invalid mint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidMintError extends Error {
+    code = 0x1789;
+    name = 'InvalidMint';
+    constructor() {
+        super('Invalid mint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidMintError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1789, () => new InvalidMintError());
+createErrorFromNameLookup.set('InvalidMint', () => new InvalidMintError());
+/**
+ * InvalidDestination: 'Invalid destination'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidDestinationError extends Error {
+    code = 0x178a;
+    name = 'InvalidDestination';
+    constructor() {
+        super('Invalid destination');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidDestinationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178a, () => new InvalidDestinationError());
+createErrorFromNameLookup.set('InvalidDestination', () => new InvalidDestinationError());
+/**
+ * SpendingLimitExceeded: 'Spending limit exceeded'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitExceededError extends Error {
+    code = 0x178b;
+    name = 'SpendingLimitExceeded';
+    constructor() {
+        super('Spending limit exceeded');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitExceededError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178b, () => new SpendingLimitExceededError());
+createErrorFromNameLookup.set('SpendingLimitExceeded', () => new SpendingLimitExceededError());
+/**
+ * DecimalsMismatch: 'Decimals don't match the mint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class DecimalsMismatchError extends Error {
+    code = 0x178c;
+    name = 'DecimalsMismatch';
+    constructor() {
+        super("Decimals don't match the mint");
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, DecimalsMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178c, () => new DecimalsMismatchError());
+createErrorFromNameLookup.set('DecimalsMismatch', () => new DecimalsMismatchError());
+/**
+ * UnknownPermission: 'Signer has unknown permission'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class UnknownPermissionError extends Error {
+    code = 0x178d;
+    name = 'UnknownPermission';
+    constructor() {
+        super('Signer has unknown permission');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, UnknownPermissionError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178d, () => new UnknownPermissionError());
+createErrorFromNameLookup.set('UnknownPermission', () => new UnknownPermissionError());
+/**
+ * ProtectedAccount: 'Account is protected, it cannot be passed into a CPI as writable'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProtectedAccountError extends Error {
+    code = 0x178e;
+    name = 'ProtectedAccount';
+    constructor() {
+        super('Account is protected, it cannot be passed into a CPI as writable');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProtectedAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178e, () => new ProtectedAccountError());
+createErrorFromNameLookup.set('ProtectedAccount', () => new ProtectedAccountError());
+/**
+ * TimeLockExceedsMaxAllowed: 'Time lock exceeds the maximum allowed (90 days)'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TimeLockExceedsMaxAllowedError extends Error {
+    code = 0x178f;
+    name = 'TimeLockExceedsMaxAllowed';
+    constructor() {
+        super('Time lock exceeds the maximum allowed (90 days)');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TimeLockExceedsMaxAllowedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x178f, () => new TimeLockExceedsMaxAllowedError());
+createErrorFromNameLookup.set('TimeLockExceedsMaxAllowed', () => new TimeLockExceedsMaxAllowedError());
+/**
+ * IllegalAccountOwner: 'Account is not owned by Smart Account program'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class IllegalAccountOwnerError extends Error {
+    code = 0x1790;
+    name = 'IllegalAccountOwner';
+    constructor() {
+        super('Account is not owned by Smart Account program');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, IllegalAccountOwnerError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1790, () => new IllegalAccountOwnerError());
+createErrorFromNameLookup.set('IllegalAccountOwner', () => new IllegalAccountOwnerError());
+/**
+ * RentReclamationDisabled: 'Rent reclamation is disabled for this smart account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class RentReclamationDisabledError extends Error {
+    code = 0x1791;
+    name = 'RentReclamationDisabled';
+    constructor() {
+        super('Rent reclamation is disabled for this smart account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, RentReclamationDisabledError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1791, () => new RentReclamationDisabledError());
+createErrorFromNameLookup.set('RentReclamationDisabled', () => new RentReclamationDisabledError());
+/**
+ * InvalidRentCollector: 'Invalid rent collector address'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidRentCollectorError extends Error {
+    code = 0x1792;
+    name = 'InvalidRentCollector';
+    constructor() {
+        super('Invalid rent collector address');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidRentCollectorError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1792, () => new InvalidRentCollectorError());
+createErrorFromNameLookup.set('InvalidRentCollector', () => new InvalidRentCollectorError());
+/**
+ * ProposalForAnotherSmartAccount: 'Proposal is for another smart account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProposalForAnotherSmartAccountError extends Error {
+    code = 0x1793;
+    name = 'ProposalForAnotherSmartAccount';
+    constructor() {
+        super('Proposal is for another smart account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProposalForAnotherSmartAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1793, () => new ProposalForAnotherSmartAccountError());
+createErrorFromNameLookup.set('ProposalForAnotherSmartAccount', () => new ProposalForAnotherSmartAccountError());
+/**
+ * TransactionForAnotherSmartAccount: 'Transaction is for another smart account'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TransactionForAnotherSmartAccountError extends Error {
+    code = 0x1794;
+    name = 'TransactionForAnotherSmartAccount';
+    constructor() {
+        super('Transaction is for another smart account');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TransactionForAnotherSmartAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1794, () => new TransactionForAnotherSmartAccountError());
+createErrorFromNameLookup.set('TransactionForAnotherSmartAccount', () => new TransactionForAnotherSmartAccountError());
+/**
+ * TransactionNotMatchingProposal: 'Transaction doesn't match proposal'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TransactionNotMatchingProposalError extends Error {
+    code = 0x1795;
+    name = 'TransactionNotMatchingProposal';
+    constructor() {
+        super("Transaction doesn't match proposal");
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TransactionNotMatchingProposalError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1795, () => new TransactionNotMatchingProposalError());
+createErrorFromNameLookup.set('TransactionNotMatchingProposal', () => new TransactionNotMatchingProposalError());
+/**
+ * TransactionNotLastInBatch: 'Transaction is not last in batch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TransactionNotLastInBatchError extends Error {
+    code = 0x1796;
+    name = 'TransactionNotLastInBatch';
+    constructor() {
+        super('Transaction is not last in batch');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TransactionNotLastInBatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1796, () => new TransactionNotLastInBatchError());
+createErrorFromNameLookup.set('TransactionNotLastInBatch', () => new TransactionNotLastInBatchError());
+/**
+ * BatchNotEmpty: 'Batch is not empty'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class BatchNotEmptyError extends Error {
+    code = 0x1797;
+    name = 'BatchNotEmpty';
+    constructor() {
+        super('Batch is not empty');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, BatchNotEmptyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1797, () => new BatchNotEmptyError());
+createErrorFromNameLookup.set('BatchNotEmpty', () => new BatchNotEmptyError());
+/**
+ * SpendingLimitInvalidAmount: 'Invalid SpendingLimit amount'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvalidAmountError extends Error {
+    code = 0x1798;
+    name = 'SpendingLimitInvalidAmount';
+    constructor() {
+        super('Invalid SpendingLimit amount');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvalidAmountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1798, () => new SpendingLimitInvalidAmountError());
+createErrorFromNameLookup.set('SpendingLimitInvalidAmount', () => new SpendingLimitInvalidAmountError());
+/**
+ * InvalidInstructionArgs: 'Invalid Instruction Arguments'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidInstructionArgsError extends Error {
+    code = 0x1799;
+    name = 'InvalidInstructionArgs';
+    constructor() {
+        super('Invalid Instruction Arguments');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidInstructionArgsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x1799, () => new InvalidInstructionArgsError());
+createErrorFromNameLookup.set('InvalidInstructionArgs', () => new InvalidInstructionArgsError());
+/**
+ * FinalBufferHashMismatch: 'Final message buffer hash doesnt match the expected hash'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class FinalBufferHashMismatchError extends Error {
+    code = 0x179a;
+    name = 'FinalBufferHashMismatch';
+    constructor() {
+        super('Final message buffer hash doesnt match the expected hash');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, FinalBufferHashMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179a, () => new FinalBufferHashMismatchError());
+createErrorFromNameLookup.set('FinalBufferHashMismatch', () => new FinalBufferHashMismatchError());
+/**
+ * FinalBufferSizeExceeded: 'Final buffer size cannot exceed 4000 bytes'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class FinalBufferSizeExceededError extends Error {
+    code = 0x179b;
+    name = 'FinalBufferSizeExceeded';
+    constructor() {
+        super('Final buffer size cannot exceed 4000 bytes');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, FinalBufferSizeExceededError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179b, () => new FinalBufferSizeExceededError());
+createErrorFromNameLookup.set('FinalBufferSizeExceeded', () => new FinalBufferSizeExceededError());
+/**
+ * FinalBufferSizeMismatch: 'Final buffer size mismatch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class FinalBufferSizeMismatchError extends Error {
+    code = 0x179c;
+    name = 'FinalBufferSizeMismatch';
+    constructor() {
+        super('Final buffer size mismatch');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, FinalBufferSizeMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179c, () => new FinalBufferSizeMismatchError());
+createErrorFromNameLookup.set('FinalBufferSizeMismatch', () => new FinalBufferSizeMismatchError());
+/**
+ * SmartAccountCreateDeprecated: 'smart_account_create has been deprecated. Use smart_account_create_v2 instead.'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SmartAccountCreateDeprecatedError extends Error {
+    code = 0x179d;
+    name = 'SmartAccountCreateDeprecated';
+    constructor() {
+        super('smart_account_create has been deprecated. Use smart_account_create_v2 instead.');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SmartAccountCreateDeprecatedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179d, () => new SmartAccountCreateDeprecatedError());
+createErrorFromNameLookup.set('SmartAccountCreateDeprecated', () => new SmartAccountCreateDeprecatedError());
+/**
+ * ThresholdNotReached: 'Signers do not reach consensus threshold'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ThresholdNotReachedError extends Error {
+    code = 0x179e;
+    name = 'ThresholdNotReached';
+    constructor() {
+        super('Signers do not reach consensus threshold');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ThresholdNotReachedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179e, () => new ThresholdNotReachedError());
+createErrorFromNameLookup.set('ThresholdNotReached', () => new ThresholdNotReachedError());
+/**
+ * InvalidSignerCount: 'Invalid number of signer accounts. Must be greater or equal to the threshold'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidSignerCountError extends Error {
+    code = 0x179f;
+    name = 'InvalidSignerCount';
+    constructor() {
+        super('Invalid number of signer accounts. Must be greater or equal to the threshold');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidSignerCountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x179f, () => new InvalidSignerCountError());
+createErrorFromNameLookup.set('InvalidSignerCount', () => new InvalidSignerCountError());
+/**
+ * MissingSignature: 'Missing signature'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class MissingSignatureError extends Error {
+    code = 0x17a0;
+    name = 'MissingSignature';
+    constructor() {
+        super('Missing signature');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, MissingSignatureError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a0, () => new MissingSignatureError());
+createErrorFromNameLookup.set('MissingSignature', () => new MissingSignatureError());
+/**
+ * InsufficientAggregatePermissions: 'Insufficient aggregate permissions across signing members'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InsufficientAggregatePermissionsError extends Error {
+    code = 0x17a1;
+    name = 'InsufficientAggregatePermissions';
+    constructor() {
+        super('Insufficient aggregate permissions across signing members');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InsufficientAggregatePermissionsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a1, () => new InsufficientAggregatePermissionsError());
+createErrorFromNameLookup.set('InsufficientAggregatePermissions', () => new InsufficientAggregatePermissionsError());
+/**
+ * InsufficientVotePermissions: 'Insufficient vote permissions across signing members'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InsufficientVotePermissionsError extends Error {
+    code = 0x17a2;
+    name = 'InsufficientVotePermissions';
+    constructor() {
+        super('Insufficient vote permissions across signing members');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InsufficientVotePermissionsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a2, () => new InsufficientVotePermissionsError());
+createErrorFromNameLookup.set('InsufficientVotePermissions', () => new InsufficientVotePermissionsError());
+/**
+ * TimeLockNotZero: 'Smart account must not be time locked'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TimeLockNotZeroError extends Error {
+    code = 0x17a3;
+    name = 'TimeLockNotZero';
+    constructor() {
+        super('Smart account must not be time locked');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TimeLockNotZeroError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a3, () => new TimeLockNotZeroError());
+createErrorFromNameLookup.set('TimeLockNotZero', () => new TimeLockNotZeroError());
+/**
+ * NotImplemented: 'Feature not implemented'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class NotImplementedError extends Error {
+    code = 0x17a4;
+    name = 'NotImplemented';
+    constructor() {
+        super('Feature not implemented');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NotImplementedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a4, () => new NotImplementedError());
+createErrorFromNameLookup.set('NotImplemented', () => new NotImplementedError());
+/**
+ * SpendingLimitInvalidCadenceConfiguration: 'Invalid cadence configuration'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvalidCadenceConfigurationError extends Error {
+    code = 0x17a5;
+    name = 'SpendingLimitInvalidCadenceConfiguration';
+    constructor() {
+        super('Invalid cadence configuration');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvalidCadenceConfigurationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a5, () => new SpendingLimitInvalidCadenceConfigurationError());
+createErrorFromNameLookup.set('SpendingLimitInvalidCadenceConfiguration', () => new SpendingLimitInvalidCadenceConfigurationError());
+/**
+ * InvalidDataConstraint: 'Invalid data constraint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidDataConstraintError extends Error {
+    code = 0x17a6;
+    name = 'InvalidDataConstraint';
+    constructor() {
+        super('Invalid data constraint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidDataConstraintError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a6, () => new InvalidDataConstraintError());
+createErrorFromNameLookup.set('InvalidDataConstraint', () => new InvalidDataConstraintError());
+/**
+ * InvalidPayload: 'Invalid payload'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidPayloadError extends Error {
+    code = 0x17a7;
+    name = 'InvalidPayload';
+    constructor() {
+        super('Invalid payload');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidPayloadError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a7, () => new InvalidPayloadError());
+createErrorFromNameLookup.set('InvalidPayload', () => new InvalidPayloadError());
+/**
+ * ProtectedInstruction: 'Protected instruction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProtectedInstructionError extends Error {
+    code = 0x17a8;
+    name = 'ProtectedInstruction';
+    constructor() {
+        super('Protected instruction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProtectedInstructionError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a8, () => new ProtectedInstructionError());
+createErrorFromNameLookup.set('ProtectedInstruction', () => new ProtectedInstructionError());
+/**
+ * PlaceholderError: 'Placeholder error'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PlaceholderErrorError extends Error {
+    code = 0x17a9;
+    name = 'PlaceholderError';
+    constructor() {
+        super('Placeholder error');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PlaceholderErrorError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17a9, () => new PlaceholderErrorError());
+createErrorFromNameLookup.set('PlaceholderError', () => new PlaceholderErrorError());
+/**
+ * InvalidPolicyPayload: 'Invalid policy payload'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidPolicyPayloadError extends Error {
+    code = 0x17aa;
+    name = 'InvalidPolicyPayload';
+    constructor() {
+        super('Invalid policy payload');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidPolicyPayloadError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17aa, () => new InvalidPolicyPayloadError());
+createErrorFromNameLookup.set('InvalidPolicyPayload', () => new InvalidPolicyPayloadError());
+/**
+ * InvalidEmptyPolicy: 'Invalid empty policy'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InvalidEmptyPolicyError extends Error {
+    code = 0x17ab;
+    name = 'InvalidEmptyPolicy';
+    constructor() {
+        super('Invalid empty policy');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InvalidEmptyPolicyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ab, () => new InvalidEmptyPolicyError());
+createErrorFromNameLookup.set('InvalidEmptyPolicy', () => new InvalidEmptyPolicyError());
+/**
+ * TransactionForAnotherPolicy: 'Transaction is for another policy'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TransactionForAnotherPolicyError extends Error {
+    code = 0x17ac;
+    name = 'TransactionForAnotherPolicy';
+    constructor() {
+        super('Transaction is for another policy');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TransactionForAnotherPolicyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ac, () => new TransactionForAnotherPolicyError());
+createErrorFromNameLookup.set('TransactionForAnotherPolicy', () => new TransactionForAnotherPolicyError());
+/**
+ * ProgramInteractionAsyncPayloadNotAllowedWithSyncTransaction: 'Program interaction sync payload not allowed with async transaction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionAsyncPayloadNotAllowedWithSyncTransactionError extends Error {
+    code = 0x17ad;
+    name = 'ProgramInteractionAsyncPayloadNotAllowedWithSyncTransaction';
+    constructor() {
+        super('Program interaction sync payload not allowed with async transaction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionAsyncPayloadNotAllowedWithSyncTransactionError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ad, () => new ProgramInteractionAsyncPayloadNotAllowedWithSyncTransactionError());
+createErrorFromNameLookup.set('ProgramInteractionAsyncPayloadNotAllowedWithSyncTransaction', () => new ProgramInteractionAsyncPayloadNotAllowedWithSyncTransactionError());
+/**
+ * ProgramInteractionSyncPayloadNotAllowedWithAsyncTransaction: 'Program interaction sync payload not allowed with sync transaction'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionSyncPayloadNotAllowedWithAsyncTransactionError extends Error {
+    code = 0x17ae;
+    name = 'ProgramInteractionSyncPayloadNotAllowedWithAsyncTransaction';
+    constructor() {
+        super('Program interaction sync payload not allowed with sync transaction');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionSyncPayloadNotAllowedWithAsyncTransactionError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ae, () => new ProgramInteractionSyncPayloadNotAllowedWithAsyncTransactionError());
+createErrorFromNameLookup.set('ProgramInteractionSyncPayloadNotAllowedWithAsyncTransaction', () => new ProgramInteractionSyncPayloadNotAllowedWithAsyncTransactionError());
+/**
+ * ProgramInteractionDataTooShort: 'Program interaction data constraint failed: instruction data too short'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionDataTooShortError extends Error {
+    code = 0x17af;
+    name = 'ProgramInteractionDataTooShort';
+    constructor() {
+        super('Program interaction data constraint failed: instruction data too short');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionDataTooShortError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17af, () => new ProgramInteractionDataTooShortError());
+createErrorFromNameLookup.set('ProgramInteractionDataTooShort', () => new ProgramInteractionDataTooShortError());
+/**
+ * ProgramInteractionInvalidNumericValue: 'Program interaction data constraint failed: invalid numeric value'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionInvalidNumericValueError extends Error {
+    code = 0x17b0;
+    name = 'ProgramInteractionInvalidNumericValue';
+    constructor() {
+        super('Program interaction data constraint failed: invalid numeric value');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionInvalidNumericValueError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b0, () => new ProgramInteractionInvalidNumericValueError());
+createErrorFromNameLookup.set('ProgramInteractionInvalidNumericValue', () => new ProgramInteractionInvalidNumericValueError());
+/**
+ * ProgramInteractionInvalidByteSequence: 'Program interaction data constraint failed: invalid byte sequence'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionInvalidByteSequenceError extends Error {
+    code = 0x17b1;
+    name = 'ProgramInteractionInvalidByteSequence';
+    constructor() {
+        super('Program interaction data constraint failed: invalid byte sequence');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionInvalidByteSequenceError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b1, () => new ProgramInteractionInvalidByteSequenceError());
+createErrorFromNameLookup.set('ProgramInteractionInvalidByteSequence', () => new ProgramInteractionInvalidByteSequenceError());
+/**
+ * ProgramInteractionUnsupportedSliceOperator: 'Program interaction data constraint failed: unsupported operator for byte slice'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionUnsupportedSliceOperatorError extends Error {
+    code = 0x17b2;
+    name = 'ProgramInteractionUnsupportedSliceOperator';
+    constructor() {
+        super('Program interaction data constraint failed: unsupported operator for byte slice');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionUnsupportedSliceOperatorError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b2, () => new ProgramInteractionUnsupportedSliceOperatorError());
+createErrorFromNameLookup.set('ProgramInteractionUnsupportedSliceOperator', () => new ProgramInteractionUnsupportedSliceOperatorError());
+/**
+ * ProgramInteractionDataParsingError: 'Program interaction constraint failed: instruction data parsing error'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionDataParsingErrorError extends Error {
+    code = 0x17b3;
+    name = 'ProgramInteractionDataParsingError';
+    constructor() {
+        super('Program interaction constraint failed: instruction data parsing error');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionDataParsingErrorError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b3, () => new ProgramInteractionDataParsingErrorError());
+createErrorFromNameLookup.set('ProgramInteractionDataParsingError', () => new ProgramInteractionDataParsingErrorError());
+/**
+ * ProgramInteractionProgramIdMismatch: 'Program interaction constraint failed: program ID mismatch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionProgramIdMismatchError extends Error {
+    code = 0x17b4;
+    name = 'ProgramInteractionProgramIdMismatch';
+    constructor() {
+        super('Program interaction constraint failed: program ID mismatch');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionProgramIdMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b4, () => new ProgramInteractionProgramIdMismatchError());
+createErrorFromNameLookup.set('ProgramInteractionProgramIdMismatch', () => new ProgramInteractionProgramIdMismatchError());
+/**
+ * ProgramInteractionAccountConstraintViolated: 'Program interaction constraint violation: account constraint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionAccountConstraintViolatedError extends Error {
+    code = 0x17b5;
+    name = 'ProgramInteractionAccountConstraintViolated';
+    constructor() {
+        super('Program interaction constraint violation: account constraint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionAccountConstraintViolatedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b5, () => new ProgramInteractionAccountConstraintViolatedError());
+createErrorFromNameLookup.set('ProgramInteractionAccountConstraintViolated', () => new ProgramInteractionAccountConstraintViolatedError());
+/**
+ * ProgramInteractionConstraintIndexOutOfBounds: 'Program interaction constraint violation: instruction constraint index out of bounds'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionConstraintIndexOutOfBoundsError extends Error {
+    code = 0x17b6;
+    name = 'ProgramInteractionConstraintIndexOutOfBounds';
+    constructor() {
+        super('Program interaction constraint violation: instruction constraint index out of bounds');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionConstraintIndexOutOfBoundsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b6, () => new ProgramInteractionConstraintIndexOutOfBoundsError());
+createErrorFromNameLookup.set('ProgramInteractionConstraintIndexOutOfBounds', () => new ProgramInteractionConstraintIndexOutOfBoundsError());
+/**
+ * ProgramInteractionInstructionCountMismatch: 'Program interaction constraint violation: instruction count mismatch'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionInstructionCountMismatchError extends Error {
+    code = 0x17b7;
+    name = 'ProgramInteractionInstructionCountMismatch';
+    constructor() {
+        super('Program interaction constraint violation: instruction count mismatch');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionInstructionCountMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b7, () => new ProgramInteractionInstructionCountMismatchError());
+createErrorFromNameLookup.set('ProgramInteractionInstructionCountMismatch', () => new ProgramInteractionInstructionCountMismatchError());
+/**
+ * ProgramInteractionInsufficientLamportAllowance: 'Program interaction constraint violation: insufficient remaining lamport allowance'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionInsufficientLamportAllowanceError extends Error {
+    code = 0x17b8;
+    name = 'ProgramInteractionInsufficientLamportAllowance';
+    constructor() {
+        super('Program interaction constraint violation: insufficient remaining lamport allowance');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionInsufficientLamportAllowanceError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b8, () => new ProgramInteractionInsufficientLamportAllowanceError());
+createErrorFromNameLookup.set('ProgramInteractionInsufficientLamportAllowance', () => new ProgramInteractionInsufficientLamportAllowanceError());
+/**
+ * ProgramInteractionInsufficientTokenAllowance: 'Program interaction constraint violation: insufficient remaining token allowance'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionInsufficientTokenAllowanceError extends Error {
+    code = 0x17b9;
+    name = 'ProgramInteractionInsufficientTokenAllowance';
+    constructor() {
+        super('Program interaction constraint violation: insufficient remaining token allowance');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionInsufficientTokenAllowanceError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17b9, () => new ProgramInteractionInsufficientTokenAllowanceError());
+createErrorFromNameLookup.set('ProgramInteractionInsufficientTokenAllowance', () => new ProgramInteractionInsufficientTokenAllowanceError());
+/**
+ * ProgramInteractionModifiedIllegalBalance: 'Program interaction constraint violation: modified illegal balance'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionModifiedIllegalBalanceError extends Error {
+    code = 0x17ba;
+    name = 'ProgramInteractionModifiedIllegalBalance';
+    constructor() {
+        super('Program interaction constraint violation: modified illegal balance');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionModifiedIllegalBalanceError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ba, () => new ProgramInteractionModifiedIllegalBalanceError());
+createErrorFromNameLookup.set('ProgramInteractionModifiedIllegalBalance', () => new ProgramInteractionModifiedIllegalBalanceError());
+/**
+ * ProgramInteractionIllegalTokenAccountModification: 'Program interaction constraint violation: illegal token account modification'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionIllegalTokenAccountModificationError extends Error {
+    code = 0x17bb;
+    name = 'ProgramInteractionIllegalTokenAccountModification';
+    constructor() {
+        super('Program interaction constraint violation: illegal token account modification');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionIllegalTokenAccountModificationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17bb, () => new ProgramInteractionIllegalTokenAccountModificationError());
+createErrorFromNameLookup.set('ProgramInteractionIllegalTokenAccountModification', () => new ProgramInteractionIllegalTokenAccountModificationError());
+/**
+ * ProgramInteractionDuplicateSpendingLimit: 'Program interaction invariant violation: duplicate spending limit for the same mint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionDuplicateSpendingLimitError extends Error {
+    code = 0x17bc;
+    name = 'ProgramInteractionDuplicateSpendingLimit';
+    constructor() {
+        super('Program interaction invariant violation: duplicate spending limit for the same mint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionDuplicateSpendingLimitError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17bc, () => new ProgramInteractionDuplicateSpendingLimitError());
+createErrorFromNameLookup.set('ProgramInteractionDuplicateSpendingLimit', () => new ProgramInteractionDuplicateSpendingLimitError());
+/**
+ * ProgramInteractionTooManyInstructionConstraints: 'Program interaction constraint violation: too many instruction constraints. Max is 20'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionTooManyInstructionConstraintsError extends Error {
+    code = 0x17bd;
+    name = 'ProgramInteractionTooManyInstructionConstraints';
+    constructor() {
+        super('Program interaction constraint violation: too many instruction constraints. Max is 20');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionTooManyInstructionConstraintsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17bd, () => new ProgramInteractionTooManyInstructionConstraintsError());
+createErrorFromNameLookup.set('ProgramInteractionTooManyInstructionConstraints', () => new ProgramInteractionTooManyInstructionConstraintsError());
+/**
+ * ProgramInteractionTooManySpendingLimits: 'Program interaction constraint violation: too many spending limits. Max is 10'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionTooManySpendingLimitsError extends Error {
+    code = 0x17be;
+    name = 'ProgramInteractionTooManySpendingLimits';
+    constructor() {
+        super('Program interaction constraint violation: too many spending limits. Max is 10');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionTooManySpendingLimitsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17be, () => new ProgramInteractionTooManySpendingLimitsError());
+createErrorFromNameLookup.set('ProgramInteractionTooManySpendingLimits', () => new ProgramInteractionTooManySpendingLimitsError());
+/**
+ * ProgramInteractionTemplateHookError: 'Program interaction hook violation: template hook error'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionTemplateHookErrorError extends Error {
+    code = 0x17bf;
+    name = 'ProgramInteractionTemplateHookError';
+    constructor() {
+        super('Program interaction hook violation: template hook error');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionTemplateHookErrorError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17bf, () => new ProgramInteractionTemplateHookErrorError());
+createErrorFromNameLookup.set('ProgramInteractionTemplateHookError', () => new ProgramInteractionTemplateHookErrorError());
+/**
+ * ProgramInteractionHookAuthorityCannotBePartOfHookAccounts: 'Program interaction hook violation: hook authority cannot be part of hook accounts'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ProgramInteractionHookAuthorityCannotBePartOfHookAccountsError extends Error {
+    code = 0x17c0;
+    name = 'ProgramInteractionHookAuthorityCannotBePartOfHookAccounts';
+    constructor() {
+        super('Program interaction hook violation: hook authority cannot be part of hook accounts');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProgramInteractionHookAuthorityCannotBePartOfHookAccountsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c0, () => new ProgramInteractionHookAuthorityCannotBePartOfHookAccountsError());
+createErrorFromNameLookup.set('ProgramInteractionHookAuthorityCannotBePartOfHookAccounts', () => new ProgramInteractionHookAuthorityCannotBePartOfHookAccountsError());
+/**
+ * SpendingLimitNotActive: 'Spending limit is not active'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitNotActiveError extends Error {
+    code = 0x17c1;
+    name = 'SpendingLimitNotActive';
+    constructor() {
+        super('Spending limit is not active');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitNotActiveError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c1, () => new SpendingLimitNotActiveError());
+createErrorFromNameLookup.set('SpendingLimitNotActive', () => new SpendingLimitNotActiveError());
+/**
+ * SpendingLimitExpired: 'Spending limit is expired'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitExpiredError extends Error {
+    code = 0x17c2;
+    name = 'SpendingLimitExpired';
+    constructor() {
+        super('Spending limit is expired');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitExpiredError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c2, () => new SpendingLimitExpiredError());
+createErrorFromNameLookup.set('SpendingLimitExpired', () => new SpendingLimitExpiredError());
+/**
+ * SpendingLimitPolicyInvariantAccumulateUnused: 'Spending limit policy invariant violation: usage state cannot be Some() if accumulate_unused is true'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitPolicyInvariantAccumulateUnusedError extends Error {
+    code = 0x17c3;
+    name = 'SpendingLimitPolicyInvariantAccumulateUnused';
+    constructor() {
+        super('Spending limit policy invariant violation: usage state cannot be Some() if accumulate_unused is true');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitPolicyInvariantAccumulateUnusedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c3, () => new SpendingLimitPolicyInvariantAccumulateUnusedError());
+createErrorFromNameLookup.set('SpendingLimitPolicyInvariantAccumulateUnused', () => new SpendingLimitPolicyInvariantAccumulateUnusedError());
+/**
+ * SpendingLimitViolatesExactQuantityConstraint: 'Amount violates exact quantity constraint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitViolatesExactQuantityConstraintError extends Error {
+    code = 0x17c4;
+    name = 'SpendingLimitViolatesExactQuantityConstraint';
+    constructor() {
+        super('Amount violates exact quantity constraint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitViolatesExactQuantityConstraintError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c4, () => new SpendingLimitViolatesExactQuantityConstraintError());
+createErrorFromNameLookup.set('SpendingLimitViolatesExactQuantityConstraint', () => new SpendingLimitViolatesExactQuantityConstraintError());
+/**
+ * SpendingLimitViolatesMaxPerUseConstraint: 'Amount violates max per use constraint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitViolatesMaxPerUseConstraintError extends Error {
+    code = 0x17c5;
+    name = 'SpendingLimitViolatesMaxPerUseConstraint';
+    constructor() {
+        super('Amount violates max per use constraint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitViolatesMaxPerUseConstraintError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c5, () => new SpendingLimitViolatesMaxPerUseConstraintError());
+createErrorFromNameLookup.set('SpendingLimitViolatesMaxPerUseConstraint', () => new SpendingLimitViolatesMaxPerUseConstraintError());
+/**
+ * SpendingLimitInsufficientRemainingAmount: 'Spending limit is insufficient'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInsufficientRemainingAmountError extends Error {
+    code = 0x17c6;
+    name = 'SpendingLimitInsufficientRemainingAmount';
+    constructor() {
+        super('Spending limit is insufficient');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInsufficientRemainingAmountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c6, () => new SpendingLimitInsufficientRemainingAmountError());
+createErrorFromNameLookup.set('SpendingLimitInsufficientRemainingAmount', () => new SpendingLimitInsufficientRemainingAmountError());
+/**
+ * SpendingLimitInvariantMaxPerPeriodZero: 'Spending limit invariant violation: max per period must be non-zero'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantMaxPerPeriodZeroError extends Error {
+    code = 0x17c7;
+    name = 'SpendingLimitInvariantMaxPerPeriodZero';
+    constructor() {
+        super('Spending limit invariant violation: max per period must be non-zero');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantMaxPerPeriodZeroError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c7, () => new SpendingLimitInvariantMaxPerPeriodZeroError());
+createErrorFromNameLookup.set('SpendingLimitInvariantMaxPerPeriodZero', () => new SpendingLimitInvariantMaxPerPeriodZeroError());
+/**
+ * SpendingLimitInvariantStartTimePositive: 'Spending limit invariant violation: start time must be positive'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantStartTimePositiveError extends Error {
+    code = 0x17c8;
+    name = 'SpendingLimitInvariantStartTimePositive';
+    constructor() {
+        super('Spending limit invariant violation: start time must be positive');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantStartTimePositiveError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c8, () => new SpendingLimitInvariantStartTimePositiveError());
+createErrorFromNameLookup.set('SpendingLimitInvariantStartTimePositive', () => new SpendingLimitInvariantStartTimePositiveError());
+/**
+ * SpendingLimitInvariantExpirationSmallerThanStart: 'Spending limit invariant violation: expiration must be greater than start'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantExpirationSmallerThanStartError extends Error {
+    code = 0x17c9;
+    name = 'SpendingLimitInvariantExpirationSmallerThanStart';
+    constructor() {
+        super('Spending limit invariant violation: expiration must be greater than start');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantExpirationSmallerThanStartError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17c9, () => new SpendingLimitInvariantExpirationSmallerThanStartError());
+createErrorFromNameLookup.set('SpendingLimitInvariantExpirationSmallerThanStart', () => new SpendingLimitInvariantExpirationSmallerThanStartError());
+/**
+ * SpendingLimitInvariantOverflowEnabledMustHaveExpiration: 'Spending limit invariant violation: overflow enabled must have expiration'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantOverflowEnabledMustHaveExpirationError extends Error {
+    code = 0x17ca;
+    name = 'SpendingLimitInvariantOverflowEnabledMustHaveExpiration';
+    constructor() {
+        super('Spending limit invariant violation: overflow enabled must have expiration');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantOverflowEnabledMustHaveExpirationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ca, () => new SpendingLimitInvariantOverflowEnabledMustHaveExpirationError());
+createErrorFromNameLookup.set('SpendingLimitInvariantOverflowEnabledMustHaveExpiration', () => new SpendingLimitInvariantOverflowEnabledMustHaveExpirationError());
+/**
+ * SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabled: 'Spending limit invariant violation: one time period cannot have overflow enabled'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabledError extends Error {
+    code = 0x17cb;
+    name = 'SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabled';
+    constructor() {
+        super('Spending limit invariant violation: one time period cannot have overflow enabled');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabledError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17cb, () => new SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabledError());
+createErrorFromNameLookup.set('SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabled', () => new SpendingLimitInvariantOneTimePeriodCannotHaveOverflowEnabledError());
+/**
+ * SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmount: 'Spending limit invariant violation: remaining amount must be less than max amount'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmountError extends Error {
+    code = 0x17cc;
+    name = 'SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmount';
+    constructor() {
+        super('Spending limit invariant violation: remaining amount must be less than max amount');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17cc, () => new SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmountError());
+createErrorFromNameLookup.set('SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmount', () => new SpendingLimitInvariantOverflowRemainingAmountGreaterThanMaxAmountError());
+/**
+ * SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriod: 'Spending limit invariant violation: remaining amount must be less than or equal to max per period'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriodError extends Error {
+    code = 0x17cd;
+    name = 'SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriod';
+    constructor() {
+        super('Spending limit invariant violation: remaining amount must be less than or equal to max per period');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriodError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17cd, () => new SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriodError());
+createErrorFromNameLookup.set('SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriod', () => new SpendingLimitInvariantRemainingAmountGreaterThanMaxPerPeriodError());
+/**
+ * SpendingLimitInvariantExactQuantityMaxPerUseZero: 'Spending limit invariant violation: exact quantity must have max per use non-zero'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantExactQuantityMaxPerUseZeroError extends Error {
+    code = 0x17ce;
+    name = 'SpendingLimitInvariantExactQuantityMaxPerUseZero';
+    constructor() {
+        super('Spending limit invariant violation: exact quantity must have max per use non-zero');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantExactQuantityMaxPerUseZeroError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ce, () => new SpendingLimitInvariantExactQuantityMaxPerUseZeroError());
+createErrorFromNameLookup.set('SpendingLimitInvariantExactQuantityMaxPerUseZero', () => new SpendingLimitInvariantExactQuantityMaxPerUseZeroError());
+/**
+ * SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriod: 'Spending limit invariant violation: max per use must be less than or equal to max per period'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriodError extends Error {
+    code = 0x17cf;
+    name = 'SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriod';
+    constructor() {
+        super('Spending limit invariant violation: max per use must be less than or equal to max per period');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriodError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17cf, () => new SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriodError());
+createErrorFromNameLookup.set('SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriod', () => new SpendingLimitInvariantMaxPerUseGreaterThanMaxPerPeriodError());
+/**
+ * SpendingLimitInvariantCustomPeriodNegative: 'Spending limit invariant violation: custom period must be positive'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantCustomPeriodNegativeError extends Error {
+    code = 0x17d0;
+    name = 'SpendingLimitInvariantCustomPeriodNegative';
+    constructor() {
+        super('Spending limit invariant violation: custom period must be positive');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantCustomPeriodNegativeError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d0, () => new SpendingLimitInvariantCustomPeriodNegativeError());
+createErrorFromNameLookup.set('SpendingLimitInvariantCustomPeriodNegative', () => new SpendingLimitInvariantCustomPeriodNegativeError());
+/**
+ * SpendingLimitPolicyInvariantDuplicateDestinations: 'Spending limit policy invariant violation: cannot have duplicate destinations for the same mint'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitPolicyInvariantDuplicateDestinationsError extends Error {
+    code = 0x17d1;
+    name = 'SpendingLimitPolicyInvariantDuplicateDestinations';
+    constructor() {
+        super('Spending limit policy invariant violation: cannot have duplicate destinations for the same mint');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitPolicyInvariantDuplicateDestinationsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d1, () => new SpendingLimitPolicyInvariantDuplicateDestinationsError());
+createErrorFromNameLookup.set('SpendingLimitPolicyInvariantDuplicateDestinations', () => new SpendingLimitPolicyInvariantDuplicateDestinationsError());
+/**
+ * SpendingLimitInvariantLastResetOutOfBounds: 'Spending limit invariant violation: last reset must be between start and expiration'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantLastResetOutOfBoundsError extends Error {
+    code = 0x17d2;
+    name = 'SpendingLimitInvariantLastResetOutOfBounds';
+    constructor() {
+        super('Spending limit invariant violation: last reset must be between start and expiration');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantLastResetOutOfBoundsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d2, () => new SpendingLimitInvariantLastResetOutOfBoundsError());
+createErrorFromNameLookup.set('SpendingLimitInvariantLastResetOutOfBounds', () => new SpendingLimitInvariantLastResetOutOfBoundsError());
+/**
+ * SpendingLimitInvariantLastResetSmallerThanStart: 'Spending limit invariant violation: last reset must be greater than start'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SpendingLimitInvariantLastResetSmallerThanStartError extends Error {
+    code = 0x17d3;
+    name = 'SpendingLimitInvariantLastResetSmallerThanStart';
+    constructor() {
+        super('Spending limit invariant violation: last reset must be greater than start');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SpendingLimitInvariantLastResetSmallerThanStartError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d3, () => new SpendingLimitInvariantLastResetSmallerThanStartError());
+createErrorFromNameLookup.set('SpendingLimitInvariantLastResetSmallerThanStart', () => new SpendingLimitInvariantLastResetSmallerThanStartError());
+/**
+ * InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowed: 'Internal fund transfer policy invariant violation: source account index is not allowed'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowedError extends Error {
+    code = 0x17d4;
+    name = 'InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowed';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: source account index is not allowed');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d4, () => new InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowedError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowed', () => new InternalFundTransferPolicyInvariantSourceAccountIndexNotAllowedError());
+/**
+ * InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowed: 'Internal fund transfer policy invariant violation: destination account index is not allowed'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowedError extends Error {
+    code = 0x17d5;
+    name = 'InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowed';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: destination account index is not allowed');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d5, () => new InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowedError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowed', () => new InternalFundTransferPolicyInvariantDestinationAccountIndexNotAllowedError());
+/**
+ * InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSame: 'Internal fund transfer policy invariant violation: source and destination cannot be the same'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSameError extends Error {
+    code = 0x17d6;
+    name = 'InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSame';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: source and destination cannot be the same');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSameError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d6, () => new InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSameError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSame', () => new InternalFundTransferPolicyInvariantSourceAndDestinationCannotBeTheSameError());
+/**
+ * InternalFundTransferPolicyInvariantMintNotAllowed: 'Internal fund transfer policy invariant violation: mint is not allowed'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantMintNotAllowedError extends Error {
+    code = 0x17d7;
+    name = 'InternalFundTransferPolicyInvariantMintNotAllowed';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: mint is not allowed');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantMintNotAllowedError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d7, () => new InternalFundTransferPolicyInvariantMintNotAllowedError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantMintNotAllowed', () => new InternalFundTransferPolicyInvariantMintNotAllowedError());
+/**
+ * InternalFundTransferPolicyInvariantAmountZero: 'Internal fund transfer policy invariant violation: amount must be greater than 0'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantAmountZeroError extends Error {
+    code = 0x17d8;
+    name = 'InternalFundTransferPolicyInvariantAmountZero';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: amount must be greater than 0');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantAmountZeroError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d8, () => new InternalFundTransferPolicyInvariantAmountZeroError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantAmountZero', () => new InternalFundTransferPolicyInvariantAmountZeroError());
+/**
+ * InternalFundTransferPolicyInvariantDuplicateMints: 'Internal fund transfer policy invariant violation: cannot have duplicate mints'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class InternalFundTransferPolicyInvariantDuplicateMintsError extends Error {
+    code = 0x17d9;
+    name = 'InternalFundTransferPolicyInvariantDuplicateMints';
+    constructor() {
+        super('Internal fund transfer policy invariant violation: cannot have duplicate mints');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, InternalFundTransferPolicyInvariantDuplicateMintsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17d9, () => new InternalFundTransferPolicyInvariantDuplicateMintsError());
+createErrorFromNameLookup.set('InternalFundTransferPolicyInvariantDuplicateMints', () => new InternalFundTransferPolicyInvariantDuplicateMintsError());
+/**
+ * ConsensusAccountNotSettings: 'Consensus account is not a settings'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ConsensusAccountNotSettingsError extends Error {
+    code = 0x17da;
+    name = 'ConsensusAccountNotSettings';
+    constructor() {
+        super('Consensus account is not a settings');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ConsensusAccountNotSettingsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17da, () => new ConsensusAccountNotSettingsError());
+createErrorFromNameLookup.set('ConsensusAccountNotSettings', () => new ConsensusAccountNotSettingsError());
+/**
+ * ConsensusAccountNotPolicy: 'Consensus account is not a policy'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class ConsensusAccountNotPolicyError extends Error {
+    code = 0x17db;
+    name = 'ConsensusAccountNotPolicy';
+    constructor() {
+        super('Consensus account is not a policy');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ConsensusAccountNotPolicyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17db, () => new ConsensusAccountNotPolicyError());
+createErrorFromNameLookup.set('ConsensusAccountNotPolicy', () => new ConsensusAccountNotPolicyError());
+/**
+ * SettingsChangePolicyActionsMustBeNonZero: 'Settings change policy invariant violation: actions must be non-zero'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangePolicyActionsMustBeNonZeroError extends Error {
+    code = 0x17dc;
+    name = 'SettingsChangePolicyActionsMustBeNonZero';
+    constructor() {
+        super('Settings change policy invariant violation: actions must be non-zero');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangePolicyActionsMustBeNonZeroError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17dc, () => new SettingsChangePolicyActionsMustBeNonZeroError());
+createErrorFromNameLookup.set('SettingsChangePolicyActionsMustBeNonZero', () => new SettingsChangePolicyActionsMustBeNonZeroError());
+/**
+ * SettingsChangeInvalidSettingsKey: 'Settings change policy violation: submitted settings account must match policy settings key'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeInvalidSettingsKeyError extends Error {
+    code = 0x17dd;
+    name = 'SettingsChangeInvalidSettingsKey';
+    constructor() {
+        super('Settings change policy violation: submitted settings account must match policy settings key');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeInvalidSettingsKeyError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17dd, () => new SettingsChangeInvalidSettingsKeyError());
+createErrorFromNameLookup.set('SettingsChangeInvalidSettingsKey', () => new SettingsChangeInvalidSettingsKeyError());
+/**
+ * SettingsChangeInvalidSettingsAccount: 'Settings change policy violation: submitted settings account must be writable'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeInvalidSettingsAccountError extends Error {
+    code = 0x17de;
+    name = 'SettingsChangeInvalidSettingsAccount';
+    constructor() {
+        super('Settings change policy violation: submitted settings account must be writable');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeInvalidSettingsAccountError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17de, () => new SettingsChangeInvalidSettingsAccountError());
+createErrorFromNameLookup.set('SettingsChangeInvalidSettingsAccount', () => new SettingsChangeInvalidSettingsAccountError());
+/**
+ * SettingsChangeInvalidRentPayer: 'Settings change policy violation: rent payer must be writable and signer'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeInvalidRentPayerError extends Error {
+    code = 0x17df;
+    name = 'SettingsChangeInvalidRentPayer';
+    constructor() {
+        super('Settings change policy violation: rent payer must be writable and signer');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeInvalidRentPayerError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17df, () => new SettingsChangeInvalidRentPayerError());
+createErrorFromNameLookup.set('SettingsChangeInvalidRentPayer', () => new SettingsChangeInvalidRentPayerError());
+/**
+ * SettingsChangeInvalidSystemProgram: 'Settings change policy violation: system program must be the system program'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeInvalidSystemProgramError extends Error {
+    code = 0x17e0;
+    name = 'SettingsChangeInvalidSystemProgram';
+    constructor() {
+        super('Settings change policy violation: system program must be the system program');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeInvalidSystemProgramError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e0, () => new SettingsChangeInvalidSystemProgramError());
+createErrorFromNameLookup.set('SettingsChangeInvalidSystemProgram', () => new SettingsChangeInvalidSystemProgramError());
+/**
+ * SettingsChangeAddSignerViolation: 'Settings change policy violation: signer does not match allowed signer'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeAddSignerViolationError extends Error {
+    code = 0x17e1;
+    name = 'SettingsChangeAddSignerViolation';
+    constructor() {
+        super('Settings change policy violation: signer does not match allowed signer');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeAddSignerViolationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e1, () => new SettingsChangeAddSignerViolationError());
+createErrorFromNameLookup.set('SettingsChangeAddSignerViolation', () => new SettingsChangeAddSignerViolationError());
+/**
+ * SettingsChangeAddSignerPermissionsViolation: 'Settings change policy violation: signer permissions does not match allowed signer permissions'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeAddSignerPermissionsViolationError extends Error {
+    code = 0x17e2;
+    name = 'SettingsChangeAddSignerPermissionsViolation';
+    constructor() {
+        super('Settings change policy violation: signer permissions does not match allowed signer permissions');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeAddSignerPermissionsViolationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e2, () => new SettingsChangeAddSignerPermissionsViolationError());
+createErrorFromNameLookup.set('SettingsChangeAddSignerPermissionsViolation', () => new SettingsChangeAddSignerPermissionsViolationError());
+/**
+ * SettingsChangeRemoveSignerViolation: 'Settings change policy violation: signer removal does not mach allowed signer removal'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeRemoveSignerViolationError extends Error {
+    code = 0x17e3;
+    name = 'SettingsChangeRemoveSignerViolation';
+    constructor() {
+        super('Settings change policy violation: signer removal does not mach allowed signer removal');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeRemoveSignerViolationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e3, () => new SettingsChangeRemoveSignerViolationError());
+createErrorFromNameLookup.set('SettingsChangeRemoveSignerViolation', () => new SettingsChangeRemoveSignerViolationError());
+/**
+ * SettingsChangeChangeTimelockViolation: 'Settings change policy violation: time lock does not match allowed time lock'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeChangeTimelockViolationError extends Error {
+    code = 0x17e4;
+    name = 'SettingsChangeChangeTimelockViolation';
+    constructor() {
+        super('Settings change policy violation: time lock does not match allowed time lock');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeChangeTimelockViolationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e4, () => new SettingsChangeChangeTimelockViolationError());
+createErrorFromNameLookup.set('SettingsChangeChangeTimelockViolation', () => new SettingsChangeChangeTimelockViolationError());
+/**
+ * SettingsChangeActionMismatch: 'Settings change policy violation: action does not match allowed action'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangeActionMismatchError extends Error {
+    code = 0x17e5;
+    name = 'SettingsChangeActionMismatch';
+    constructor() {
+        super('Settings change policy violation: action does not match allowed action');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangeActionMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e5, () => new SettingsChangeActionMismatchError());
+createErrorFromNameLookup.set('SettingsChangeActionMismatch', () => new SettingsChangeActionMismatchError());
+/**
+ * SettingsChangePolicyInvariantDuplicateActions: 'Settings change policy invariant violation: cannot have duplicate actions'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangePolicyInvariantDuplicateActionsError extends Error {
+    code = 0x17e6;
+    name = 'SettingsChangePolicyInvariantDuplicateActions';
+    constructor() {
+        super('Settings change policy invariant violation: cannot have duplicate actions');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangePolicyInvariantDuplicateActionsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e6, () => new SettingsChangePolicyInvariantDuplicateActionsError());
+createErrorFromNameLookup.set('SettingsChangePolicyInvariantDuplicateActions', () => new SettingsChangePolicyInvariantDuplicateActionsError());
+/**
+ * SettingsChangePolicyInvariantActionIndicesActionsLengthMismatch: 'Settings change policy invariant violation: action indices must match actions length'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangePolicyInvariantActionIndicesActionsLengthMismatchError extends Error {
+    code = 0x17e7;
+    name = 'SettingsChangePolicyInvariantActionIndicesActionsLengthMismatch';
+    constructor() {
+        super('Settings change policy invariant violation: action indices must match actions length');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangePolicyInvariantActionIndicesActionsLengthMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e7, () => new SettingsChangePolicyInvariantActionIndicesActionsLengthMismatchError());
+createErrorFromNameLookup.set('SettingsChangePolicyInvariantActionIndicesActionsLengthMismatch', () => new SettingsChangePolicyInvariantActionIndicesActionsLengthMismatchError());
+/**
+ * SettingsChangePolicyInvariantActionIndexOutOfBounds: 'Settings change policy invariant violation: action index out of bounds'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class SettingsChangePolicyInvariantActionIndexOutOfBoundsError extends Error {
+    code = 0x17e8;
+    name = 'SettingsChangePolicyInvariantActionIndexOutOfBounds';
+    constructor() {
+        super('Settings change policy invariant violation: action index out of bounds');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, SettingsChangePolicyInvariantActionIndexOutOfBoundsError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e8, () => new SettingsChangePolicyInvariantActionIndexOutOfBoundsError());
+createErrorFromNameLookup.set('SettingsChangePolicyInvariantActionIndexOutOfBounds', () => new SettingsChangePolicyInvariantActionIndexOutOfBoundsError());
+/**
+ * PolicyNotActiveYet: 'Policy is not active yet'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyNotActiveYetError extends Error {
+    code = 0x17e9;
+    name = 'PolicyNotActiveYet';
+    constructor() {
+        super('Policy is not active yet');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyNotActiveYetError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17e9, () => new PolicyNotActiveYetError());
+createErrorFromNameLookup.set('PolicyNotActiveYet', () => new PolicyNotActiveYetError());
+/**
+ * PolicyInvariantInvalidExpiration: 'Policy invariant violation: invalid policy expiration'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyInvariantInvalidExpirationError extends Error {
+    code = 0x17ea;
+    name = 'PolicyInvariantInvalidExpiration';
+    constructor() {
+        super('Policy invariant violation: invalid policy expiration');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyInvariantInvalidExpirationError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ea, () => new PolicyInvariantInvalidExpirationError());
+createErrorFromNameLookup.set('PolicyInvariantInvalidExpiration', () => new PolicyInvariantInvalidExpirationError());
+/**
+ * PolicyExpirationViolationPolicySettingsKeyMismatch: 'Policy expiration violation: submitted settings key does not match policy settings key'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyExpirationViolationPolicySettingsKeyMismatchError extends Error {
+    code = 0x17eb;
+    name = 'PolicyExpirationViolationPolicySettingsKeyMismatch';
+    constructor() {
+        super('Policy expiration violation: submitted settings key does not match policy settings key');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyExpirationViolationPolicySettingsKeyMismatchError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17eb, () => new PolicyExpirationViolationPolicySettingsKeyMismatchError());
+createErrorFromNameLookup.set('PolicyExpirationViolationPolicySettingsKeyMismatch', () => new PolicyExpirationViolationPolicySettingsKeyMismatchError());
+/**
+ * PolicyExpirationViolationSettingsAccountNotPresent: 'Policy expiration violation: state expiration requires the settings to be submitted'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyExpirationViolationSettingsAccountNotPresentError extends Error {
+    code = 0x17ec;
+    name = 'PolicyExpirationViolationSettingsAccountNotPresent';
+    constructor() {
+        super('Policy expiration violation: state expiration requires the settings to be submitted');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyExpirationViolationSettingsAccountNotPresentError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ec, () => new PolicyExpirationViolationSettingsAccountNotPresentError());
+createErrorFromNameLookup.set('PolicyExpirationViolationSettingsAccountNotPresent', () => new PolicyExpirationViolationSettingsAccountNotPresentError());
+/**
+ * PolicyExpirationViolationHashExpired: 'Policy expiration violation: state hash has expired'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyExpirationViolationHashExpiredError extends Error {
+    code = 0x17ed;
+    name = 'PolicyExpirationViolationHashExpired';
+    constructor() {
+        super('Policy expiration violation: state hash has expired');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyExpirationViolationHashExpiredError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ed, () => new PolicyExpirationViolationHashExpiredError());
+createErrorFromNameLookup.set('PolicyExpirationViolationHashExpired', () => new PolicyExpirationViolationHashExpiredError());
+/**
+ * PolicyExpirationViolationTimestampExpired: 'Policy expiration violation: timestamp has expired'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class PolicyExpirationViolationTimestampExpiredError extends Error {
+    code = 0x17ee;
+    name = 'PolicyExpirationViolationTimestampExpired';
+    constructor() {
+        super('Policy expiration violation: timestamp has expired');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, PolicyExpirationViolationTimestampExpiredError);
+        }
+    }
+}
+createErrorFromCodeLookup.set(0x17ee, () => new PolicyExpirationViolationTimestampExpiredError());
+createErrorFromNameLookup.set('PolicyExpirationViolationTimestampExpired', () => new PolicyExpirationViolationTimestampExpiredError());
+/**
+ * Attempts to resolve a custom program error from the provided error code.
+ * @category Errors
+ * @category generated
+ */
+export function errorFromCode(code) {
+    const createError = createErrorFromCodeLookup.get(code);
+    return createError != null ? createError() : null;
+}
+/**
+ * Attempts to resolve a custom program error from the provided error name, i.e. 'Unauthorized'.
+ * @category Errors
+ * @category generated
+ */
+export function errorFromName(name) {
+    const createError = createErrorFromNameLookup.get(name);
+    return createError != null ? createError() : null;
+}