# DALP-9000 to DALP-9099

Source: https://docs.settlemint.com/docs/api-reference/errors/error-code-reference/dalp-9000-9099
Cause, fix and retry flag for every on-chain contract error with a code from DALP-9000 to DALP-9099.

This page lists the 70 errors in the contract error reference with a code from DALP-9000 to DALP-9099. Match the error's `id`, or its `dalpCode` on a contract error or a failed deployment step, for example `DALP-9001`, to the DALP Code column, then read Retryable and Suggested Fix. The [contract error reference](https://docs.settlemint.com/docs/api-reference/errors/error-code-reference#how-to-use-this-reference) explains each column, including Severity, and the [DALP error index](https://docs.settlemint.com/docs/api-reference/errors) lists the page for every code range.

| DALP Code | Message | Why | Suggested Fix | Severity | Retryable | Solidity Error |
| --- | --- | --- | --- | --- | --- | --- |
| DALP-9001 | Access control bad confirmation. | OpenZeppelin AccessControl requires callers to confirm role renunciation by passing their own address. The confirmation address provided did not match the caller. | Pass your own account address as the confirmation argument when calling renounceRole. | error | No | `AccessControlBadConfirmation()` |
| DALP-9002 | Access control enforced default admin delay. | A default admin transfer is scheduled but the required delay period has not elapsed. The contract enforces a minimum wait before it will accept the transfer. | Wait until the scheduled timestamp (returned as schedule in the error) has passed, then call acceptDefaultAdminTransfer to complete the role handover. | error | No | `AccessControlEnforcedDefaultAdminDelay(uint48)` |
| DALP-9003 | Access control enforced default admin rules. | Contracts that enforce default admin rules do not allow you to grant or revoke DEFAULT_ADMIN_ROLE directly. The two-step transfer process with a time delay is required for this role. | Use the beginDefaultAdminTransfer and acceptDefaultAdminTransfer sequence to change the default admin, rather than calling grantRole or revokeRole on DEFAULT_ADMIN_ROLE. | error | No | `AccessControlEnforcedDefaultAdminRules()` |
| DALP-9004 | Default admin address cannot be the zero address. | The contract requires the new default admin address to be a non-zero address. OpenZeppelin AccessControl rejects the zero address because it cannot be used as a role holder. | Provide a non-zero account address as the default admin when calling `beginDefaultAdminTransfer`. | error | No | `AccessControlInvalidDefaultAdmin(address)` |
| DALP-9005 | Access control missing any of roles. | The contract checked the caller's address against both role1 and role2 and found neither held. The caller must hold at least one of the two required roles to proceed. | Grant the caller at least one of the two required roles through the token's access manager before retrying the call. | error | No | `AccessControlMissingAnyOfRoles(address,bytes32,bytes32)` |
| DALP-9006 | Address empty code. | The target address passed to an address utility function has no deployed contract code. The call expected a contract at that address but found an externally owned account or an empty address. | Verify that the target address refers to a deployed contract on the current network before retrying the call. | error | No | `AddressEmptyCode(address)` |
| DALP-9007 | Checkpoint unordered insertion. | The checkpoint history accepts keys in non-decreasing order only. This key is lower than the most recent checkpoint key, which is an internal ordering fault. | Contact support with the `requestId` from the error. | error | No | `CheckpointUnorderedInsertion()` |
| DALP-9008 | ECDSA signature malformed. | The ECDSA recovery function returned the zero address, which means the signature bytes do not encode a valid secp256k1 signature. This typically occurs when the signature is truncated, zeroed out, or otherwise corrupted. | Re-sign the message with a valid secp256k1 private key and supply the resulting 65-byte signature. | error | No | `ECDSAInvalidSignature()` |
| DALP-9009 | ECDSA signature length is wrong. | The signature byte array supplied is `{{length}}` bytes long. A valid ECDSA signature must be exactly 65 bytes (r: 32, s: 32, v: 1). | Supply a 65-byte signature produced by signing the EIP-712 or raw hash with the owner's key. | error | No | `ECDSAInvalidSignatureLength(uint256)` |
| DALP-9010 | ECDSA signature s-value is in the upper curve half. | The `s` component of the signature (`{{s}}`) falls in the upper half of the secp256k1 curve order. The contract rejects upper-half `s` values to prevent signature malleability. | Use a signing library that produces a canonical (lower-half `s`) signature, such as a library that normalises `s` after signing. | error | No | `ECDSAInvalidSignatureS(bytes32)` |
| DALP-9011 | ERC 1155 insufficient balance. | The sender's ERC-1155 balance for the specified tokenId is less than the amount you are transferring. The error payload includes both the current balance and the needed amount. | Reduce the transfer amount to no more than the sender's current balance for tokenId, or ensure the sender has received sufficient tokens before retrying. | error | No | `ERC1155InsufficientBalance(address,uint256,uint256,uint256)` |
| DALP-9012 | ERC-1155 approval cannot come from the zero address. | The contract requires the approver in `setApprovalForAll` to be a non-zero address. OpenZeppelin ERC-1155 rejects approvals where the caller resolves to the zero address. | Call `setApprovalForAll` from a funded, non-zero account that owns the tokens. | error | No | `ERC1155InvalidApprover(address)` |
| DALP-9013 | ERC-1155 ids and values arrays have different lengths. | A batch transfer requires one value entry for every token id. The `ids` array has `{{idsLength}}` entries and the `values` array has `{{valuesLength}}` entries, so the contract cannot pair them. | Ensure the `ids` and `values` arrays passed to `safeBatchTransferFrom` have the same length before submitting. | error | No | `ERC1155InvalidArrayLength(uint256,uint256)` |
| DALP-9014 | ERC-1155 operator cannot be the zero address. | The contract requires the operator in `setApprovalForAll` to be a non-zero address. OpenZeppelin ERC-1155 rejects approval grants where the operator is the zero address. | Supply a non-zero operator address when calling `setApprovalForAll`. | error | No | `ERC1155InvalidOperator(address)` |
| DALP-9015 | ERC-1155 receiver address cannot accept tokens. | The transfer target is either the zero address or a contract that returned a value other than the ERC-1155 acceptance magic from `onERC1155Received` or `onERC1155BatchReceived`. The contract halted the transfer to prevent token loss. | Use a recipient address that is either an externally owned account or a contract that correctly implements `IERC1155Receiver`. | error | No | `ERC1155InvalidReceiver(address)` |
| DALP-9016 | ERC-1155 sender cannot be the zero address. | Transferring tokens from the zero address is not permitted by the ERC-1155 standard. The zero address has no balance and cannot be the origin of a transfer. | Initiate the transfer from a non-zero account that holds the tokens being transferred. | error | No | `ERC1155InvalidSender(address)` |
| DALP-9017 | ERC 1155 missing approval for all. | The ERC-1155 standard requires an owner to grant operator approval via setApprovalForAll before that operator can transfer tokens on their behalf. The contract blocked this transfer because the operator address does not have that approval from the token owner. | The token owner must call setApprovalForAll with the operator address and approve=true before the operator can transfer tokens. Retry the transfer after the approval transaction confirms on-chain. | error | No | `ERC1155MissingApprovalForAll(address,address)` |
| DALP-9018 | ERC-1967 implementation address has no contract code. | The contract store rejected the new implementation address (`{{implementation}}`) because it has no deployed bytecode. Setting the implementation slot to an address without code would make all proxied calls revert immediately. | Supply the address of a fully deployed, non-zero implementation contract before calling the upgrade function. | error | No | `ERC1967InvalidImplementation(address)` |
| DALP-9019 | ERC-1967 proxy upgrade cannot receive ETH. | The upgrade sent ETH with no initialisation call to pass it to. ERC-1967 refuses value on a bare upgrade. | Resubmit the upgrade with zero value, or include the initialisation call that the value is for. | error | No | `ERC1967NonPayable()` |
| DALP-9020 | ERC-1967 proxy deployed without initialisation data. | The proxy was deployed with empty initialisation data. The proxy refuses to start uninitialised. | Deploy the proxy with the implementation's initialize call as its data. | error | No | `ERC1967ProxyUninitialized()` |
| DALP-9021 | ERC 20 exceeded safe supply. | The token tracks voting power, which caps total supply at `{{cap}}`. This mint would raise total supply to `{{increasedSupply}}`. | Reduce the mint amount so total supply stays at or below `{{cap}}`. | error | No | `ERC20ExceededSafeSupply(uint256,uint256)` |
| DALP-9022 | ERC-20 approver cannot be the zero address. | The contract requires the approver (the account calling `approve`) to be a non-zero address. An allowance set by the zero address cannot be enforced. | Call `approve` from a non-zero account. The zero address cannot hold or grant token allowances. | error | No | `ERC20InvalidApprover(address)` |
| DALP-9023 | ERC-20 receiver cannot be the zero address. | Transferring or minting tokens to the zero address permanently removes them from circulation. The contract blocks this to prevent accidental token loss. | Supply a non-zero recipient address for the transfer or mint operation. | error | No | `ERC20InvalidReceiver(address)` |
| DALP-9024 | ERC-20 sender cannot be the zero address. | Transferring or burning from the zero address is not permitted. The zero address carries no real balance, and the standard treats it as the token mint/burn sink. | Initiate the transfer or burn from a non-zero account that holds the tokens. | error | No | `ERC20InvalidSender(address)` |
| DALP-9025 | ERC-20 spender cannot be the zero address. | The contract requires the spender in an `approve` or `permit` call to be a non-zero address. The standard blocks an allowance for the zero address, because no one can spend it. | Supply a non-zero spender address when calling `approve` or `permit`. | error | No | `ERC20InvalidSpender(address)` |
| DALP-9026 | Permit signature deadline expired. | The permit signature carries a deadline timestamp and the contract checks that block.timestamp is at or before that deadline. The current block time is past the deadline of `{{deadline}}`, so the permit is no longer usable. | Request a new permit signature with a future deadline timestamp. The deadline in the new permit must be greater than or equal to the current block timestamp at submission time. | error | No | `ERC2612ExpiredSignature(uint256)` |
| DALP-9027 | Permit signature signer does not match the token owner. | The contract recovered address `{{signer}}` from the permit signature, but the expected owner is `{{owner}}`. The recovered address must equal the owner for the permit to authorise the allowance. | Re-sign the EIP-712 permit digest using the private key of the token owner (`{{owner}}`), then resubmit the permit call with the updated signature. | error | No | `ERC2612InvalidSigner(address,address)` |
| DALP-9028 | Forwarder request deadline expired. | The ERC-2771 meta-transaction forwarder checks that the request deadline has not passed before executing the forwarded call. The request deadline of `{{deadline}}` has already elapsed, so the forwarder rejected the request. | Create a new meta-transaction request with a deadline in the future and re-sign it. Submit the updated request before its deadline elapses. | error | No | `ERC2771ForwarderExpiredRequest(uint48)` |
| DALP-9029 | Forwarded request signer does not match the declared sender. | The ERC-2771 forwarder recovered `{{signer}}` from the request signature, but the request declares `{{from}}` as the sender. These two addresses must match for the forwarder to authorise execution. | Re-sign the request with the `from` account's key over its current `nonces(from)` value and the exact fields submitted, then resubmit. | error | No | `ERC2771ForwarderInvalidSigner(address,address)` |
| DALP-9030 | ERC 2771 forwarder mismatched value. | The ERC-2771 forwarder requires that msg.value exactly matches the value declared in the forwarded request. The declared request value was `{{requestedValue}}` but the call arrived with msg.value of `{{msgValue}}`, so the forwarder blocked it. | Resubmit the forwarded call ensuring the ETH value sent with the transaction exactly equals the value field in the signed request. Both values must match. | error | No | `ERC2771ForwarderMismatchedValue(uint256,uint256)` |
| DALP-9031 | ERC 2771 untrustful target. | The ERC-2771 standard requires the target contract to trust the forwarder submitting the request. The target at `{{target}}` does not recognize `{{forwarder}}` as a trusted forwarder, so the contract rejected the forwarded call. | Verify that the target contract lists the forwarder address as trusted. Use a forwarder that the target contract has already registered as trusted. | error | No | `ERC2771UntrustfulTarget(address,address)` |
| DALP-9032 | ERC 5805 future lookup. | The ERC-5805 Votes extension only allows querying vote weight at past timepoints. The requested timepoint of `{{timepoint}}` is ahead of the contract's current clock value of `{{clock}}`, so the contract cannot satisfy the lookup. | Query vote weight using a timepoint that is in the past relative to the current block. Wait for the clock to advance beyond the target timepoint before retrying the lookup. | error | No | `ERC5805FutureLookup(uint256,uint48)` |
| DALP-9033 | ERC 6372 inconsistent clock. | The ERC-6372 clock extension requires that a contract's declared clock mode matches the values it returns. The contract detected an inconsistency between its clock mode descriptor and the clock value, which would make vote timestamps unreliable. | This indicates a contract configuration error. Contact the token administrator to verify that the clock mode and clock implementation are consistent. | error | No | `ERC6372InconsistentClock()` |
| DALP-9034 | ERC 721 incorrect owner. | The ERC-721 transfer function checks that the sender is the current owner of the token before executing a transfer. The contract records `{{owner}}` as the owner of token `{{tokenId}}`, not the caller address `{{sender}}`. | Only the token owner or an approved operator can transfer the token. Confirm the correct owner address and submit the transfer from that address or an approved operator. | error | No | `ERC721IncorrectOwner(address,uint256,address)` |
| DALP-9035 | ERC 721 insufficient approval. | The ERC-721 standard requires the owner to approve an operator for a specific token or for all tokens before the operator can transfer. The operator `{{operator}}` does not have sufficient approval to transfer token `{{tokenId}}`. | The token owner must approve the operator for the specific token via approve, or grant full approval via setApprovalForAll, before the operator can transfer it. | error | No | `ERC721InsufficientApproval(address,uint256)` |
| DALP-9036 | ERC-721 approver cannot be the zero address. | The contract requires the account calling `approve` to be a non-zero address. The zero address cannot own tokens and therefore cannot grant approvals. | Call `approve` from a non-zero account that is the current owner of the token. | error | No | `ERC721InvalidApprover(address)` |
| DALP-9037 | ERC-721 operator cannot be the zero address. | The contract requires the operator in `setApprovalForAll` to be a non-zero address. Granting blanket approval to the zero address has no valid use and the standard blocks it. | Supply a non-zero operator address when calling `setApprovalForAll`. | error | No | `ERC721InvalidOperator(address)` |
| DALP-9038 | ERC-721 owner cannot be the zero address. | The contract maps token ownership to non-zero addresses. Querying or minting to the zero address is not permitted because the zero address is the burned or unminted state. | Supply a non-zero owner address for the mint or ownership query. Check that the token ID exists and has not been burned. | error | No | `ERC721InvalidOwner(address)` |
| DALP-9039 | ERC-721 receiver address cannot accept tokens. | The transfer target is either the zero address or a contract that did not return the ERC-721 acceptance magic from `onERC721Received`. The contract halted the transfer to prevent the token from becoming permanently inaccessible. | Use a recipient address that is either an externally owned account or a contract that correctly implements `IERC721Receiver`. | error | No | `ERC721InvalidReceiver(address)` |
| DALP-9040 | ERC-721 transfer sender is the zero address. | The contract requires the sender address in an ERC-721 transfer or burn to be a non-zero address that holds the token. The zero address was supplied as the sender, which the contract does not recognize as a valid token holder. | Supply the actual owner address as the sender when calling the transfer or burn operation. Confirm the address holds the token before submitting. | error | No | `ERC721InvalidSender(address)` |
| DALP-9041 | ERC 721 nonexistent token. | The ERC-721 contract has no record of token `{{tokenId}}`. Either no one has minted this token yet, or a previous holder burned it, and the contract blocks all operations on it. | Verify the token ID exists by checking current ownership on-chain. Use a token ID that an address has minted and no one has burned. | error | No | `ERC721NonexistentToken(uint256)` |
| DALP-9042 | ERC 7579 already installed module. | The ERC-7579 modular account requires each module to be installed only once per module type. The account already holds module `{{module}}` under type ID `{{moduleTypeId}}`, so the contract blocked a second installation. | Check the account's currently installed modules before calling install. If you need a different module of the same type, uninstall the existing one first, then install the new one. | error | No | `ERC7579AlreadyInstalledModule(uint256,address)` |
| DALP-9043 | ERC 7579 cannot decode fallback data. | Installing or removing a fallback-handler module needs init data that starts with the 4-byte function selector the handler serves. The data supplied is shorter than 4 bytes. | Prefix the module's init data with the selector the fallback handler serves, then resubmit. | error | No | `ERC7579CannotDecodeFallbackData()` |
| DALP-9044 | ERC 7579 decoding error. | The account could not decode the batch execution data: it is too short, or its array offset or length points outside the data. | ABI-encode the batch as an `Execution[]` array of `(target, value, callData)` tuples and resubmit. | error | No | `ERC7579DecodingError()` |
| DALP-9045 | ERC 7579 mismatched module type id. | The ERC-7579 module installation verifies that the module at `{{module}}` self-reports a type that matches the requested type ID `{{moduleTypeId}}`. The module returned a different type, so the contract blocked installation to prevent misconfiguration. | Confirm that the module address and module type ID are correct. Install the module using the type ID that matches what the module contract itself declares. | error | No | `ERC7579MismatchedModuleTypeId(uint256,address)` |
| DALP-9046 | ERC 7579 missing fallback handler. | The ERC-7579 account received a call for function selector `{{selector}}` via the fallback path, but no fallback handler module covers that selector. The contract reverted rather than silently drop the call. | Install a fallback handler module that registers the required function selector before making this call. Check the account's installed fallback handlers and add the appropriate one. | error | No | `ERC7579MissingFallbackHandler(bytes4)` |
| DALP-9047 | ERC 7579 multisig already exists. | The ERC-7579 multisig module maintains a set of unique signers per account. The account's signer set already holds the provided signer bytes, so the contract blocked the duplicate addition to preserve set uniqueness. | Check the account's current signer list before calling addSigners. Remove the duplicate signer from the list or skip entries that are already registered. | error | No | `ERC7579MultisigAlreadyExists(bytes)` |
| DALP-9048 | Multisig init data is too short to decode. | The contract requires `initData` to be at least 96 bytes so it can ABI-decode the signers array and threshold. The data provided is shorter than that minimum and cannot be parsed. | Provide `initData` as a valid ABI-encoded `(bytes[], uint64)` (or `(bytes[], uint64, uint64[])` for weighted installs). A correct encoding is always at least 96 bytes. | error | No | `ERC7579MultisigInvalidInitData()` |
| DALP-9049 | Signer bytes are too short to represent a valid ERC-7913 signer. | The contract stores signers as variable-length bytes and requires each signer to be at least 20 bytes long. The signer value you supplied (`{{signer}}`) is shorter than 20 bytes, which does not meet the minimum length for an ERC-7913 signer. | Supply signer bytes that are at least 20 bytes long. For a plain EOA, encode the 20-byte address. For a contract signer, follow the ERC-7913 encoding format. | error | No | `ERC7579MultisigInvalidSigner(bytes)` |
| DALP-9050 | Signer weight of zero is not permitted. | The contract requires every signer weight to be at least 1. The weight supplied for signer `{{signer}}` is 0, which would make the signer contribute nothing toward the approval threshold. | Set the weight for each signer to 1 or greater. The minimum effective weight is 1. | error | No | `ERC7579MultisigInvalidWeight(bytes,uint64)` |
| DALP-9051 | ERC 7579 multisig mismatched length. | The multisig weight update requires one weight entry for each signer. The signers array and the weights array have different lengths, so the contract cannot map each signer to a weight. | Ensure the signers array and the weights array you pass to the weight-update call contain the same number of entries, then resubmit. | error | No | `ERC7579MultisigMismatchedLength()` |
| DALP-9052 | ERC 7579 multisig nonexistent signer. | The address bytes you provided as a signer do not appear in the account's signer set. The contract requires each signer to be registered before you can change its weight or remove it. | Verify the signer bytes match an address you previously added to the multisig. Add the signer first, or correct the signer bytes, then retry the operation. | error | No | `ERC7579MultisigNonexistentSigner(bytes)` |
| DALP-9053 | ERC 7579 multisig unreachable threshold. | The combined weight of all registered signers (`{{signers}}`) is less than the required threshold (`{{threshold}}`). Every signer would need to approve and the total weight would still fall short, making approval permanently impossible. | Either reduce the threshold to at most the current total signer weight, or add more signers with sufficient weight before setting the threshold. | error | No | `ERC7579MultisigUnreachableThreshold(uint64,uint64)` |
| DALP-9054 | ERC 7579 multisig zero threshold. | The multisig threshold must be at least 1. A threshold of zero would allow any call to pass without any signer approvals, which the contract prevents. | Set the threshold to a value of 1 or greater before installing or reconfiguring the multisig. | error | No | `ERC7579MultisigZeroThreshold()` |
| DALP-9055 | ERC 7579 uninstalled module. | The account does not have the module at the given address installed for the specified module type. The operation requires the module to be present before you can use or remove it. | Install the module on the account first using the install module call, then retry the operation. | error | No | `ERC7579UninstalledModule(uint256,address)` |
| DALP-9056 | ERC 7579 unsupported call type. | The call type byte in the execution mode (`{{callType}}`) does not match any of the supported types. This account supports single call (0x00), batch call (0x01), and delegatecall (0xff). | Set the call type byte in your execution mode to one of the supported values: 0x00 for single, 0x01 for batch, or 0xff for delegatecall. | error | No | `ERC7579UnsupportedCallType(bytes1)` |
| DALP-9057 | ERC 7579 unsupported exec type. | The exec type byte in the execution mode (`{{execType}}`) is not one of the supported types. This account supports default execution (0x00, reverts on failure) and try execution (0x01, emits an event on failure). | Set the exec type byte in your execution mode to 0x00 (default, revert on failure) or 0x01 (try, emit on failure). | error | No | `ERC7579UnsupportedExecType(bytes1)` |
| DALP-9058 | ERC 7579 unsupported module type. | The module type identifier (`{{moduleTypeId}}`) is not supported by this account. The account supports validator modules (type 1), executor modules (type 2), and fallback handler modules (type 3). | Use one of the supported module type identifiers: 1 for validator, 2 for executor, or 3 for fallback handler. | error | No | `ERC7579UnsupportedModuleType(uint256)` |
| DALP-9059 | Expected pause. | The token contract is in the wrong pause state for this call. A resume (unpause) was requested while the token is already active, or a function that requires the paused state was called while the token is active. A token on an older implementation raises it for a halt (pause) requested while the token is already paused instead. | Read the token's pause state before calling. If you asked to halt or resume it and it is already in that state, there is nothing to change. Pause the token before you call a function that requires the paused state. | error | No | `ExpectedPause()` |
| DALP-9060 | Failed call. | A low-level call failed without returning a reason. The target reverted with no data or ran out of gas. | Confirm the target address is a deployed contract and that it accepts the call. Check that you provide sufficient gas, then retry the operation. | error | No | `FailedCall()` |
| DALP-9061 | The contract does not hold enough ETH for this operation. | The ETH balance held by the contract (`{{balance}}`) is below the amount needed (`{{needed}}`) to complete the operation. The contract enforces that it holds enough ETH before proceeding. | Ensure the contract holds enough ETH to cover the required amount before retrying. You may need to send ETH to the contract first. | error | No | `InsufficientBalance(uint256,uint256)` |
| DALP-9062 | Ownership transfer to the zero address rejected. | The contract rejects `address(0)` as a proposed owner because a zero-address owner would make the contract permanently unowned and unmanageable. | Supply a non-zero Ethereum address as the new owner when calling the ownership transfer or initialization function. | error | No | `OwnableInvalidOwner(address)` |
| DALP-9063 | Reentrancy guard reentrant call. | Your code called a protected function while the same function (or another protected function) was still executing. The reentrancy guard detected a nested call and blocked it to prevent exploits. | Ensure your code does not call back into this contract from within a callback or external call that the contract itself initiates. Restructure the calling sequence to avoid nesting calls to protected functions. | error | No | `ReentrancyGuardReentrantCall()` |
| DALP-9064 | Safe cast overflowed uint downcast. | The numeric value (`{{value}}`) exceeds the maximum that a `{{bits}}`-bit unsigned integer can hold. The safe cast library prevents silent overflow by reverting instead of truncating the value. | Reduce the input value so it fits within the `{{bits}}`-bit range, then retry the operation. | error | No | `SafeCastOverflowedUintDowncast(uint8,uint256)` |
| DALP-9065 | Safe erc 20 failed operation. | A transfer or approval call on the ERC-20 token at address `{{token}}` returned false or reverted. The token contract did not confirm success. | Check that the sending address has sufficient balance and allowance, and that the token at `{{token}}` is a standard ERC-20 contract. Resolve any token-level rejection and retry the operation. | error | No | `SafeERC20FailedOperation(address)` |
| DALP-9066 | Strings insufficient hex length. | The numeric value (`{{value}}`) requires more hex digits than the requested output length (`{{length}}`) can hold. The contract cannot produce a shorter representation without losing data. | Increase the requested hex string length to fit the value, or reduce the value, then retry the operation. | error | No | `StringsInsufficientHexLength(uint256,uint256)` |
| DALP-9067 | UUPS unauthorized call context. | You called a UUPS upgrade function in an unsupported context. Either you called it directly on the implementation contract instead of through the proxy, or the notDelegated guard detected a delegatecall on a function that must run directly. | Route the upgrade call through the proxy contract, not directly to the implementation. Confirm your client is calling the proxy address. | error | No | `UUPSUnauthorizedCallContext()` |
| DALP-9068 | UUPS unsupported proxiable uuid. | During an upgrade, the new implementation's proxiableUUID() returned a storage slot (`{{slot}}`) that does not match the expected ERC-1967 implementation slot. This means the proposed implementation is not compatible with the UUPS proxy pattern used by this contract. | Ensure the new implementation contract inherits from UUPSUpgradeable correctly and returns the ERC-1967 implementation slot from proxiableUUID(). Deploy a corrected implementation, then retry the upgrade. | error | No | `UUPSUnsupportedProxiableUUID(bytes32)` |
| DALP-9069 | Permit signature verification failed for owner `{{owner}}`. | The contract called `SignatureChecker.isValidSignatureNow` with the provided bytes signature and it returned false for the expected owner (`{{owner}}`). This overload supports both ECDSA signatures and EIP-1271 contract-wallet validation, so the signature may be malformed, signed with the wrong key, or the owner contract rejected it. | Re-sign the EIP-712 permit digest with the correct key for the owner address. If the owner is a smart wallet, confirm it implements `isValidSignature` and that the signature bytes match what the wallet expects. | error | No | `ERC2612InvalidSignature(address)` |
| DALP-9081 | Convert needs the accrued-interest backlog settled first. | A full conversion on a feature set to close interest on conversion must close the holder's yield accrual. The holder still has unsettled convertible interest, and closing accrual now would discard it. | Send the conversion again. The platform drains the backlog before each convert. To settle it yourself, call `convertYield` for target tokens or `claimYield` for cash. | error | Yes | `UnsettledConvertibleInterest()` |

The previous page is [DALP-4500 to DALP-4999](https://docs.settlemint.com/docs/api-reference/errors/error-code-reference/dalp-4500-4999). The next page is [DALP-9200 to DALP-9299](https://docs.settlemint.com/docs/api-reference/errors/error-code-reference/dalp-9200-9299).