/**
 * 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
 */

type ErrorWithCode = Error & { code: number }
type MaybeErrorWithCode = ErrorWithCode | null | undefined

const createErrorFromCodeLookup: Map<number, () => ErrorWithCode> = new Map()
const createErrorFromNameLookup: Map<string, () => ErrorWithCode> = new Map()

/**
 * NotAProtocolAuthority: 'Require protocol authority'
 *
 * @category Errors
 * @category generated
 */
export class NotAProtocolAuthorityError extends Error {
  readonly code: number = 0x1770
  readonly name: string = 'NotAProtocolAuthority'
  constructor() {
    super('Require protocol authority')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAProtocolAuthorityError)
    }
  }
}

createErrorFromCodeLookup.set(0x1770, () => new NotAProtocolAuthorityError())
createErrorFromNameLookup.set(
  'NotAProtocolAuthority',
  () => new NotAProtocolAuthorityError()
)

/**
 * AlreadyAdded: 'Program is already added'
 *
 * @category Errors
 * @category generated
 */
export class AlreadyAddedError extends Error {
  readonly code: number = 0x1771
  readonly name: string = 'AlreadyAdded'
  constructor() {
    super('Program is already added')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AlreadyAddedError)
    }
  }
}

createErrorFromCodeLookup.set(0x1771, () => new AlreadyAddedError())
createErrorFromNameLookup.set('AlreadyAdded', () => new AlreadyAddedError())

/**
 * CannotAddBecauseOfMaxAmountLimit: 'Can't add because the max limit is reached'
 *
 * @category Errors
 * @category generated
 */
export class CannotAddBecauseOfMaxAmountLimitError extends Error {
  readonly code: number = 0x1772
  readonly name: string = 'CannotAddBecauseOfMaxAmountLimit'
  constructor() {
    super("Can't add because the max limit is reached")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CannotAddBecauseOfMaxAmountLimitError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1772,
  () => new CannotAddBecauseOfMaxAmountLimitError()
)
createErrorFromNameLookup.set(
  'CannotAddBecauseOfMaxAmountLimit',
  () => new CannotAddBecauseOfMaxAmountLimitError()
)

/**
 * InvalidValueForAFee: 'Fee can't be higher than 100%'
 *
 * @category Errors
 * @category generated
 */
export class InvalidValueForAFeeError extends Error {
  readonly code: number = 0x1773
  readonly name: string = 'InvalidValueForAFee'
  constructor() {
    super("Fee can't be higher than 100%")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidValueForAFeeError)
    }
  }
}

createErrorFromCodeLookup.set(0x1773, () => new InvalidValueForAFeeError())
createErrorFromNameLookup.set(
  'InvalidValueForAFee',
  () => new InvalidValueForAFeeError()
)

/**
 * InvalidRiskEngineRegister: 'Invalid risk engine register'
 *
 * @category Errors
 * @category generated
 */
export class InvalidRiskEngineRegisterError extends Error {
  readonly code: number = 0x1774
  readonly name: string = 'InvalidRiskEngineRegister'
  constructor() {
    super('Invalid risk engine register')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidRiskEngineRegisterError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1774,
  () => new InvalidRiskEngineRegisterError()
)
createErrorFromNameLookup.set(
  'InvalidRiskEngineRegister',
  () => new InvalidRiskEngineRegisterError()
)

/**
 * NotACollateralMint: 'Passed mint is not a collateral mint'
 *
 * @category Errors
 * @category generated
 */
export class NotACollateralMintError extends Error {
  readonly code: number = 0x1775
  readonly name: string = 'NotACollateralMint'
  constructor() {
    super('Passed mint is not a collateral mint')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotACollateralMintError)
    }
  }
}

createErrorFromCodeLookup.set(0x1775, () => new NotACollateralMintError())
createErrorFromNameLookup.set(
  'NotACollateralMint',
  () => new NotACollateralMintError()
)

/**
 * NotACollateralTokenAccount: 'Passed token account does not belong to collateral mint'
 *
 * @category Errors
 * @category generated
 */
export class NotACollateralTokenAccountError extends Error {
  readonly code: number = 0x1776
  readonly name: string = 'NotACollateralTokenAccount'
  constructor() {
    super('Passed token account does not belong to collateral mint')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotACollateralTokenAccountError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1776,
  () => new NotACollateralTokenAccountError()
)
createErrorFromNameLookup.set(
  'NotACollateralTokenAccount',
  () => new NotACollateralTokenAccountError()
)

/**
 * NotARiskEngine: 'Passed account is not a risk engine in the protocol'
 *
 * @category Errors
 * @category generated
 */
export class NotARiskEngineError extends Error {
  readonly code: number = 0x1777
  readonly name: string = 'NotARiskEngine'
  constructor() {
    super('Passed account is not a risk engine in the protocol')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotARiskEngineError)
    }
  }
}

createErrorFromCodeLookup.set(0x1777, () => new NotARiskEngineError())
createErrorFromNameLookup.set('NotARiskEngine', () => new NotARiskEngineError())

/**
 * InvalidRecentTimestamp: 'Recent timestamp is too different from on-chain time'
 *
 * @category Errors
 * @category generated
 */
export class InvalidRecentTimestampError extends Error {
  readonly code: number = 0x1778
  readonly name: string = 'InvalidRecentTimestamp'
  constructor() {
    super('Recent timestamp is too different from on-chain time')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidRecentTimestampError)
    }
  }
}

createErrorFromCodeLookup.set(0x1778, () => new InvalidRecentTimestampError())
createErrorFromNameLookup.set(
  'InvalidRecentTimestamp',
  () => new InvalidRecentTimestampError()
)

/**
 * InvalidExpirationTimestamp: 'Expiration timestamp is invalid'
 *
 * @category Errors
 * @category generated
 */
export class InvalidExpirationTimestampError extends Error {
  readonly code: number = 0x1779
  readonly name: string = 'InvalidExpirationTimestamp'
  constructor() {
    super('Expiration timestamp is invalid')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidExpirationTimestampError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1779,
  () => new InvalidExpirationTimestampError()
)
createErrorFromNameLookup.set(
  'InvalidExpirationTimestamp',
  () => new InvalidExpirationTimestampError()
)

/**
 * EmptyLegsNotSupported: 'An Rfq without legs is not supported'
 *
 * @category Errors
 * @category generated
 */
export class EmptyLegsNotSupportedError extends Error {
  readonly code: number = 0x177a
  readonly name: string = 'EmptyLegsNotSupported'
  constructor() {
    super('An Rfq without legs is not supported')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, EmptyLegsNotSupportedError)
    }
  }
}

createErrorFromCodeLookup.set(0x177a, () => new EmptyLegsNotSupportedError())
createErrorFromNameLookup.set(
  'EmptyLegsNotSupported',
  () => new EmptyLegsNotSupportedError()
)

/**
 * LegsSizeDoesNotMatchExpectedSize: 'Legs size does not match specified expected leg size'
 *
 * @category Errors
 * @category generated
 */
export class LegsSizeDoesNotMatchExpectedSizeError extends Error {
  readonly code: number = 0x177b
  readonly name: string = 'LegsSizeDoesNotMatchExpectedSize'
  constructor() {
    super('Legs size does not match specified expected leg size')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, LegsSizeDoesNotMatchExpectedSizeError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x177b,
  () => new LegsSizeDoesNotMatchExpectedSizeError()
)
createErrorFromNameLookup.set(
  'LegsSizeDoesNotMatchExpectedSize',
  () => new LegsSizeDoesNotMatchExpectedSizeError()
)

/**
 * LegsHashDoesNotMatchExpectedHash: 'Legs hash does not match specified expected leg hash'
 *
 * @category Errors
 * @category generated
 */
export class LegsHashDoesNotMatchExpectedHashError extends Error {
  readonly code: number = 0x177c
  readonly name: string = 'LegsHashDoesNotMatchExpectedHash'
  constructor() {
    super('Legs hash does not match specified expected leg hash')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, LegsHashDoesNotMatchExpectedHashError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x177c,
  () => new LegsHashDoesNotMatchExpectedHashError()
)
createErrorFromNameLookup.set(
  'LegsHashDoesNotMatchExpectedHash',
  () => new LegsHashDoesNotMatchExpectedHashError()
)

/**
 * NotEnoughTokens: 'Not enough tokens'
 *
 * @category Errors
 * @category generated
 */
export class NotEnoughTokensError extends Error {
  readonly code: number = 0x177d
  readonly name: string = 'NotEnoughTokens'
  constructor() {
    super('Not enough tokens')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotEnoughTokensError)
    }
  }
}

createErrorFromCodeLookup.set(0x177d, () => new NotEnoughTokensError())
createErrorFromNameLookup.set(
  'NotEnoughTokens',
  () => new NotEnoughTokensError()
)

/**
 * NotEnoughCollateral: 'Not enough collateral'
 *
 * @category Errors
 * @category generated
 */
export class NotEnoughCollateralError extends Error {
  readonly code: number = 0x177e
  readonly name: string = 'NotEnoughCollateral'
  constructor() {
    super('Not enough collateral')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotEnoughCollateralError)
    }
  }
}

createErrorFromCodeLookup.set(0x177e, () => new NotEnoughCollateralError())
createErrorFromNameLookup.set(
  'NotEnoughCollateral',
  () => new NotEnoughCollateralError()
)

/**
 * NotAWhitelistedInstrument: 'Not a whitelisted instrument'
 *
 * @category Errors
 * @category generated
 */
export class NotAWhitelistedInstrumentError extends Error {
  readonly code: number = 0x177f
  readonly name: string = 'NotAWhitelistedInstrument'
  constructor() {
    super('Not a whitelisted instrument')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAWhitelistedInstrumentError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x177f,
  () => new NotAWhitelistedInstrumentError()
)
createErrorFromNameLookup.set(
  'NotAWhitelistedInstrument',
  () => new NotAWhitelistedInstrumentError()
)

/**
 * NotAWhitelistedPrintTradeProvider: 'Not a whitelisted print trade provider'
 *
 * @category Errors
 * @category generated
 */
export class NotAWhitelistedPrintTradeProviderError extends Error {
  readonly code: number = 0x1780
  readonly name: string = 'NotAWhitelistedPrintTradeProvider'
  constructor() {
    super('Not a whitelisted print trade provider')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAWhitelistedPrintTradeProviderError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1780,
  () => new NotAWhitelistedPrintTradeProviderError()
)
createErrorFromNameLookup.set(
  'NotAWhitelistedPrintTradeProvider',
  () => new NotAWhitelistedPrintTradeProviderError()
)

/**
 * NotEnoughAccounts: 'Not enough accounts'
 *
 * @category Errors
 * @category generated
 */
export class NotEnoughAccountsError extends Error {
  readonly code: number = 0x1781
  readonly name: string = 'NotEnoughAccounts'
  constructor() {
    super('Not enough accounts')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotEnoughAccountsError)
    }
  }
}

createErrorFromCodeLookup.set(0x1781, () => new NotEnoughAccountsError())
createErrorFromNameLookup.set(
  'NotEnoughAccounts',
  () => new NotEnoughAccountsError()
)

/**
 * PassedProgramIdDiffersFromAnInstrument: 'Passed program id differs from an instrument'
 *
 * @category Errors
 * @category generated
 */
export class PassedProgramIdDiffersFromAnInstrumentError extends Error {
  readonly code: number = 0x1782
  readonly name: string = 'PassedProgramIdDiffersFromAnInstrument'
  constructor() {
    super('Passed program id differs from an instrument')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PassedProgramIdDiffersFromAnInstrumentError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1782,
  () => new PassedProgramIdDiffersFromAnInstrumentError()
)
createErrorFromNameLookup.set(
  'PassedProgramIdDiffersFromAnInstrument',
  () => new PassedProgramIdDiffersFromAnInstrumentError()
)

/**
 * PassedProgramIdDiffersFromAPrintTradeProvider: 'Passed program id differs from a print trade provider'
 *
 * @category Errors
 * @category generated
 */
export class PassedProgramIdDiffersFromAPrintTradeProviderError extends Error {
  readonly code: number = 0x1783
  readonly name: string = 'PassedProgramIdDiffersFromAPrintTradeProvider'
  constructor() {
    super('Passed program id differs from a print trade provider')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(
        this,
        PassedProgramIdDiffersFromAPrintTradeProviderError
      )
    }
  }
}

createErrorFromCodeLookup.set(
  0x1783,
  () => new PassedProgramIdDiffersFromAPrintTradeProviderError()
)
createErrorFromNameLookup.set(
  'PassedProgramIdDiffersFromAPrintTradeProvider',
  () => new PassedProgramIdDiffersFromAPrintTradeProviderError()
)

/**
 * RfqIsNotInRequiredState: 'Rfq is not in required state'
 *
 * @category Errors
 * @category generated
 */
export class RfqIsNotInRequiredStateError extends Error {
  readonly code: number = 0x1784
  readonly name: string = 'RfqIsNotInRequiredState'
  constructor() {
    super('Rfq is not in required state')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, RfqIsNotInRequiredStateError)
    }
  }
}

createErrorFromCodeLookup.set(0x1784, () => new RfqIsNotInRequiredStateError())
createErrorFromNameLookup.set(
  'RfqIsNotInRequiredState',
  () => new RfqIsNotInRequiredStateError()
)

/**
 * ResponseDoesNotMatchOrderType: 'Response does not match order type'
 *
 * @category Errors
 * @category generated
 */
export class ResponseDoesNotMatchOrderTypeError extends Error {
  readonly code: number = 0x1785
  readonly name: string = 'ResponseDoesNotMatchOrderType'
  constructor() {
    super('Response does not match order type')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ResponseDoesNotMatchOrderTypeError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1785,
  () => new ResponseDoesNotMatchOrderTypeError()
)
createErrorFromNameLookup.set(
  'ResponseDoesNotMatchOrderType',
  () => new ResponseDoesNotMatchOrderTypeError()
)

/**
 * InvalidQuoteType: 'Invalid quote type'
 *
 * @category Errors
 * @category generated
 */
export class InvalidQuoteTypeError extends Error {
  readonly code: number = 0x1786
  readonly name: string = 'InvalidQuoteType'
  constructor() {
    super('Invalid quote type')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidQuoteTypeError)
    }
  }
}

createErrorFromCodeLookup.set(0x1786, () => new InvalidQuoteTypeError())
createErrorFromNameLookup.set(
  'InvalidQuoteType',
  () => new InvalidQuoteTypeError()
)

/**
 * ResponseForAnotherRfq: 'Response is for another Rfq'
 *
 * @category Errors
 * @category generated
 */
export class ResponseForAnotherRfqError extends Error {
  readonly code: number = 0x1787
  readonly name: string = 'ResponseForAnotherRfq'
  constructor() {
    super('Response is for another Rfq')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ResponseForAnotherRfqError)
    }
  }
}

createErrorFromCodeLookup.set(0x1787, () => new ResponseForAnotherRfqError())
createErrorFromNameLookup.set(
  'ResponseForAnotherRfq',
  () => new ResponseForAnotherRfqError()
)

/**
 * NotATaker: 'Passed address is not a rfq taker'
 *
 * @category Errors
 * @category generated
 */
export class NotATakerError extends Error {
  readonly code: number = 0x1788
  readonly name: string = 'NotATaker'
  constructor() {
    super('Passed address is not a rfq taker')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotATakerError)
    }
  }
}

createErrorFromCodeLookup.set(0x1788, () => new NotATakerError())
createErrorFromNameLookup.set('NotATaker', () => new NotATakerError())

/**
 * ResponseIsNotInRequiredState: 'Response is not required state'
 *
 * @category Errors
 * @category generated
 */
export class ResponseIsNotInRequiredStateError extends Error {
  readonly code: number = 0x1789
  readonly name: string = 'ResponseIsNotInRequiredState'
  constructor() {
    super('Response is not required state')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ResponseIsNotInRequiredStateError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1789,
  () => new ResponseIsNotInRequiredStateError()
)
createErrorFromNameLookup.set(
  'ResponseIsNotInRequiredState',
  () => new ResponseIsNotInRequiredStateError()
)

/**
 * ConfirmedSideMissing: 'Confirmed side is missing in a response'
 *
 * @category Errors
 * @category generated
 */
export class ConfirmedSideMissingError extends Error {
  readonly code: number = 0x178a
  readonly name: string = 'ConfirmedSideMissing'
  constructor() {
    super('Confirmed side is missing in a response')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, ConfirmedSideMissingError)
    }
  }
}

createErrorFromCodeLookup.set(0x178a, () => new ConfirmedSideMissingError())
createErrorFromNameLookup.set(
  'ConfirmedSideMissing',
  () => new ConfirmedSideMissingError()
)

/**
 * NotAPassedAuthority: 'Caller is not a authority passed in parameters'
 *
 * @category Errors
 * @category generated
 */
export class NotAPassedAuthorityError extends Error {
  readonly code: number = 0x178b
  readonly name: string = 'NotAPassedAuthority'
  constructor() {
    super('Caller is not a authority passed in parameters')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAPassedAuthorityError)
    }
  }
}

createErrorFromCodeLookup.set(0x178b, () => new NotAPassedAuthorityError())
createErrorFromNameLookup.set(
  'NotAPassedAuthority',
  () => new NotAPassedAuthorityError()
)

/**
 * TakerCanNotRespond: 'Taker can not respond to rfq he had created'
 *
 * @category Errors
 * @category generated
 */
export class TakerCanNotRespondError extends Error {
  readonly code: number = 0x178c
  readonly name: string = 'TakerCanNotRespond'
  constructor() {
    super('Taker can not respond to rfq he had created')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TakerCanNotRespondError)
    }
  }
}

createErrorFromCodeLookup.set(0x178c, () => new TakerCanNotRespondError())
createErrorFromNameLookup.set(
  'TakerCanNotRespond',
  () => new TakerCanNotRespondError()
)

/**
 * NotAQuoteMint: 'Not a quote mint'
 *
 * @category Errors
 * @category generated
 */
export class NotAQuoteMintError extends Error {
  readonly code: number = 0x178d
  readonly name: string = 'NotAQuoteMint'
  constructor() {
    super('Not a quote mint')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAQuoteMintError)
    }
  }
}

createErrorFromCodeLookup.set(0x178d, () => new NotAQuoteMintError())
createErrorFromNameLookup.set('NotAQuoteMint', () => new NotAQuoteMintError())

/**
 * WrongQuoteReceiver: 'Quote receiver account is not a receiver associated token account'
 *
 * @category Errors
 * @category generated
 */
export class WrongQuoteReceiverError extends Error {
  readonly code: number = 0x178e
  readonly name: string = 'WrongQuoteReceiver'
  constructor() {
    super('Quote receiver account is not a receiver associated token account')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WrongQuoteReceiverError)
    }
  }
}

createErrorFromCodeLookup.set(0x178e, () => new WrongQuoteReceiverError())
createErrorFromNameLookup.set(
  'WrongQuoteReceiver',
  () => new WrongQuoteReceiverError()
)

/**
 * NoLegMultiplierForFixedSize: 'Fixed size rfq doesn't support specifying legs multiplier'
 *
 * @category Errors
 * @category generated
 */
export class NoLegMultiplierForFixedSizeError extends Error {
  readonly code: number = 0x178f
  readonly name: string = 'NoLegMultiplierForFixedSize'
  constructor() {
    super("Fixed size rfq doesn't support specifying legs multiplier")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoLegMultiplierForFixedSizeError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x178f,
  () => new NoLegMultiplierForFixedSizeError()
)
createErrorFromNameLookup.set(
  'NoLegMultiplierForFixedSize',
  () => new NoLegMultiplierForFixedSizeError()
)

/**
 * LegMultiplierHigherThanInQuote: 'Leg multiplier can't be higher than which is specified in the quote'
 *
 * @category Errors
 * @category generated
 */
export class LegMultiplierHigherThanInQuoteError extends Error {
  readonly code: number = 0x1790
  readonly name: string = 'LegMultiplierHigherThanInQuote'
  constructor() {
    super("Leg multiplier can't be higher than which is specified in the quote")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, LegMultiplierHigherThanInQuoteError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1790,
  () => new LegMultiplierHigherThanInQuoteError()
)
createErrorFromNameLookup.set(
  'LegMultiplierHigherThanInQuote',
  () => new LegMultiplierHigherThanInQuoteError()
)

/**
 * CanNotLockAdditionalMakerCollateral: 'Confirmation can't lock additional maker collateral'
 *
 * @category Errors
 * @category generated
 */
export class CanNotLockAdditionalMakerCollateralError extends Error {
  readonly code: number = 0x1791
  readonly name: string = 'CanNotLockAdditionalMakerCollateral'
  constructor() {
    super("Confirmation can't lock additional maker collateral")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, CanNotLockAdditionalMakerCollateralError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x1791,
  () => new CanNotLockAdditionalMakerCollateralError()
)
createErrorFromNameLookup.set(
  'CanNotLockAdditionalMakerCollateral',
  () => new CanNotLockAdditionalMakerCollateralError()
)

/**
 * NoPreparationToRevert: 'This side of rfq either had not prepared or had already reverted'
 *
 * @category Errors
 * @category generated
 */
export class NoPreparationToRevertError extends Error {
  readonly code: number = 0x1792
  readonly name: string = 'NoPreparationToRevert'
  constructor() {
    super('This side of rfq either had not prepared or had already reverted')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoPreparationToRevertError)
    }
  }
}

createErrorFromCodeLookup.set(0x1792, () => new NoPreparationToRevertError())
createErrorFromNameLookup.set(
  'NoPreparationToRevert',
  () => new NoPreparationToRevertError()
)

/**
 * NoCollateralLocked: 'No collateral locked'
 *
 * @category Errors
 * @category generated
 */
export class NoCollateralLockedError extends Error {
  readonly code: number = 0x1793
  readonly name: string = 'NoCollateralLocked'
  constructor() {
    super('No collateral locked')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoCollateralLockedError)
    }
  }
}

createErrorFromCodeLookup.set(0x1793, () => new NoCollateralLockedError())
createErrorFromNameLookup.set(
  'NoCollateralLocked',
  () => new NoCollateralLockedError()
)

/**
 * InvalidDefaultingParty: 'Invalid defaulting party'
 *
 * @category Errors
 * @category generated
 */
export class InvalidDefaultingPartyError extends Error {
  readonly code: number = 0x1794
  readonly name: string = 'InvalidDefaultingParty'
  constructor() {
    super('Invalid defaulting party')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidDefaultingPartyError)
    }
  }
}

createErrorFromCodeLookup.set(0x1794, () => new InvalidDefaultingPartyError())
createErrorFromNameLookup.set(
  'InvalidDefaultingParty',
  () => new InvalidDefaultingPartyError()
)

/**
 * HaveCollateralLocked: 'Can't clean up with collateral locked'
 *
 * @category Errors
 * @category generated
 */
export class HaveCollateralLockedError extends Error {
  readonly code: number = 0x1795
  readonly name: string = 'HaveCollateralLocked'
  constructor() {
    super("Can't clean up with collateral locked")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, HaveCollateralLockedError)
    }
  }
}

createErrorFromCodeLookup.set(0x1795, () => new HaveCollateralLockedError())
createErrorFromNameLookup.set(
  'HaveCollateralLocked',
  () => new HaveCollateralLockedError()
)

/**
 * PendingPreparations: 'Can't clean up with pending settle preparations'
 *
 * @category Errors
 * @category generated
 */
export class PendingPreparationsError extends Error {
  readonly code: number = 0x1796
  readonly name: string = 'PendingPreparations'
  constructor() {
    super("Can't clean up with pending settle preparations")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PendingPreparationsError)
    }
  }
}

createErrorFromCodeLookup.set(0x1796, () => new PendingPreparationsError())
createErrorFromNameLookup.set(
  'PendingPreparations',
  () => new PendingPreparationsError()
)

/**
 * NotAMaker: 'Passed address is not a response maker'
 *
 * @category Errors
 * @category generated
 */
export class NotAMakerError extends Error {
  readonly code: number = 0x1797
  readonly name: string = 'NotAMaker'
  constructor() {
    super('Passed address is not a response maker')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotAMakerError)
    }
  }
}

createErrorFromCodeLookup.set(0x1797, () => new NotAMakerError())
createErrorFromNameLookup.set('NotAMaker', () => new NotAMakerError())

/**
 * NotFirstToPrepare: 'Passed address is not of a party first to prepare for settlement'
 *
 * @category Errors
 * @category generated
 */
export class NotFirstToPrepareError extends Error {
  readonly code: number = 0x1798
  readonly name: string = 'NotFirstToPrepare'
  constructor() {
    super('Passed address is not of a party first to prepare for settlement')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NotFirstToPrepareError)
    }
  }
}

createErrorFromCodeLookup.set(0x1798, () => new NotFirstToPrepareError())
createErrorFromNameLookup.set(
  'NotFirstToPrepare',
  () => new NotFirstToPrepareError()
)

/**
 * HaveExistingResponses: 'Rfq have not cleared responses and can't be cleaned up'
 *
 * @category Errors
 * @category generated
 */
export class HaveExistingResponsesError extends Error {
  readonly code: number = 0x1799
  readonly name: string = 'HaveExistingResponses'
  constructor() {
    super("Rfq have not cleared responses and can't be cleaned up")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, HaveExistingResponsesError)
    }
  }
}

createErrorFromCodeLookup.set(0x1799, () => new HaveExistingResponsesError())
createErrorFromNameLookup.set(
  'HaveExistingResponses',
  () => new HaveExistingResponsesError()
)

/**
 * HaveResponses: 'Can't cancel an rfq with existing responses'
 *
 * @category Errors
 * @category generated
 */
export class HaveResponsesError extends Error {
  readonly code: number = 0x179a
  readonly name: string = 'HaveResponses'
  constructor() {
    super("Can't cancel an rfq with existing responses")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, HaveResponsesError)
    }
  }
}

createErrorFromCodeLookup.set(0x179a, () => new HaveResponsesError())
createErrorFromNameLookup.set('HaveResponses', () => new HaveResponsesError())

/**
 * InvalidSpecifiedLegAmount: 'Invalid specified leg amount'
 *
 * @category Errors
 * @category generated
 */
export class InvalidSpecifiedLegAmountError extends Error {
  readonly code: number = 0x179b
  readonly name: string = 'InvalidSpecifiedLegAmount'
  constructor() {
    super('Invalid specified leg amount')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidSpecifiedLegAmountError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x179b,
  () => new InvalidSpecifiedLegAmountError()
)
createErrorFromNameLookup.set(
  'InvalidSpecifiedLegAmount',
  () => new InvalidSpecifiedLegAmountError()
)

/**
 * AlreadyStartedToPrepare: 'Already started to prepare to settle'
 *
 * @category Errors
 * @category generated
 */
export class AlreadyStartedToPrepareError extends Error {
  readonly code: number = 0x179c
  readonly name: string = 'AlreadyStartedToPrepare'
  constructor() {
    super('Already started to prepare to settle')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AlreadyStartedToPrepareError)
    }
  }
}

createErrorFromCodeLookup.set(0x179c, () => new AlreadyStartedToPrepareError())
createErrorFromNameLookup.set(
  'AlreadyStartedToPrepare',
  () => new AlreadyStartedToPrepareError()
)

/**
 * HaveNotStartedToPrepare: 'Have not started to prepare to settle'
 *
 * @category Errors
 * @category generated
 */
export class HaveNotStartedToPrepareError extends Error {
  readonly code: number = 0x179d
  readonly name: string = 'HaveNotStartedToPrepare'
  constructor() {
    super('Have not started to prepare to settle')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, HaveNotStartedToPrepareError)
    }
  }
}

createErrorFromCodeLookup.set(0x179d, () => new HaveNotStartedToPrepareError())
createErrorFromNameLookup.set(
  'HaveNotStartedToPrepare',
  () => new HaveNotStartedToPrepareError()
)

/**
 * TooManyLegs: 'LegAmountExceedsMaximumLimit'
 *
 * @category Errors
 * @category generated
 */
export class TooManyLegsError extends Error {
  readonly code: number = 0x179e
  readonly name: string = 'TooManyLegs'
  constructor() {
    super('LegAmountExceedsMaximumLimit')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TooManyLegsError)
    }
  }
}

createErrorFromCodeLookup.set(0x179e, () => new TooManyLegsError())
createErrorFromNameLookup.set('TooManyLegs', () => new TooManyLegsError())

/**
 * LegsDataTooBig: 'LegsDataSizeExceedsMaximumLimit'
 *
 * @category Errors
 * @category generated
 */
export class LegsDataTooBigError extends Error {
  readonly code: number = 0x179f
  readonly name: string = 'LegsDataTooBig'
  constructor() {
    super('LegsDataSizeExceedsMaximumLimit')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, LegsDataTooBigError)
    }
  }
}

createErrorFromCodeLookup.set(0x179f, () => new LegsDataTooBigError())
createErrorFromNameLookup.set('LegsDataTooBig', () => new LegsDataTooBigError())

/**
 * MaxInstruments: 'Can't add new instrument because maximum amout of instruments already added'
 *
 * @category Errors
 * @category generated
 */
export class MaxInstrumentsError extends Error {
  readonly code: number = 0x17a0
  readonly name: string = 'MaxInstruments'
  constructor() {
    super(
      "Can't add new instrument because maximum amout of instruments already added"
    )
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MaxInstrumentsError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a0, () => new MaxInstrumentsError())
createErrorFromNameLookup.set('MaxInstruments', () => new MaxInstrumentsError())

/**
 * InvalidQuoteInstrument: 'Current instrument cannot be used as a quote asset'
 *
 * @category Errors
 * @category generated
 */
export class InvalidQuoteInstrumentError extends Error {
  readonly code: number = 0x17a1
  readonly name: string = 'InvalidQuoteInstrument'
  constructor() {
    super('Current instrument cannot be used as a quote asset')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidQuoteInstrumentError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a1, () => new InvalidQuoteInstrumentError())
createErrorFromNameLookup.set(
  'InvalidQuoteInstrument',
  () => new InvalidQuoteInstrumentError()
)

/**
 * NoPrintTradeProvider: 'Print trade provider program ID wasn't provided'
 *
 * @category Errors
 * @category generated
 */
export class NoPrintTradeProviderError extends Error {
  readonly code: number = 0x17a2
  readonly name: string = 'NoPrintTradeProvider'
  constructor() {
    super("Print trade provider program ID wasn't provided")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoPrintTradeProviderError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a2, () => new NoPrintTradeProviderError())
createErrorFromNameLookup.set(
  'NoPrintTradeProvider',
  () => new NoPrintTradeProviderError()
)

/**
 * InvalidSettlingFlow: 'This instruction is used for settling flow of another type of rfq'
 *
 * @category Errors
 * @category generated
 */
export class InvalidSettlingFlowError extends Error {
  readonly code: number = 0x17a3
  readonly name: string = 'InvalidSettlingFlow'
  constructor() {
    super('This instruction is used for settling flow of another type of rfq')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidSettlingFlowError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a3, () => new InvalidSettlingFlowError())
createErrorFromNameLookup.set(
  'InvalidSettlingFlow',
  () => new InvalidSettlingFlowError()
)

/**
 * NoPrintTradeToCleanUp: 'No print trade to clean up'
 *
 * @category Errors
 * @category generated
 */
export class NoPrintTradeToCleanUpError extends Error {
  readonly code: number = 0x17a4
  readonly name: string = 'NoPrintTradeToCleanUp'
  constructor() {
    super('No print trade to clean up')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, NoPrintTradeToCleanUpError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a4, () => new NoPrintTradeToCleanUpError())
createErrorFromNameLookup.set(
  'NoPrintTradeToCleanUp',
  () => new NoPrintTradeToCleanUpError()
)

/**
 * AssetAmountOverflow: 'Amount of asset to transfer overflows'
 *
 * @category Errors
 * @category generated
 */
export class AssetAmountOverflowError extends Error {
  readonly code: number = 0x17a5
  readonly name: string = 'AssetAmountOverflow'
  constructor() {
    super('Amount of asset to transfer overflows')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AssetAmountOverflowError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a5, () => new AssetAmountOverflowError())
createErrorFromNameLookup.set(
  'AssetAmountOverflow',
  () => new AssetAmountOverflowError()
)

/**
 * PriceShouldBePositive: 'Price should be positive for fixed quote asset amount RFQ'
 *
 * @category Errors
 * @category generated
 */
export class PriceShouldBePositiveError extends Error {
  readonly code: number = 0x17a6
  readonly name: string = 'PriceShouldBePositive'
  constructor() {
    super('Price should be positive for fixed quote asset amount RFQ')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, PriceShouldBePositiveError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a6, () => new PriceShouldBePositiveError())
createErrorFromNameLookup.set(
  'PriceShouldBePositive',
  () => new PriceShouldBePositiveError()
)

/**
 * AlreadyHasAStatusToSet: 'Already has a status to set'
 *
 * @category Errors
 * @category generated
 */
export class AlreadyHasAStatusToSetError extends Error {
  readonly code: number = 0x17a7
  readonly name: string = 'AlreadyHasAStatusToSet'
  constructor() {
    super('Already has a status to set')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AlreadyHasAStatusToSetError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a7, () => new AlreadyHasAStatusToSetError())
createErrorFromNameLookup.set(
  'AlreadyHasAStatusToSet',
  () => new AlreadyHasAStatusToSetError()
)

/**
 * InstrumentIsDisabled: 'Can't create an rfq using a disabled instrument'
 *
 * @category Errors
 * @category generated
 */
export class InstrumentIsDisabledError extends Error {
  readonly code: number = 0x17a8
  readonly name: string = 'InstrumentIsDisabled'
  constructor() {
    super("Can't create an rfq using a disabled instrument")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InstrumentIsDisabledError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a8, () => new InstrumentIsDisabledError())
createErrorFromNameLookup.set(
  'InstrumentIsDisabled',
  () => new InstrumentIsDisabledError()
)

/**
 * BaseAssetIsDisabled: 'Can't create an rfq using a disabled base asset'
 *
 * @category Errors
 * @category generated
 */
export class BaseAssetIsDisabledError extends Error {
  readonly code: number = 0x17a9
  readonly name: string = 'BaseAssetIsDisabled'
  constructor() {
    super("Can't create an rfq using a disabled base asset")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, BaseAssetIsDisabledError)
    }
  }
}

createErrorFromCodeLookup.set(0x17a9, () => new BaseAssetIsDisabledError())
createErrorFromNameLookup.set(
  'BaseAssetIsDisabled',
  () => new BaseAssetIsDisabledError()
)

/**
 * SettlementInfoDoesNotMatchRfqType: 'Settlement type info does not match rfq type'
 *
 * @category Errors
 * @category generated
 */
export class SettlementInfoDoesNotMatchRfqTypeError extends Error {
  readonly code: number = 0x17aa
  readonly name: string = 'SettlementInfoDoesNotMatchRfqType'
  constructor() {
    super('Settlement type info does not match rfq type')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, SettlementInfoDoesNotMatchRfqTypeError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17aa,
  () => new SettlementInfoDoesNotMatchRfqTypeError()
)
createErrorFromNameLookup.set(
  'SettlementInfoDoesNotMatchRfqType',
  () => new SettlementInfoDoesNotMatchRfqTypeError()
)

/**
 * SettlementExpirationIsDisabled: 'Settlement expiration is disabled for this print trade provider'
 *
 * @category Errors
 * @category generated
 */
export class SettlementExpirationIsDisabledError extends Error {
  readonly code: number = 0x17ab
  readonly name: string = 'SettlementExpirationIsDisabled'
  constructor() {
    super('Settlement expiration is disabled for this print trade provider')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, SettlementExpirationIsDisabledError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17ab,
  () => new SettlementExpirationIsDisabledError()
)
createErrorFromNameLookup.set(
  'SettlementExpirationIsDisabled',
  () => new SettlementExpirationIsDisabledError()
)

/**
 * TooEarlyForExpiration: 'Too early for the settlement expiration'
 *
 * @category Errors
 * @category generated
 */
export class TooEarlyForExpirationError extends Error {
  readonly code: number = 0x17ac
  readonly name: string = 'TooEarlyForExpiration'
  constructor() {
    super('Too early for the settlement expiration')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, TooEarlyForExpirationError)
    }
  }
}

createErrorFromCodeLookup.set(0x17ac, () => new TooEarlyForExpirationError())
createErrorFromNameLookup.set(
  'TooEarlyForExpiration',
  () => new TooEarlyForExpirationError()
)

/**
 * DefaultValueIsNotPermitted: 'Can't accept default value in non-default field'
 *
 * @category Errors
 * @category generated
 */
export class DefaultValueIsNotPermittedError extends Error {
  readonly code: number = 0x17ad
  readonly name: string = 'DefaultValueIsNotPermitted'
  constructor() {
    super("Can't accept default value in non-default field")
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, DefaultValueIsNotPermittedError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17ad,
  () => new DefaultValueIsNotPermittedError()
)
createErrorFromNameLookup.set(
  'DefaultValueIsNotPermitted',
  () => new DefaultValueIsNotPermittedError()
)

/**
 * OracleSourceIsMissing: 'Specified oracle source is missing'
 *
 * @category Errors
 * @category generated
 */
export class OracleSourceIsMissingError extends Error {
  readonly code: number = 0x17ae
  readonly name: string = 'OracleSourceIsMissing'
  constructor() {
    super('Specified oracle source is missing')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, OracleSourceIsMissingError)
    }
  }
}

createErrorFromCodeLookup.set(0x17ae, () => new OracleSourceIsMissingError())
createErrorFromNameLookup.set(
  'OracleSourceIsMissing',
  () => new OracleSourceIsMissingError()
)

/**
 * AdditionalDataIsNotSupported: 'Additional data is not supported for escrow rfqs'
 *
 * @category Errors
 * @category generated
 */
export class AdditionalDataIsNotSupportedError extends Error {
  readonly code: number = 0x17af
  readonly name: string = 'AdditionalDataIsNotSupported'
  constructor() {
    super('Additional data is not supported for escrow rfqs')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AdditionalDataIsNotSupportedError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17af,
  () => new AdditionalDataIsNotSupportedError()
)
createErrorFromNameLookup.set(
  'AdditionalDataIsNotSupported',
  () => new AdditionalDataIsNotSupportedError()
)

/**
 * InvalidReturnDataEmitter: 'Invalid return data emitter'
 *
 * @category Errors
 * @category generated
 */
export class InvalidReturnDataEmitterError extends Error {
  readonly code: number = 0x17b0
  readonly name: string = 'InvalidReturnDataEmitter'
  constructor() {
    super('Invalid return data emitter')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, InvalidReturnDataEmitterError)
    }
  }
}

createErrorFromCodeLookup.set(0x17b0, () => new InvalidReturnDataEmitterError())
createErrorFromNameLookup.set(
  'InvalidReturnDataEmitter',
  () => new InvalidReturnDataEmitterError()
)

/**
 * WhitelistMaximumCapacityReached: 'Whitelist maximum capacity reached'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistMaximumCapacityReachedError extends Error {
  readonly code: number = 0x17b1
  readonly name: string = 'WhitelistMaximumCapacityReached'
  constructor() {
    super('Whitelist maximum capacity reached')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistMaximumCapacityReachedError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17b1,
  () => new WhitelistMaximumCapacityReachedError()
)
createErrorFromNameLookup.set(
  'WhitelistMaximumCapacityReached',
  () => new WhitelistMaximumCapacityReachedError()
)

/**
 * MakerAddressNotWhitelisted: 'Cannot respond as maker address is not whitelisted'
 *
 * @category Errors
 * @category generated
 */
export class MakerAddressNotWhitelistedError extends Error {
  readonly code: number = 0x17b2
  readonly name: string = 'MakerAddressNotWhitelisted'
  constructor() {
    super('Cannot respond as maker address is not whitelisted')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, MakerAddressNotWhitelistedError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17b2,
  () => new MakerAddressNotWhitelistedError()
)
createErrorFromNameLookup.set(
  'MakerAddressNotWhitelisted',
  () => new MakerAddressNotWhitelistedError()
)

/**
 * WhitelistCreatorMismatch: 'Whitelist creator mismatch'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistCreatorMismatchError extends Error {
  readonly code: number = 0x17b3
  readonly name: string = 'WhitelistCreatorMismatch'
  constructor() {
    super('Whitelist creator mismatch')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistCreatorMismatchError)
    }
  }
}

createErrorFromCodeLookup.set(0x17b3, () => new WhitelistCreatorMismatchError())
createErrorFromNameLookup.set(
  'WhitelistCreatorMismatch',
  () => new WhitelistCreatorMismatchError()
)

/**
 * WhitelistEmpty: 'Whitelist empty'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistEmptyError extends Error {
  readonly code: number = 0x17b4
  readonly name: string = 'WhitelistEmpty'
  constructor() {
    super('Whitelist empty')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistEmptyError)
    }
  }
}

createErrorFromCodeLookup.set(0x17b4, () => new WhitelistEmptyError())
createErrorFromNameLookup.set('WhitelistEmpty', () => new WhitelistEmptyError())

/**
 * AddressDoesNotExistOnWhitelist: 'Address does not exist on whitelist'
 *
 * @category Errors
 * @category generated
 */
export class AddressDoesNotExistOnWhitelistError extends Error {
  readonly code: number = 0x17b5
  readonly name: string = 'AddressDoesNotExistOnWhitelist'
  constructor() {
    super('Address does not exist on whitelist')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, AddressDoesNotExistOnWhitelistError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17b5,
  () => new AddressDoesNotExistOnWhitelistError()
)
createErrorFromNameLookup.set(
  'AddressDoesNotExistOnWhitelist',
  () => new AddressDoesNotExistOnWhitelistError()
)

/**
 * WhitelistNotProvided: 'Whitelist not provided'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistNotProvidedError extends Error {
  readonly code: number = 0x17b6
  readonly name: string = 'WhitelistNotProvided'
  constructor() {
    super('Whitelist not provided')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistNotProvidedError)
    }
  }
}

createErrorFromCodeLookup.set(0x17b6, () => new WhitelistNotProvidedError())
createErrorFromNameLookup.set(
  'WhitelistNotProvided',
  () => new WhitelistNotProvidedError()
)

/**
 * WhitelistAddressMismatch: 'Whitelist address mismatch'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistAddressMismatchError extends Error {
  readonly code: number = 0x17b7
  readonly name: string = 'WhitelistAddressMismatch'
  constructor() {
    super('Whitelist address mismatch')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistAddressMismatchError)
    }
  }
}

createErrorFromCodeLookup.set(0x17b7, () => new WhitelistAddressMismatchError())
createErrorFromNameLookup.set(
  'WhitelistAddressMismatch',
  () => new WhitelistAddressMismatchError()
)

/**
 * WhitelistAlreadyAssociated: 'Whitelist already associated with an RFQ'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistAlreadyAssociatedError extends Error {
  readonly code: number = 0x17b8
  readonly name: string = 'WhitelistAlreadyAssociated'
  constructor() {
    super('Whitelist already associated with an RFQ')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistAlreadyAssociatedError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17b8,
  () => new WhitelistAlreadyAssociatedError()
)
createErrorFromNameLookup.set(
  'WhitelistAlreadyAssociated',
  () => new WhitelistAlreadyAssociatedError()
)

/**
 * WhitelistHasAssociatedRfq: 'Whitelist has an associated RFQ'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistHasAssociatedRfqError extends Error {
  readonly code: number = 0x17b9
  readonly name: string = 'WhitelistHasAssociatedRfq'
  constructor() {
    super('Whitelist has an associated RFQ')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistHasAssociatedRfqError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17b9,
  () => new WhitelistHasAssociatedRfqError()
)
createErrorFromNameLookup.set(
  'WhitelistHasAssociatedRfq',
  () => new WhitelistHasAssociatedRfqError()
)

/**
 * WhitelistAssocaitionRFQMismatch: 'Whitelist RFQ association  mismatch'
 *
 * @category Errors
 * @category generated
 */
export class WhitelistAssocaitionRFQMismatchError extends Error {
  readonly code: number = 0x17ba
  readonly name: string = 'WhitelistAssocaitionRFQMismatch'
  constructor() {
    super('Whitelist RFQ association  mismatch')
    if (typeof Error.captureStackTrace === 'function') {
      Error.captureStackTrace(this, WhitelistAssocaitionRFQMismatchError)
    }
  }
}

createErrorFromCodeLookup.set(
  0x17ba,
  () => new WhitelistAssocaitionRFQMismatchError()
)
createErrorFromNameLookup.set(
  'WhitelistAssocaitionRFQMismatch',
  () => new WhitelistAssocaitionRFQMismatchError()
)

/**
 * Attempts to resolve a custom program error from the provided error code.
 * @category Errors
 * @category generated
 */
export function errorFromCode(code: number): MaybeErrorWithCode {
  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: string): MaybeErrorWithCode {
  const createError = createErrorFromNameLookup.get(name)
  return createError != null ? createError() : null
}