SettleMint
Errors

Error code reference

Find the cause and the fix for every on-chain revert your contracts can return, with retryability for each.

DALP contract errors identify on-chain failures. They cover validation and permission checks, the asset lifecycle, settlement, and infrastructure.

When an API or SDK response includes a DALP-#### contract error code, read the message to see what failed, the why to understand the on-chain condition, and the suggested fix to decide the next step. Use the retryability field to control retries.

Smart contract revert codes come from the current DALP ABIs. For errors at the API level such as authentication or transport failures, see Error handling.

How to use this reference

  1. Find the DALP-#### code from the API, SDK, CLI, or Console error response.
  2. Read the Message and Why columns to understand what the contract rejected and why.
  3. Apply the Suggested Fix, then use Retryable for control flow. No means repeat calls fail until the underlying condition changes. Yes means retry with backoff after confirming the request is still valid.
  4. Preserve the request ID or correlation ID from the API error envelope when you open a support ticket.

Do not parse the human-readable Message, Why, or Suggested Fix columns for program logic. Public copy can become clearer over time. Branch on the stable DALP-#### code together with the retryability flag and HTTP status from the API error envelope.

Contents

Compliance & token operations

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-1001Bond already matured.The contract already matured this bond. It blocks a second call to mature() and also blocks any non-forced transfer to a non-zero address once the bond reaches the matured state, because tokens can only be redeemed at that point.Read the isMatured flag on the bond before calling mature(). If the bond is already matured, redeem tokens directly instead of calling mature() again.errorNoBondAlreadyMatured()
DALP-1002Bond maturity date must be in the future.The contract checks that the supplied maturity date is strictly greater than the current block timestamp at initialization. A maturity date at or before the current block timestamp causes the contract to revert.Supply a maturity date that is at least one second ahead of the expected block timestamp when the transaction confirms. Check the current on-chain timestamp before constructing the bond parameters.errorNoBondInvalidMaturityDate()
DALP-1003Bond not yet matured.You attempted to redeem before the bond reached its maturity date. The bond contract locks principal redemption until the maturity timestamp passes, so the call reverts and returns the current time and the required maturity time.Wait until the bond's maturity date before redeeming. Read the maturity date from the bond, or the maturityTimestamp returned with this error, to schedule the redemption.errorNoBondNotYetMatured(uint256,uint256)
DALP-1004Bytes feeds not supported.The topic registered for this feed has a BYTES schema kind. The feeds directory currently supports only SCALAR feeds, so registering a BYTES feed reverts.Choose a topic whose registered schema kind is SCALAR. Verify the topic scheme registry entry for the topicId before submitting a feed registration.errorNoBytesFeedsNotSupported()
DALP-1005Caller must have identity.The caller's wallet address has no identity contract registered in the identity registry for this token. The transfer-approval compliance module requires the caller to hold a registered on-chain identity before granting or revoking approvals.Register an on-chain identity for the caller's wallet through the identity registry before attempting to create or revoke a transfer approval.errorNoCallerMustHaveIdentity()
DALP-1006Caller not identity owner.The caller holds no MANAGEMENT_KEY on the ERC734 identity contract under registration. The identity registry requires the registering caller to control the identity contract.Use a wallet that holds a MANAGEMENT_KEY on the identity contract, or add the caller as a MANAGEMENT_KEY holder on the identity contract before registering.errorNoCallerNotIdentityOwner()
DALP-1007Cannot transfer converted tokens.The token uses the MarkConverted debt-reduction method, which keeps source tokens on the holder's balance after conversion but marks them as encumbered. The contract tracks the holder's converted token count and blocks any transfer or burn that would move tokens beyond the unconverted portion.Reduce the transfer or burn amount to at most the holder's unconverted balance. The unconverted balance equals the holder's total token balance minus the amount already converted. Check the current converted total on-chain before resubmitting.errorNoCannotTransferConvertedTokens(uint256,uint256)
DALP-1008Cannot withdraw sale token.The token sale contract restricts fund withdrawal to accepted payment currencies only. The sale token itself cannot pass through this path because withdrawing it would drain the pool of tokens held for distribution to investors.To recover unsold sale tokens after the sale ends, use the dedicated unsold-token withdrawal call rather than withdrawFunds. Pass a payment currency address, not the sale token address, to withdrawFunds.errorNoCannotWithdrawSaleToken()
DALP-1009Compliance check failed: {{reason}}.A V1 compliance module's pre-transfer check ran and found the proposed operation does not satisfy its rules. The module reverted with a descriptive reason, which the platform captures in {{reason}}. Each compliance module enforces its own rule set, so {{reason}} describes the specific constraint.Read the {{reason}} value to identify which compliance rule the module applied. Resolve the underlying condition (for example, ensure the party has the required identity claims or is not on a block list), then resubmit.errorNoComplianceCheckFailed(string)
DALP-1010Compliance implementation not set.The system's compliance logic contract address is zero. Deploying a token or bootstrapping the system requires a valid compliance implementation address before the operation can proceed.Call setComplianceImplementation on the system contract with a valid compliance contract address before deploying tokens or bootstrapping.errorNoComplianceImplementationNotSet()
DALP-1011Compliance module already registered.A compliance module with the same type identifier (derived from its name) already exists in the compliance module registry. Each compliance module type must have a unique registration.Check the existing registry for a module with the same name before registering. To update an existing module, use the update path rather than registering again.errorNoComplianceModuleAlreadyRegistered(string)
DALP-1012Compliance module registry implementation not set.The compliance module registry logic contract address is absent from the system configuration. Operations that require the registry revert until the system stores this address.Set the compliance module registry implementation address in the system configuration before bootstrapping or operating on compliance modules.errorNoComplianceModuleRegistryImplementationNotSet()
DALP-1013Contract identity topic id not set.The contract identity topic ID passed to ensureContractIdentityClaimIsSet is zero. The topic ID must be a non-zero value from the topic scheme registry to issue a CONTRACT_IDENTITY claim.Retrieve the correct CONTRACT_IDENTITY topic ID from the topic scheme registry and pass it as the contractIdentityTopicId argument.errorNoContractIdentityTopicIdNotSet()
DALP-1014Contract missing identity interface.The contract address passed to createContractIdentityFor lacks the IContractWithIdentity interface. The factory checks this via ERC165 supportsInterface before creating an identity.Ensure the target contract implements IContractWithIdentity and registers its interface ID via ERC165. Confirm the contract address is correct before calling.errorNoContractMissingIdentityInterface(address)
DALP-1015Empty token type.The tokenType string provided to the external token registry is empty. The registry requires a non-empty type string for every token registration or type update.Provide a non-empty tokenType string that describes the category of the external token you are registering or updating.errorNoEmptyTokenType()
DALP-1016Exceeds unconverted balance.The conversion amount exceeds the holder's remaining unconverted principal balance. Under the MarkConverted debt method the contract tracks how much principal the holder already converted, and the requested amount exceeds what remains.Read the holder's unconverted balance before converting. Pass an amount no greater than the unconverted remainder, or pass 0 to convert the full remaining unconverted balance in one call.errorNoExceedsUnconvertedBalance(uint256,uint256)
DALP-1017External token registry implementation not set.The external token registry logic contract address is absent from the system configuration. The system needs this address before the external token registry can bootstrap.Set the external token registry implementation address in the system configuration before bootstrapping or using the external token registry.errorNoExternalTokenRegistryImplementationNotSet()
DALP-1018Feature token mismatch.The feature contract's token() returns an address different from the token under configuration. Each feature contract is deployed and bound to a specific token, and the contract rejects features bound to a different token.Deploy a feature contract pointing to this specific token address, or verify that the feature address you are passing targets this token and not a different one.errorNoFeatureTokenMismatch(address)
DALP-1019Fee rate frozen.A governance call to freezeFeeRate() permanently froze the AUM fee rate and fee recipient for this token. The freeze is irreversible.The fee rate and recipient are permanently locked for this token. No further changes to the AUM fee configuration are possible.errorNoFeeRateIsFrozen()
DALP-1020Fee rates frozen.A governance call to freezeFeeRates() permanently froze the transaction fee rates for this token. The fee recipient is also locked once the freeze takes effect.The transaction fee rates and fee recipient are permanently locked for this token. No further changes to fee rates are possible.errorNoFeeRatesAreFrozen()
DALP-1021Feed already exists.A feed is already registered for the given subject address and topicId combination. The feeds directory prevents duplicate feed registrations for the same subject and topic.To replace the existing feed, use the update path rather than a new registration. To register a different feed, use a different topicId.errorNoFeedAlreadyExists(address,uint256)
DALP-1022The requested resource could not be found.The feeds directory holds no feed for the given subject address and topicId combination. The operation requires an existing feed entry at that location.Register a feed for this subject and topicId first, then retry the update or lookup. Confirm the subject address and topicId are correct.errorNoFeedNotFound(address,uint256)
DALP-1023Feeds directory implementation not set.The feeds directory implementation address was absent from the system when bootstrapFeedsDirectory ran. The system needs a non-zero implementation address before it can deploy the feeds directory proxy.Set the feeds directory implementation address in the system configuration using the appropriate setter, then retry the bootstrapFeedsDirectory call.errorNoFeedsDirectoryImplementationNotSet()
DALP-1024Fees frozen.A governance call to freezeFees() permanently froze the external transaction fee configuration for this token. The fee amounts, fee recipient, and fee token cannot change after the freeze.The external transaction fee configuration is permanently locked for this token. No further changes to fees, fee recipient, or fee token are possible.errorNoFeesAreFrozen()
DALP-1025Freeze amount exceeds available balance.The requested freeze amount is larger than the holder's available (unfrozen) token balance. The custodian calculates available balance as total balance minus already-frozen tokens, and the requested amount exceeds that.Read the holder's current balance and frozen amount before freezing. The freeze amount must be no greater than (totalBalance - alreadyFrozen). Reduce the requested freeze amount accordingly.errorNoFreezeAmountExceedsAvailableBalance(uint256,uint256)
DALP-1026Global compliance not available.The system's global compliance contract address is absent from the configuration. Token compliance creation requires a deployed global compliance contract in the system before the platform can create any per-token compliance proxy.Confirm that the system completed full bootstrap with a global compliance implementation before creating token compliance. Contact your platform administrator to verify the system configuration.errorNoGlobalComplianceNotAvailable()
DALP-1027Historical balances not available.The token has no historical balances provider configured. The fixed treasury yield feature needs a resolvable historical balances provider for the token before you can attach a yield schedule.Deploy and configure the token's historical balances module in the system directory before attaching a fixed treasury yield schedule.errorNoHistoricalBalancesNotAvailable()
DALP-1028Identity already accepted.The address {{userAddress}} already holds an identity in accepted (fully registered) state. The contract applies the accept step only to identities currently in the pending state, and {{userAddress}} has already passed that step.Query the identity registry to confirm the current registration status for {{userAddress}}. The contract requires no further acceptance step for this address.errorNoIdentityAlreadyAccepted(address)
DALP-1029Identity already exists.The identity storage contract already holds an identity contract for the address {{userAddress}}. The registry stores each address only once.Use the address lookup API to retrieve the existing identity for {{userAddress}} rather than attempting a second registration.errorNoIdentityAlreadyExists(address)
DALP-1030Identity already registered.The address {{userAddress}} already has an identity association in the registry, either in pending or accepted state. The registry prevents duplicate registrations across both states to maintain a one-identity-per-address invariant.Use the identity registry read API to check the current state for {{userAddress}} before attempting registration. If a pending identity exists and you hold the appropriate role, you can accept it rather than re-registering.errorNoIdentityAlreadyRegistered(address)
DALP-1031Identity already set.The token sale contract already has an on-chain identity address set and enforces a write-once policy. The contract blocks any attempt to assign a different identity after the first assignment.Read the current on-chain identity address from the token sale contract. If the contract already holds the correct identity, no further step is required.errorNoIdentityAlreadySet()
DALP-1032Identity factory implementation not set.The system holds no identity factory implementation address. The system requires a deployed identity factory logic contract before creating identity proxies during bootstrap or token deployment.Register the identity factory implementation address in the system before retrying. A platform administrator must complete this configuration step during system setup.errorNoIdentityFactoryImplementationNotSet()
DALP-1033Identity implementation not set.The identity logic contract address has not been set in the identity factory. Proxy creation requires the factory to hold a reference to a deployed identity implementation contract.Set the identity implementation address in the identity factory before creating identity proxies. A platform administrator must complete this configuration step during platform setup.errorNoIdentityImplementationNotSet()
DALP-1034Identity not pending.The address {{userAddress}} does not have an identity in the pending state, so the contract cannot accept it. The address either has no identity associated with it at all, or the contract already accepted it previously.Register a pending identity for {{userAddress}} first using the pending registration call, then retry the accept step. Use the identity registry read API to confirm the current state.errorNoIdentityNotPending(address)
DALP-1035Identity not registered.The address {{userAddress}} has no accepted (fully registered) identity in the registry. The operation requires the address to be present in the accepted identity storage layer.Register and accept an identity for {{userAddress}} before retrying this operation. Use the identity registry read API to confirm the registration state.errorNoIdentityNotRegistered(address)
DALP-1036Identity registry already bound.The registry at {{registryAddress}} is already bound to the identity registry storage contract. Each identity registry can be bound only once to prevent duplicate bindings.Use the bound registries read API to verify the current binding state for {{registryAddress}}. No further step is required if the binding is already correct.errorNoIdentityRegistryAlreadyBound(address)
DALP-1037Identity registry implementation not set.The system holds no identity registry logic contract address. The system cannot deploy or reference an identity registry until an administrator registers an implementation address.Register the identity registry implementation address in the system configuration before retrying. Completing this step requires platform administrator access.errorNoIdentityRegistryImplementationNotSet()
DALP-1038Identity registry not bound.The registry at {{registryAddress}} is not currently bound to the identity registry storage contract. The unbind operation requires the registry to have been bound previously.Verify that {{registryAddress}} was successfully bound before attempting to unbind it. Use the bound registries read API to confirm the current state.errorNoIdentityRegistryNotBound(address)
DALP-1039Identity registry storage implementation not set.The system holds no identity registry storage logic contract address. The system requires an identity registry storage implementation before deploying the registry storage proxy.Register the identity registry storage implementation address in the system configuration before bootstrapping. Completing this step requires platform administrator access.errorNoIdentityRegistryStorageImplementationNotSet()
DALP-1040Your account does not have enough resources for this operation.The token's collateral claim covers {{available}} units but minting this amount would require {{required}} units of collateral backing. The contract enforces a configured collateral ratio against the post-mint total supply before each mint.Obtain a new or updated collateral claim from a trusted issuer that covers at least {{required}} units, then retry the mint. Reduce the mint amount so that the post-mint total supply stays within the coverage of the existing claim.errorNoInsufficientCollateral(uint256,uint256)
DALP-1041Your account does not have enough resources for this operation.The bond contract or treasury holds {{currentBalance}} of the denomination asset but the operation requires {{requiredBalance}}. Redemption or maturity processing requires the full required amount to be present before it can proceed.Transfer sufficient denomination asset to the bond treasury so the balance reaches at least {{requiredBalance}}, then retry the operation.errorNoInsufficientDenominationAssetBalance(uint256,uint256)
DALP-1042Your account does not have enough resources for this operation.The token sale contract's token balance falls below the configured hard cap. The sale requires the contract to hold the full hard cap amount of tokens before activation.Transfer tokens to the token sale contract address until its balance equals or exceeds the hard cap, then retry the activation.errorNoInsufficientTokenBalance()
DALP-1043Your account does not have enough resources for this operation.The treasury holds {{available}} but the contract requires at least {{required}} to cover the full redemption payout for all outstanding tokens at maturity. The contract enforces a solvency check at the maturity call to prevent an underfunded bond from opening redemptions.Fund the treasury with at least {{required}} of the denomination asset before calling mature. After funding, retry the maturity call.errorNoInsufficientTreasuryBalance(uint256,uint256)
DALP-1044Collateral ratio exceeds the 200% ceiling.The contract requires ratioBps to be at most 20,000 (200%). The value supplied is above that limit.Supply a collateral ratio in basis points between 0 and 20,000 inclusive. A value of 0 disables collateral enforcement; 10,000 equals 100%.errorNoInvalidCollateralRatio(uint16)
DALP-1045Collateral proof topic ID must be non-zero.The contract treats topic ID 0 as unset and rejects it. A collateral proof topic must reference a real claim topic registered on-chain.Supply a non-zero uint256 topic ID that corresponds to a valid collateral proof claim topic.errorNoInvalidCollateralTopic(uint256)
DALP-1046Compliance module address must be a non-zero contract address.The compliance module registry rejects a zero address when a module is registered. A zero address indicates the module contract has not been deployed or was not provided.Supply the deployed address of a compliance module contract.errorNoInvalidComplianceModuleAddress()
DALP-1047Contract identity implementation does not support the required interface.The identity factory validates that the contract identity implementation reports support for the IDALPContractIdentity interface via ERC-165. The provided address does not pass that check.Supply the address of a deployed contract identity implementation that correctly implements IDALPContractIdentity and returns true from supportsInterface.errorNoInvalidContractIdentityImplementation()
DALP-1048Fee rate exceeds the 100% maximum (10,000 basis points).Each individual fee rate (mint, burn, or transfer) must not exceed 10,000 basis points (100%). One or more of the supplied rates is above that limit.Supply fee rates in basis points where each value is between 0 and 10,000 inclusive. For example, 250 equals 2.5%.errorNoInvalidFeeRate()
DALP-1049Fee recipient address must be a non-zero address.The fee feature requires a valid recipient address to hold accrued fees. A zero address is rejected because fees cannot be sent to the null address.Supply a non-zero Ethereum address that will receive collected fees.errorNoInvalidFeeRecipient()
DALP-1050Fee token must not be the token contract itself.The external transaction fee feature does not allow the fee token to be the same contract as the token being transferred or this contract's own address. Using the same token for fees would create circular dependency in transfers.Supply a different ERC-20 token address as the fee token, or use the zero address to indicate the native currency.errorNoInvalidFeeToken()
DALP-1051Feed address must be a non-zero contract address.The feeds directory rejects a zero address when registering or updating a feed. A valid feed must be deployed at a real contract address.Supply the deployed address of a feed contract before submitting the registration or update request.errorNoInvalidFeedAddress()
DALP-1052Feed contract must implement the required price feed interface.The feeds directory calls decimals() and latestRoundData() on the provided feed address to verify it conforms to the expected price feed interface. The contract at the supplied address did not respond correctly to one or both of those calls.Supply the address of a feed contract that fully implements the required price feed interface, including decimals() returning a 32-byte value and latestRoundData() returning 160 bytes.errorNoInvalidFeedInterface(address)
DALP-1053Identity contract must implement the IIdentity interface.The identity registry checks via ERC-165 that the supplied contract implements IIdentity. The contract at the provided address either does not support ERC-165 or explicitly returns false for the IIdentity interface ID.Supply the address of an on-chain identity contract that implements IIdentity and returns true from supportsInterface for that interface ID.errorNoInvalidIdentityContract()
DALP-1054Identity factory address must be a non-zero address that implements the factory interface.The identity proxy constructor rejects a zero address and also rejects any address that does not report support for the IDALPIdentityFactory interface via ERC-165.Supply the deployed address of a contract that implements IDALPIdentityFactory and returns true from supportsInterface for that interface ID.errorNoInvalidIdentityFactoryAddress()
DALP-1055Identity implementation does not support the IDALPIdentity interface.The identity factory checks via ERC-165 that the provided implementation address returns true for the IDALPIdentity interface ID. The supplied address does not pass this check.Supply the address of a deployed identity implementation contract that fully implements IDALPIdentity and returns true from supportsInterface.errorNoInvalidIdentityImplementation()
DALP-1056Identity registry address must be a non-zero address.The identity registry storage rejects a zero address when binding an identity registry. Only a real, deployed registry contract address is accepted.Supply a non-zero address of a deployed identity registry contract before calling bindIdentityRegistry.errorNoInvalidIdentityRegistryAddress()
DALP-1057Wallet address must be a non-zero address.The identity registry storage rejects a zero wallet address when adding, updating, or recovering identity records. Every identity record must be linked to a valid, non-zero wallet address.Supply a non-zero Ethereum wallet address for the user whose identity record is being created or modified.errorNoInvalidIdentityWalletAddress()
DALP-1058Redemption amount must be greater than zero.The bond contract rejects a redemption call where the token amount is zero. A redemption must burn at least one token to release denomination assets.Supply a positive token amount to redeem. The bond must also have reached maturity before redemption is possible.errorNoInvalidRedemptionAmount()
DALP-1059Target identity address must be a non-zero address.The system contract rejects a claim issuance request where the target identity address is the zero address. A claim can only be issued to a deployed on-chain identity contract.Supply the address of the on-chain identity contract for the intended claim recipient.errorNoInvalidTargetIdentity()
DALP-1060Token address must be a non-zero address.The token sale factory and airdrop factory both reject a zero address when a token address is required. A zero address indicates the token has not been deployed or was not provided.Supply the deployed address of the token contract for which the sale or airdrop is being created.errorNoInvalidTokenAddress()
DALP-1061Token factory address must be a non-zero address.The token factory registry rejects a zero address when registering or updating a factory implementation. A factory must be a deployed contract with a real address.Supply the deployed address of a token factory contract that implements IDALPTokenFactory.errorNoInvalidTokenFactoryAddress()
DALP-1062Token implementation address must be a non-zero address.When registering a token factory, the registry also requires a non-zero token implementation address. A zero address indicates the implementation contract has not been provided.Supply the deployed address of a token implementation contract alongside the factory address.errorNoInvalidTokenImplementationAddress()
DALP-1063Token implementation is not accepted by the factory's interface validation.The token factory registry calls isValidTokenImplementation on the factory to verify the implementation is compatible. The factory returned false, meaning the implementation does not satisfy the factory's required interface or type constraints.Supply a token implementation address that the associated factory's isValidTokenImplementation check accepts.errorNoInvalidTokenImplementationInterface()
DALP-1064Issuer identity setup required.The system's issuer identity contract does not yet exist. Operations that issue claims on behalf of the platform require the organisation identity to be deployed and registered during system bootstrap.Complete system bootstrap, which deploys the organisation identity, before attempting claim issuance or other operations that depend on the issuer identity.errorNoIssuerIdentityNotInitialized()
DALP-1065Maturity date in past.The maturity date {{provided}} is in the past relative to the current block timestamp {{current}}. The contract requires the maturity date to be strictly in the future at the time of deployment or initialization to ensure redemptions become available at a future point.Provide a maturity date that is strictly greater than the current block timestamp. Check the current on-chain timestamp before submitting the deployment parameters.errorNoMaturityDateInPast(uint256,uint256)
DALP-1066Maturity date not reached.You called mature() before the bond's configured maturity date arrived. The contract reads maturityDate from storage and compares it to the current block timestamp; when the timestamp is still earlier than maturityDate, the revert fires and returns both values.Wait until block.timestamp >= maturityDate before calling mature(). The maturityDate value returned with this error (or readable from the bond contract) tells you the earliest timestamp at which the call will succeed.errorNoMaturityDateNotReached(uint256,uint256)
DALP-1067Minting failed.During a token conversion, the step that mints target tokens to the holder did not complete successfully. The conversion feature calls the target token's minter contract; if that call fails or the minter is misconfigured, the contract reverts to prevent issuing partial conversions.Verify that the target token's conversion minter feature is correctly deployed and that the token's minter contract has authorized it. If the configuration looks correct, contact the token issuer to inspect the minter contract's state before retrying the conversion.errorNoMintingFailed()
DALP-1068Net balance invariant violation.After executing a cross-value-proposition (XvP) settlement, the contract checked that net token positions across all participants summed to zero for each asset. At least one asset's net balance was non-zero, indicating unbalanced settlement flows.Construct the settlement flows so that every asset's total outflows equal its total inflows across all participants. Review the flow definitions for the asset address returned in this error and correct the amounts before resubmitting the settlement.errorNoNetBalanceInvariantViolation(address)
DALP-1069No denomination asset balance.You attempted to withdraw denomination asset from a fixed yield schedule, but the schedule contract holds no denomination asset balance. The contract checks the ERC-20 balance of the denomination asset before transferring and reverts when the balance is zero.Fund the yield schedule contract with the denomination asset before calling the withdrawal. Check the current denomination asset balance on the schedule contract and deposit the required amount.errorNoNoDenominationAssetBalance()
DALP-1070No fees to reconcile.You called reconcileFees() on the transaction fee accounting feature, but the contract's totalAccruedFees counter is currently zero. The feature processes a reconciliation only when fee amounts have accumulated since the last reconciliation.Reconciliation is only possible after at least one fee-bearing transfer, mint, or burn has occurred. Verify that fee-generating operations have taken place and that the accrued total is greater than zero before calling reconcileFees().errorNoNoFeesToReconcile()
DALP-1071No historical balances provider.A query requiring historical balance data was made against a token that has no historical balances provider configured. The resolver checks both the ISMARTHistoricalBalances extension on the token itself and any registered IHistoricalBalancesFeature; neither was found for the token address returned in this error.The token requires a historical balances extension or a historical balances feature before historical balance queries can succeed. Contact the token issuer to verify that the historical balances capability is configured on the token.errorNoNoHistoricalBalancesProvider(address)
DALP-1072No tokens to recover.You attempted to recover a token from an address that holds a zero balance of the target ERC-20. The contract checks the token balance before initiating recovery and reverts when there is nothing to recover.Verify that the target address actually holds a non-zero balance of the token you are attempting to recover. Query the token balance on-chain before calling the recovery function.errorNoNoTokensToRecover()
DALP-1073Not whitelisted.The caller attempted to participate in a presale token purchase, but their address is not on the presale whitelist. The token sale contract enforces a whitelist during the presale phase; only addresses added by the sale operator can purchase during this period.Contact the token sale operator to request inclusion on the presale whitelist. Once the operator adds your address, you can retry the purchase. Alternatively, wait for the presale to end and the public sale to begin, at which point the whitelist restriction is lifted.errorNoNotWhitelisted()
DALP-1074Recipient address frozen.A transfer, mint, or other token operation targeting this recipient was blocked because a custodian froze that recipient's address. The SMART custodian extension marks individual addresses as frozen; while frozen, no tokens can be sent to that address.An authorized custodian must unfreeze the recipient's address before tokens can be delivered to it. Contact the token custodian or issuer to request that the recipient address be unfrozen.errorNoRecipientAddressFrozen()
DALP-1075Recover insufficient balance.An ERC-20 recovery call requested an amount larger than the contract's current balance of that token. The recovery function checks the contract balance before transferring and reverts when the balance is lower than the requested amount.Reduce the recovery amount to at most the contract's current token balance, or split the recovery into smaller amounts. Query the contract's token balance first to determine the maximum recoverable amount.errorNoRecoverInsufficientBalance()
DALP-1076Sender address frozen.A transfer or burn operation from this sender was blocked because a custodian froze the sender's address. The SMART custodian extension marks individual addresses as frozen; while frozen, that address cannot initiate token movements.An authorized custodian must unfreeze the sender's address before it can send or burn tokens. Contact the token custodian or issuer to request that the sender address be unfrozen.errorNoSenderAddressFrozen()
DALP-1077Token access manager implementation not set.The system deployment step requires a token access manager implementation address, but none has been set in the system registry. The system contract checks this implementation slot before deploying or bootstrapping tokens and reverts when the slot is empty.Set the token access manager implementation address in the system registry before retrying the deployment or bootstrap step. A holder of the SYSTEM_MANAGER_ROLE must complete this system configuration step.errorNoTokenAccessManagerImplementationNotSet()
DALP-1078Token already bound.You submitted a token address to the system compliance contract's bindToken function, but the contract already records that token in its bound-tokens mapping. Each token address can be bound to the system compliance contract only once.Call isTokenBound(tokenAddress) on the system compliance contract to check whether the token is already bound before attempting to bind it again. If it is already bound, no further step is needed.errorNoTokenAlreadyBound(address)
DALP-1079Token already registered.You submitted a token address to the external token registry's registerToken function, but the contract already records that address in its _isRegistered mapping. Each external token can only be registered once.Check whether the token is already registered by calling isRegistered(tokenAddress) on the external token registry before attempting to register it again. If already registered and the type is wrong, use updateTokenType instead.errorNoTokenAlreadyRegistered(address)
DALP-1080Token compliance already exists.The token compliance factory received a createTokenCompliance call for a token address that already has a compliance contract recorded in its _tokenCompliances mapping. A token can only have one compliance contract created through this factory.Retrieve the existing compliance contract address by calling predictTokenComplianceAddress(tokenAddress) on the compliance factory, or look up the address stored in the factory's mapping. Use the existing compliance contract rather than creating another.errorNoTokenComplianceAlreadyExists(address)
DALP-1081Token compliance factory not available.The V2 token factory's _createTokenCompliance helper resolved the token compliance factory proxy address from the system registry and found a zero address. The token compliance factory must be deployed and registered before V2 tokens can be created.Deploy and register the token compliance factory in the system registry before deploying V2 tokens. A holder of the SYSTEM_MANAGER_ROLE must complete this system setup step.errorNoTokenComplianceFactoryNotAvailable()
DALP-1082Token decimals too high.The conversion feature factory checked the ERC-20 decimals() of the loan token or the target token and found a value greater than 18. The conversion's WAD-based pricing math requires both tokens to have at most 18 decimal places.The token returned in this error has more than 18 decimals, which is incompatible with the conversion feature. Use a token with 18 or fewer decimals as either the loan token or the target token in the conversion configuration.errorNoTokenDecimalsTooHigh(address,uint8)
DALP-1083Token factory registry implementation not set.A system operation required the token factory registry implementation address, but the slot in the system registry is empty. The system contract checks this implementation slot during setup and bootstrap steps.Set the token factory registry implementation address in the system registry before retrying the setup step. A holder of the SYSTEM_MANAGER_ROLE must complete this system configuration step.errorNoTokenFactoryRegistryImplementationNotSet()
DALP-1084Token factory type already registered.A token factory type with the same name was already registered in the factory registry. The V1 registry uses a keccak256 hash of the type name as its key; if that key is already occupied, a second registration for the same name reverts.Each token factory type name must be unique in the registry. Check the registered factory types before attempting to register, and use a distinct name if you are registering a new factory type.errorNoTokenFactoryTypeAlreadyRegistered(string)
DALP-1085Token factory type already registered.A token factory type with the same typeId (bytes32) was already registered in the V2 factory registry and is not in an archived state. The V2 registry allows unarchiving an archived entry under the same key but rejects a fully active duplicate registration.Each token factory type identifier must be unique in the V2 registry. If you are trying to upgrade an existing factory, archive the old registration first. If you are registering a new type, use a distinct typeId.errorNoTokenFactoryTypeAlreadyRegisteredV2(bytes32)
DALP-1086Token identity address mismatch.During token deployment the factory computes a deterministic CREATE2 address for the token identity contract and then verifies the deployed address matches. The deployed identity address (deployedTokenIdentityAddress) does not match the predicted address (tokenIdentityAddress), meaning the factory's internal consistency check failed.Adjusting request parameters cannot resolve this system-level deployment failure. Contact support with the deployedTokenIdentityAddress and tokenIdentityAddress values from the error.errorNoTokenIdentityAddressMismatch(address,address)
DALP-1087Token implementation not set.The system directory has no logic contract address recorded for the token implementation slot. The factory cannot deploy a token proxy without a valid implementation address to point to.A system administrator must register a token implementation address in the directory before token deployment can proceed. Contact your platform operator to verify the token implementation is correctly configured.errorNoTokenImplementationNotSet()
DALP-1088Token must support access managed.Creating a token sale requires the token to expose an access manager so the sale contract can read roles. The token at the given address must implement the ISMARTTokenAccessManaged interface for the factory to proceed; it verified via ERC-165 that this interface is absent.Token sale creation is only supported for tokens that implement the ISMARTTokenAccessManaged interface. Verify you are using the correct token address and that the token was deployed with access-management support enabled.errorNoTokenMustSupportAccessManaged()
DALP-1089Token not bound.The per-token compliance contract has no token address bound to it. The compliance contract requires a bound token before it can process transfer checks or other operations.The token compliance contract must be bound to a token address before use. The token factory performs this binding during deployment. If you see this error outside of a factory flow, contact support.errorNoTokenNotBound()
DALP-1090Token not bound.The system compliance contract has no binding recorded for the token address provided. Transfer hooks and burn hooks require the token to be registered with the system compliance layer before the contract can process them.The token must be bound to the system compliance contract first. For newly deployed tokens this happens during factory setup. For pre-existing tokens, use the batch binding migration path. Contact your platform operator if the binding is missing.errorNoTokenNotBound(address)
DALP-1091Token not registered.The external token registry does not contain the token address. Operations that read or update the token type require you to register the token first.Register the token address in the external token registry before calling operations that require it. A TOKEN_MANAGER_ROLE holder can register the token via the registry's registration function.errorNoTokenNotRegistered(address)
DALP-1092Transfer blocked after maturity.The bond has reached its maturity date, after which the contract blocks all regular transfers and mints. Only forced custodian transfers are allowed post-maturity. The contract returns the from and to addresses that triggered the block in the error.Post-maturity token movements require a forced custodian transfer rather than a standard transfer or mint. Review whether a redemption is the intended next step instead of a transfer.errorNoTransferBlockedAfterMaturity(address,address)
DALP-1093You do not have permission for this operation.The caller's on-chain identity is not in the list of configured approval authorities for this transfer approval compliance module. Only registered approval authorities can create, revoke, or consume transfer approvals.Request that a system administrator add your identity as an approval authority for this module, then retry the operation.errorNoUnauthorizedApprover()
DALP-1094You do not have permission for this operation.Creating a price feed requires either a system-level role (for global feeds) or the GOVERNANCE_ROLE on the subject token (for token-scoped feeds). The caller holds neither of the required roles for the requested subject.Obtain the GOVERNANCE_ROLE on the subject token (or the appropriate system role for global feeds) before creating a feed. Contact the token's governance administrator to request the role.errorNoUnauthorizedFeedCreation()
DALP-1095You do not have permission for this operation.Creating a token sale requires either the TOKEN_FACTORY_MODULE_ROLE at the system level or the GOVERNANCE_ROLE on the specific subject token. The caller holds neither role, so the factory rejects the request.Obtain the GOVERNANCE_ROLE on the subject token or have a system administrator with TOKEN_FACTORY_MODULE_ROLE create the sale on your behalf.errorNoUnauthorizedTokenSaleCreation()
DALP-1096The compliance rules blocked this transfer: the sender or recipient does not meet the token's requirements.One of the token's compliance rules blocked the transfer.Check both parties' identity registration and claims, then retry.errorNoTransferNotCompliant()
DALP-1097Wallet not registered to this identity.The identity recovery process verifies that the wallet you are reporting as lost is linked to the specified identity contract. The registry does not record that wallet address as belonging to that identity contract, so the recovery request cannot proceed.Confirm the correct identity contract address for the wallet. Retrieve the wallet's registered identity from the identity registry and retry the recovery request with the matching identity contract address.errorNoWalletNotRegisteredToThisIdentity(address,address)
DALP-1098A required value cannot be zero.The redemption call specified an amount of zero. The maturity redemption contract requires a positive amount to process the redemption and burn the corresponding tokens.Submit the redemption request with a non-zero token amount. Check the account's available balance before calling redeem.errorNoZeroRedemptionAmount()
DALP-1099Feeds directory address is zero.The price resolver contract requires a non-zero feeds directory address during initialization. The address passed to initialize was the zero address.Supply the deployed feeds directory contract address when calling initialize.errorNoInvalidFeedsDirectory()
DALP-1100This wallet is not associated with the expected identity.The identity registry storage contract checked whether the given wallet is currently registered under the specified identity contract. The wallet's on-chain record points to a different identity, so the contract blocked the operation to prevent an incorrect lost-wallet marking.Confirm your wallet is linked to the correct identity, or contact your administrator for assistance.errorNoWalletNotAssociatedWithIdentity(address,address)
DALP-1101The account does not have enough tokens. Available: {{available}}, required: {{required}}.The ERC-20 contract enforces that a sender holds at least the requested token amount before any transfer or burn proceeds. In this token's custodian extension, only the unfrozen portion of the balance counts: a custodian has frozen the remainder, so it does not appear in {{available}}.Check the token balance and try again with a smaller amount, or acquire more tokens.errorNoERC20InsufficientBalance(address,uint256,uint256)
DALP-1102The token allowance is too low. Current allowance: {{allowance}}, required: {{required}}.The ERC-20 contract requires a spender to have an approved allowance of at least the requested amount before it can transfer tokens on behalf of the owner. The current allowance is {{allowance}}, which is below the {{required}} needed for this transfer.Approve a sufficient token allowance before retrying the operation.errorYesERC20InsufficientAllowance(address,uint256,uint256)
DALP-1103Contract paused; this operation is unavailable.An administrator has placed the contract in a paused state. While paused, the contract rejects calls to protected functions such as transfers and mints.Wait for the administrator to resume operations, then try again.warningYesEnforcedPause()
DALP-1104The account {{account}} does not have a registered identity on this platform.The identity registry storage has no record for account {{account}}. Every account must have a registered identity before the token contract will accept transfers or compliance checks involving that address.The account owner needs to complete the identity registration process before they can interact with this token.errorNoIdentityDoesNotExist(address)
DALP-1105The approved spending amount is not enough. Current: {{currentAllowance}}, required: {{requiredAllowance}}.During settlement approval, the contract checks that the caller has approved enough of the asset token for the settlement contract to pull. The current allowance ({{currentAllowance}}) is less than the amount the settlement flow requires ({{requiredAllowance}}), so the contract cannot lock the tokens.Increase the token allowance to cover the required amount, then try again.errorYesInsufficientAllowance(address,address,address,uint256,uint256)
DALP-1106The amount exceeds the currently frozen token balance. Available: {{available}}, requested: {{requested}}.The unfreeze request asks for more tokens ({{requested}}) than are currently held in the frozen balance for this address ({{available}}). The contract blocks the operation to prevent the frozen balance from going below zero.Reduce the amount to at most the currently frozen balance, or freeze additional tokens first.errorNoInsufficientFrozenTokens(uint256,uint256)
DALP-1107Identity contract address is zero.The identity registry storage contract requires a non-zero identity contract address. The _identity argument passed to addIdentityToStorage or updateIdentityToStorage was the zero address.Provide the deployed on-chain identity contract address for the wallet being registered.errorNoInvalidIdentityAddress()
DALP-1108Settlement flow asset is not a valid ERC-20 token.Each settlement flow must reference a non-zero token address that exposes the ERC-20 decimals() selector. The flow asset address must be a non-zero ERC-20 contract address that implements that function.Set each flow's asset to a deployed ERC-20 token contract address and confirm the contract exposes decimals().errorNoInvalidToken()
DALP-1109Token paused; no operations are available.An administrator activated the token's pausable extension. The whenNotPaused guard blocks transfers and mints until the token is unpaused. Forced custodian operations are exempt from this check.Wait for the token administrator to resume the token, then try again.warningYesTokenPaused()
DALP-1110The compliance rules blocked this mint: the recipient does not meet the token's requirements.One of the token's compliance rules blocked the mint.Check the recipient's identity registration and claims, then retry.errorNoMintNotCompliant()
DALP-1111Stale feed.The price resolver read a feed whose last update timestamp is older than the configured maximum staleness window. The error returns the subject address, topic id, the feed's last updatedAt timestamp, and the configured maxAge so you can calculate how stale the feed is.Wait for the price feed to receive a fresh update, then retry the operation. If the feed is consistently stale, contact the feed provider or your platform operator to investigate the oracle update frequency.errorNoStaleFeed(address,uint256,uint256,uint256)
DALP-1112Token compliance creation failed.The token factory called the token compliance factory to create a per-token compliance contract, but the factory returned the zero address instead of a deployed contract address. The token deployment cannot proceed without a valid compliance contract.This is a system configuration failure. Contact your platform operator to verify that the token compliance factory is correctly deployed and that the directory points to it.errorNoTokenComplianceCreationFailed()
DALP-1113Not factory token.The migration call passed a token address that was not originally deployed by this factory. The factory tracks every token it created, and the provided address is absent from that record, so it cannot safely bind or backfill it.Ensure the token address belongs to this factory by checking the factory's token list. Only tokens this factory originally deployed can be migrated through it.errorNoNotFactoryToken(address)
DALP-1114Only compliance engine.An address other than the bound compliance engine called a configuration update on this module. The module restricts this operation to the engine contract it governs.Configuration updates to this compliance module must be sent through the compliance engine that governs it. Call updateConfig via the engine, not directly on the module.errorNoOnlyComplianceEngine()
DALP-1115Token registries already exist.The registry factory already deployed per-token identity and storage registries for this token address. The registry factory enforces one set of per-token registries per token to prevent duplicate deployments.The registry factory creates per-token registries only once per token. Retrieve the existing registries from the registry factory instead of attempting to create new ones.errorNoTokenRegistriesAlreadyExist(address)
DALP-1116Token registry implementations missing.Deploying the per-token registry factory requires all three registry implementations (token identity registry, token storage registry, and identity registry) to be present in the directory. At least one is missing.A system administrator must register all three per-token registry implementations in the directory before the registry factory can deploy. Contact your platform operator to complete the directory configuration.errorNoTokenRegistryImplementationsMissing()
DALP-1117Compliance module type mismatch.Updating a compliance module implementation requires the new contract's typeId() to match the module slot being updated. The new implementation reports a different typeId (actualTypeId) than the slot's registered identifier (expectedTypeId), indicating you provided the wrong implementation.Deploy or supply a compliance module implementation whose typeId() matches the module slot identifier you are updating. Verify the correct implementation address against the module registry.errorNoComplianceModuleTypeMismatch(bytes32,bytes32)
DALP-1118Unsupported compliance module.The address provided as a compliance module implementation does not support any recognized compliance module interface. The directory validates the interface via ERC-165 before accepting an implementation, and this address failed all three probes.Supply an implementation address that correctly implements a supported compliance module interface. Verify you have deployed the contract and that it exposes the expected ERC-165 interface identifiers.errorNoUnsupportedComplianceModule(address)
DALP-1119Token scope not supported.The compliance module you are installing belongs to a token-level compliance engine. Token-level engines do not support per-token inclusion or exemption scope filters; only the system compliance engine accepts those dimensions. The contract reverts whenever the scope passed to installScopedModule contains a non-empty tokenInclusion or tokenExemption list.Remove the tokenInclusion and tokenExemption entries from the scope before calling installScopedModule on a token-level compliance engine. If you require per-token scoping, use the system compliance engine instead.errorNoTokenScopeNotSupported()
DALP-1120Compliance check failed: {{reason}}.A V2 compliance module instance checked the proposed transfer or mint and found it does not meet the module's requirements. The error identifies the specific module instance, module type, and reason code (for example, COMPLIANCE_CHECK_REASON_EXCEEDS_SUPPLY_CAP or COMPLIANCE_CHECK_REASON_COUNTRY_BLOCKED) so the exact constraint is machine-readable.Inspect the moduleCode to identify which compliance module rejected the request, and the reasonCode to determine the specific rule that was not satisfied. Resolve that constraint for the relevant party or amount, then resubmit.errorNoComplianceCheckFailed(address,bytes32,bytes32,string)
DALP-1121Identity v2 not supported.The identity factory targets V2 identity proxy deployment, but the underlying implementation contract does not expose the IDALPIdentityV2 interface. The factory checks supportsInterface at deploy time and reverts when the implementation predates V2.Verify that the identity factory is pointing to a V2-capable implementation. Contact your platform administrator to update the factory's implementation address to one that supports IDALPIdentityV2 before retrying the identity creation call.errorNoIdentityV2NotSupported()
DALP-1122Authorization deadline expired.The signed authorization included a deadline timestamp, and the current block time is past that deadline. The contract validates the authorization before creating the identity with management keys and reverts when the deadline has elapsed.Request a new signed authorization with a deadline that has not yet passed, then resubmit the identity creation call with the updated signature and deadline.errorNoExpiredIdentityManagementKeyAuthorization(uint256)
DALP-1123Identity authorization signature does not match the wallet.The EIP-712 signature provided for createIdentityWithManagementKeyAuthorization recovered to a different address than the target wallet. The recovered argument in the error carries the address that was actually recovered.Re-sign the authorization digest with the private key of the wallet address passed as _wallet. Confirm the domain separator matches the identity factory contract and chain.errorNoInvalidIdentityManagementKeyAuthorization(address,address)
DALP-1124The scheduled maturity date has passed; early maturity is not applicable.The emergency early-maturity call is only available before the scheduled maturity date. The current time ({{currentTime}}) has reached or passed the maturity timestamp ({{maturityDate}}), so the early-maturity path is no longer applicable.Use the regular maturity operation (governance role) to mature this bond. The emergency window applies only before the scheduled date.errorNoMaturityDateAlreadyReached(uint256,uint256)
DALP-1125Fee rate too high.The fee rate supplied in the feature configuration exceeds 10,000 basis points (100%). The contract enforces that no fee rate can be set above 100 percent of the transaction amount.Set feeBps to a value of 10,000 or less in the feature configuration and resubmit.errorNoFeeRateTooHigh(uint16)
DALP-1126Fee token required when fees non zero.The external transaction fee feature configuration sets at least one of mintFee, burnFee, or transferFee to a non-zero value but leaves the fee token address as the zero address. The contract requires a fee token whenever any fee amount is non-zero.Supply a valid fee token address in the configuration alongside the non-zero fee amounts, or set all fee amounts to zero if no fee token is available.errorNoFeeTokenRequiredWhenFeesNonZero()
DALP-1127Conversion feature target token address is zero.The conversion feature configuration requires a non-zero targetToken address. The value supplied in the config was the zero address.Set config.targetToken to the deployed address of the token to be received after conversion.errorNoInvalidTargetToken()
DALP-1128Maturity date zero.The maturity date value in the maturity redemption feature configuration is zero. The contract requires a non-zero Unix timestamp for the maturity date before it will accept the configuration.Provide a valid future Unix timestamp as the maturityDate in the feature configuration and resubmit.errorNoMaturityDateZero()
DALP-1129Native recovery failed.The paymaster refund splitter attempted to send native currency to the target address and the low-level call returned false. This typically indicates the recipient contract rejected the transfer or ran out of gas.Verify that the recipient address can accept native currency transfers. If the recipient is a contract, confirm it has a payable fallback or receive function, then retry the recoverNative call.errorNoNativeRecoveryFailed()
DALP-1130Token not system registered.The system identity registry does not record the token address you provided. The token sale factory requires all tokens to be registered in the system registry before a sale can be created for them, ensuring only legitimately provisioned tokens can be associated with a sale.Confirm the system has fully provisioned and registered the token before attempting to create a token sale. If the token was recently deployed, wait for indexing to complete and retry.errorNoTokenNotSystemRegistered()

Settlement & XvP

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-2001Sender not approved settlement.The caller attempted to revoke their approval on an XvP settlement, but their address has no recorded approval. The settlement contract only permits revoking an approval that the same address previously granted.Only call revokeApproval from an address that has already called approve on this settlement. Verify the address and settlement contract before retrying.errorNoSenderNotApprovedSettlement()
DALP-2003You are not a participant in this settlement.The contract checks every flow's sender address against the caller. Your account does not appear as a sender in any of this settlement's configured flows, so the contract cannot grant you access.Verify that you are using the correct account and settlement reference.errorNoSenderNotInvolvedInSettlement()
DALP-2004Settlement already cancelled.The settlement reached a cancelled terminal state before this call arrived. Once cancelled, the contract blocks all further operations on this settlement.No further step is possible. Create a new settlement if needed.errorNoXvPSettlementAlreadyCancelled()
DALP-2005Settlement already completed.The contract already executed this settlement and transferred all token flows. It blocks further operations once execution completes.No further step is needed. The settlement completed successfully.errorNoXvPSettlementAlreadyExecuted()
DALP-2006Settlement expired and the contract blocked execution.The settlement's cutoff date has passed. The contract blocks execution and approval once the cutoff timestamp passes.Create a new settlement with an updated deadline.errorNoXvPSettlementExpired()
DALP-2007Settlement expired and the contract already returned the funds.The contract already processed this expired withdrawal. It sets a withdrawn flag after the first successful call to withdrawExpired and rejects any repeat calls.No further withdrawal is needed. The contract returned the funds when the settlement expired.errorNoXvPSettlementExpiredWithdrawalAlreadyProcessed()
DALP-2008Not all parties have approved this settlement.Execution requires every local sender in the settlement to have called approve. At least one local sender has not yet approved, so the settlement is not fully approved.Check which participants still need to approve, then ask them to do so.errorYesXvPSettlementNotApproved()
DALP-2009This settlement has not yet expired.The withdrawExpired call requires the settlement's cutoff timestamp to have passed. The settlement is still within its active window, so the expired withdrawal path is not yet available.Expired withdrawal is only available after the settlement deadline has passed.errorYesXvPSettlementNotExpired()
DALP-2010This settlement requires a security code to execute.This settlement includes flows on external chains, which requires a hashlock to coordinate cross-chain execution. You did not provide a hashlock when you created the settlement, so the contract rejected initialization.Provide the required security code when executing the settlement.errorYesHashlockRequired()
DALP-2011Settlement cutoff date is not in the future.The XvP settlement factory requires the cutoff date to be strictly greater than the current block timestamp. The value supplied was equal to or before the current time.Set the cutoff date to a Unix timestamp that is at least one second after the current block time.errorNoInvalidCutoffDate()
DALP-2012The settlement has no payment flows defined.The settlement requires at least one payment flow specifying what token each party sends and receives. You submitted the settlement with an empty flows array.Add at least one payment flow specifying the tokens and amounts to exchange.errorYesEmptyFlows()
DALP-2013You have already approved this settlement.The contract records one approval per sender address. Your account has already called approve for this settlement, and the approval is already on-chain.No further step is needed. The contract has recorded your approval.warningNoSenderAlreadyApprovedSettlement()

Airdrop & distribution

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-3001Airdrop ended.The current block timestamp is past the airdrop's configured end time. The time-bound airdrop contract enforces a claim window and reverts any claim or distribution attempted after the window closes.The claim window for this airdrop has closed. You cannot submit further claims. Review the airdrop's configured end time to confirm.errorNoAirdropEnded()
DALP-3002Airdrop not started.The current block timestamp is before the airdrop's configured start time. The time-bound airdrop contract enforces a claim window and reverts any claim submitted before the window opens.Wait until the airdrop's start time has passed before submitting a claim. Check the airdrop's configured startTime to determine when claims become available.errorNoAirdropNotStarted()
DALP-3003Claim already revoked.The signature hash for this claim is already present in the revoked claims registry. The contract permits revoking each claim signature only once and blocks duplicate revocations.The contract already revoked this claim. No further steps are needed for revocation. Verify the claim's current state before submitting another revocation request.errorNoClaimAlreadyRevoked(bytes32)
DALP-3004The requested resource could not be found.The ERC-735 identity contract stores no claim under the claimId you provided. The contract looks up claims by their computed ID and reverts when no matching claim exists.Verify the claimId by computing it from the correct issuer and topic for the identity address. Confirm the contract successfully added the claim before attempting to retrieve or remove it.errorNoClaimDoesNotExist(bytes32)
DALP-3005Claim not eligible.The vesting airdrop contract determined the caller does not meet the eligibility conditions required to claim at this time. The airdrop may have eligibility requirements that the caller's address or state does not currently satisfy.Confirm the airdrop includes your address in the eligible set and that you meet all required conditions. If eligibility depends on a time-based or on-chain state, verify that the current state satisfies those conditions before retrying.errorNoClaimNotEligible()
DALP-3006Claim not valid according to issuer.When adding a claim signed by an external issuer, the issuer's isClaimValid function returned false for the given topic and signature. The contract verifies claim validity with the issuer before storing it, and reverts when the issuer rejects the claim.Request a fresh, valid claim signature from the issuer for the correct topic and identity address. Verify the issuer address and topic value match what the issuer signed before resubmitting.errorNoClaimNotValidAccordingToIssuer(address,uint256)
DALP-3007Cliff exceeds vesting duration.The cliff duration provided to the linear vesting strategy is longer than the total vesting duration. The contract enforces that the cliff period must fall within the overall vesting period.Set the cliff duration to a value less than or equal to the vesting duration and redeploy the vesting strategy.errorNoCliffExceedsVestingDuration()
DALP-3008Distribution cap exceeded.The amount being distributed would cause the total distributed so far to exceed the distribution cap configured on the airdrop. The contract enforces the cap to prevent distributing more tokens than the allocation permits.Reduce the distribution amount so that the sum of all distributed amounts stays within the configured cap, or verify the cap value against the intended total allocation.errorNoDistributionCapExceeded()
DALP-3009Duplicate claim topic.The claim topics array provided when registering or updating a trusted issuer contains the same topic value more than once. The contract requires each topic to appear exactly once in the list.Remove duplicate topic values from the claimTopics array so that each topic appears only once, then resubmit the trusted issuer registration call.errorNoDuplicateClaimTopic(uint256)
DALP-3010Airdrop name is empty.The airdrop contract requires a non-empty name string during initialization. The name_ argument passed to the initializer had zero bytes.Provide a non-empty string as the airdrop name.errorNoInvalidAirdropName()
DALP-3011Claim tracker address is zero or missing the required interface.The airdrop initializer requires a non-zero claim tracker address that implements IDALPClaimTracker. The address was either zero or the interface probe call failed.Supply the address of a deployed IDALPClaimTracker contract such as DALPBitmapClaimTracker.errorNoInvalidClaimTrackerAddress()
DALP-3012Distribution recipient address is zero.Each push airdrop distribution call requires a non-zero recipient address. The recipient argument was the zero address.Provide a valid, non-zero recipient address for the distribution.errorNoInvalidDistributionAddress()
DALP-3013Merkle root is zero.The airdrop initializer requires a non-zero Merkle root. The root_ argument was bytes32(0), which would make every proof verification fail.Supply the Merkle root computed from the airdrop allocation tree before calling the initializer.errorNoInvalidMerkleRoot()
DALP-3014Vesting duration is zero.The linear vesting strategy constructor requires a vesting duration greater than zero. A duration of zero would make the vesting schedule complete immediately at deployment.Set vestingDuration_ to the desired total vesting period in seconds (greater than zero).errorNoInvalidVestingDuration()
DALP-3015Vesting strategy does not support multiple claims.The vesting airdrop contract requires a vesting strategy that returns true from supportsMultipleClaims(). The strategy at the provided address either reverted or returned false.Use a vesting strategy implementation that supports incremental claim release, such as DALPLinearVestingStrategy.errorNoInvalidVestingStrategy(address)
DALP-3016Vesting strategy address is zero.The vesting airdrop initializer requires a non-zero vesting strategy address. The vestingStrategy_ argument was the zero address.Deploy a compatible vesting strategy contract and pass its address to the initializer.errorNoInvalidVestingStrategyAddress()
DALP-3017No claim topics provided.The trusted issuers registry requires at least one claim topic when registering or updating a trusted issuer. The call supplied an empty list of claim topics, so the registry rejected it.Include at least one claim topic in the trusted issuer registration request and resubmit.errorNoNoClaimTopicsProvided()
DALP-3018Push airdrop claim not allowed.Push airdrops are admin-controlled: the contract owner distributes tokens directly to recipients. The contract disables the claim functions by design, so calling them always reverts.Push airdrop recipients receive their allocation from the administrator. Contact the airdrop administrator to have your allocation distributed to your address.errorNoPushAirdropClaimNotAllowed()
DALP-3019Sender lacks claim signer key.Adding or removing a claim on an identity requires the caller to hold a CLAIM_SIGNER_KEY for that identity. The sending address does not have that key registered on-chain.Use an address that holds the CLAIM_SIGNER_KEY on the target identity, or ask the identity owner to add the key before retrying.errorNoSenderLacksClaimSignerKey()
DALP-3020You do not have permission for this operation.Creating a push airdrop requires either the TOKEN_FACTORY_MODULE_ROLE in the system or the GOVERNANCE_ROLE on the subject token. The calling address holds neither role.Use an address that holds GOVERNANCE_ROLE on the subject token, or request that a system manager with TOKEN_FACTORY_MODULE_ROLE create the airdrop.errorNoUnauthorizedAirdropCreation()
DALP-3021You do not have permission for this operation.A CONTRACT-scheme claim requires the claim issuer contract itself to call addClaim, with its own address as msg.sender. The call arrived from a different address.The claim must be submitted directly from the issuer contract address ({{caller}}). Ensure the issuer contract is calling addClaim itself, with msg.sender equal to the issuer field ({{issuer}}).errorNoUnauthorizedContractClaim(address,address)
DALP-3022Unsupported claim scheme.The ERC-735 claim implementation accepts ECDSA and ERC-1271 signature schemes, plus CONTRACT. You submitted a scheme value ({{scheme}}) that does not match any of those.Resubmit the claim using a supported scheme: ECDSA (1), ERC-1271 (2), or CONTRACT (3). Check the ERC-735 scheme constants for the correct value.errorNoUnsupportedClaimScheme(uint256)
DALP-3023Vesting airdrop implementation not set.The vesting airdrop factory requires a deployed vesting airdrop implementation contract before new vesting airdrops can be created. No one has configured the factory's implementation address yet.A system manager must call updateImplementation on the vesting airdrop factory with a valid implementation address before creating vesting airdrops.errorNoVestingAirdropImplementationNotSet()
DALP-3024Vesting already initialized.Vesting for this allocation index has already been initialized. Each Merkle-tree index can only start vesting once, and the contract found a non-zero initialization timestamp for the requested index.Check the initialization status for this index before calling initializeVesting. Each index supports a single vesting initialization; use claimableAmount to check and claim to collect vested tokens.errorNoVestingAlreadyInitialized()
DALP-3025Vesting initialization required.Claiming vested tokens requires that you started vesting first for this allocation index. The contract found no initialization record (timestamp of zero) for the requested index.Call initializeVesting with a valid Merkle proof for this index to start the vesting schedule, then retry the claim after the vesting period has elapsed.errorNoVestingNotInitialized()
DALP-3026Claim fallback disabled.The price resolver's claim fallback feature is turned off. Without an active feed for the requested token, the resolver cannot return a price.Either register a price feed for this token in the FeedsDirectory, or ask the feeds manager to enable claim fallback on the price resolver before retrying.errorNoClaimFallbackDisabled()
DALP-3027No claim fallback.The price resolver attempted to fall back to a trusted identity claim for token {{token}}, but the token has no valid trusted claim available. The fallback path found nothing to return.Ensure a trusted claim issuer has issued a valid base-price claim for token {{token}}, or register a price feed for this token in the FeedsDirectory so the fallback path is unnecessary.errorNoNoClaimFallback(address)
DALP-3028Nothing to claim.The caller attempted to claim refunded or settled funds from an XvP settlement, but the contract found no locked or parked balance for their address. Either the balance was already claimed or none was ever locked.Verify that your address has an outstanding balance in this settlement before calling claimRefund or claimSettled. Each balance supports a single claim.errorNoNothingToClaim()
DALP-3029The claim amount cannot be zero.The airdrop contract requires a non-zero token quantity for every claim. You submitted a claim amount of zero, so the contract reverted before any tokens were transferred.Enter a valid amount greater than zero to claim your airdrop tokens.errorYesZeroClaimAmount()
DALP-3030Airdrop reward already claimed.The claim tracker records each Merkle tree index as claimed the first time it is processed. The claim tracker already recorded this index as claimed, so the contract rejected the duplicate request.Check your account, the tokens from this claim should already be in your balance.warningNoIndexAlreadyClaimed()
DALP-3031Claim amount exceeds the allocated total for this index.The claim tracker validated the request and found that the amount being claimed is greater than the total allocation recorded for this index. This occurs when the claimed amount does not match what was committed in the Merkle tree.Use the exact allocated amount for the index as recorded in the airdrop Merkle tree.errorYesInvalidClaimAmount()
DALP-3032Merkle proof does not match the airdrop root.The contract verified the supplied Merkle proof against the stored root and the proof failed. The proof was generated for a different account, amount, or Merkle tree than the one stored on-chain.Regenerate the Merkle proof from the same allocation tree used to set the on-chain root, for the exact account and amount being claimed.errorNoInvalidMerkleProof()

System & infrastructure

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-4001Authority address has no deployed contract code.The setAuthority function checks that the new authority address contains deployed contract bytecode. The address supplied has no contract code, so the contract rejected the update.Supply an address where an authority contract is already deployed. Passing a wallet address or an address with no contract at it will always revert.errorNoAccessManagedInvalidAuthority(address)
DALP-4002Access managed required delay.The OpenZeppelin AccessManager enforces a mandatory delay before certain restricted calls can execute. The caller ({{caller}}) triggered a function that requires waiting {{delay}} seconds after scheduling before it may proceed.Schedule the operation first, wait for the required delay of {{delay}} seconds, then execute it. Use the AccessManager's schedule function and check the operation's execution window before calling.errorNoAccessManagedRequiredDelay(address,uint32)
DALP-4003Access manager already deployed.The factory uses CREATE2 to deploy access managers at deterministic addresses derived from the token's name and symbol alongside the caller address. The predicted address for this combination is already registered as a factory-deployed access manager, so the contract cannot deploy a second one to the same address.The address is derived from the caller address and the token's name and symbol (plus decimal precision), so each unique combination maps to one access manager. Change the token name or symbol to deploy a new access manager, or retrieve the existing address via predictAccessManagerAddress.errorNoAccessManagerAlreadyDeployed(address)
DALP-4004Access manager already scheduled.The OpenZeppelin AccessManager's schedule function rejected this call because an operation with the same id is already scheduled and its scheduled timepoint has not yet expired. The operation id is derived from the caller and target pair together with the calldata. The contract blocks duplicate scheduling of the same pending operation.Wait for the existing scheduled operation to either execute or expire before scheduling it again. You can check the current schedule timepoint by calling getSchedule with the operation id, or cancel the existing schedule first.errorNoAccessManagerAlreadyScheduled(bytes32)
DALP-4005Access manager bad confirmation.The OpenZeppelin AccessManager's renounceRole function requires the caller to pass their own address as the callerConfirmation argument. The address supplied does not match the address of the account that sent the transaction.Call renounceRole again and pass your own wallet address as the callerConfirmation argument. The value must exactly match the address that signs and sends the transaction.errorNoAccessManagerBadConfirmation()
DALP-4006Scheduled operation deadline expired.You submitted the scheduled operation ({{operationId}}) to the AccessManager after its execution window had already closed. Scheduled operations must execute within the allowed time window.Re-schedule the operation to obtain a fresh execution window, then execute it before the window expires.errorNoAccessManagerExpired(bytes32)
DALP-4007AccessManager deployed with a zero initial admin address.The AccessManager constructor requires a non-zero address for the initial admin. The address supplied was the zero address (0x000...000), so the contract cannot grant the ADMIN_ROLE to any account.Provide a valid, non-zero wallet or contract address as the initial admin when deploying the AccessManager. The address must be a real account that will hold the ADMIN_ROLE.errorNoAccessManagerInvalidInitialAdmin(address)
DALP-4008Access manager locked role.Role {{roleId}} is a locked administrative role in the AccessManager. The AccessManager protects this role from configuration changes.Choose a different role ID that the AccessManager allows to be modified, or contact the system administrator if you believe this restriction needs to change at the governance level.errorNoAccessManagerLockedRole(uint64)
DALP-4009Access manager not configured.The token sale contract requires an AccessManager on the subject token before role checks can run. The token's access manager address is zero, meaning no one has set an access manager for it.Ensure the subject token has an access manager deployed and configured before creating or interacting with a token sale for that token.errorNoAccessManagerNotConfigured()
DALP-4010Access manager not ready.The scheduled operation ({{operationId}}) exists in the AccessManager, but its delay period has not yet elapsed. The AccessManager blocks execution until the scheduled time arrives.Wait until the scheduled execution window opens for operation {{operationId}}, then retry. Check the AccessManager for the exact scheduled timestamp.errorNoAccessManagerNotReady(bytes32)
DALP-4011Access manager not scheduled.The operation ({{operationId}}) has not been scheduled in the AccessManager. Executing or cancelling a delayed operation requires scheduling it first.Call schedule on the AccessManager for this operation before attempting to execute or cancel it.errorNoAccessManagerNotScheduled(bytes32)
DALP-4012Access manager unauthorized account.The account ({{msgsender}}) does not hold role {{roleId}} in the AccessManager and is therefore not permitted to call the restricted function.Request that an AccessManager admin grant role {{roleId}} to your address, or use an address that already holds the required role.errorNoAccessManagerUnauthorizedAccount(address,uint64)
DALP-4013Access manager unauthorized call.The caller ({{caller}}) attempted to call a function on target contract ({{target}}) with selector {{selector}}, but the AccessManager has no permission granting access to that call.Ensure the AccessManager has a permission configured that allows your address (or role) to call the target function. Contact the system administrator to grant the necessary permission.errorNoAccessManagerUnauthorizedCall(address,address,bytes4)
DALP-4014Access manager unauthorized cancel.The OpenZeppelin AccessManager contract received a cancel request from an account that is not permitted to cancel this scheduled operation. Only the original caller or an account with the appropriate admin role may cancel a pending operation.Retry the cancel from the account that originally scheduled the operation, or from an account holding the admin role that governs the target function.errorNoAccessManagerUnauthorizedCancel(address,address,address,bytes4)
DALP-4015Access manager unauthorized consume.The OpenZeppelin AccessManager blocked an attempt to consume a scheduled operation because the consuming target does not match the target the operation recorded at scheduling time.Ensure the contract consuming the scheduled operation is the same target address that the operation recorded when scheduled.errorNoAccessManagerUnauthorizedConsume(address)
DALP-4016Account implementation not set.The directory does not have an account implementation address registered. The account proxy resolves its logic contract from the directory at call time, and found a zero address for the ACCOUNT key.Register a valid account implementation address in the directory before deploying or calling through an account proxy.errorNoAccountImplementationNotSet()
DALP-4017Account unauthorized.The call reached the account contract from an address that is neither the configured EntryPoint nor the resolved canonical EntryPoint. The account only accepts UserOperation calls from its bound EntryPoint.Submit this operation through the EntryPoint that is bound to this account. Direct calls to restricted account functions are not permitted.errorNoAccountUnauthorized(address)
DALP-4018Accrual already closed.Yield accrual for this holder address is already in a closed state. The fixed treasury yield feature records a closed flag per holder and blocks a second close on the same holder.Check the holder's accrual status before calling closeAccrual. Nothing further is required if accrual is already closed.errorNoAccrualAlreadyClosed(address)
DALP-4019Addon registry implementation not set.The system cannot create or operate an addon registry because no logic contract address has been set for it. The system checked the addon registry implementation slot and found a zero address.Configure a non-zero addon registry implementation address in the system before attempting to bootstrap or use the addon registry.errorNoAddonRegistryImplementationNotSet()
DALP-4020Address already deployed.You requested a CREATE2 deployment for an address that the factory already recorded as a deployed system addon. Each system addon address can only be deployed once.Verify that the salt and constructor arguments you are supplying have not already produced a deployed system addon. Use a different salt to deploy a distinct instance.errorNoAddressAlreadyDeployed(address)
DALP-4021Address already on bypass list.The address you are adding to the compliance bypass list is already present on that list. The contract enforces uniqueness and rejects duplicate entries.Check whether the address is already on the bypass list before calling addToBypassList. Nothing further is required if the address is already present.errorNoAddressAlreadyOnBypassList(address)
DALP-4022The requested resource could not be found.The trusted issuer address you are trying to remove was not found in the registry list. The contract scans the list and reverts when no matching entry exists.Confirm that the trusted issuer registry currently holds this address before you attempt to remove it.errorNoAddressNotFoundInList(address)
DALP-4023Address not on bypass list.The address you are trying to remove from the compliance bypass list is not on that list. The contract requires the address to be present; you cannot remove an address that does not appear on the list.Verify the address is on the bypass list before calling removeFromBypassList.errorNoAddressNotOnBypassList(address)
DALP-4024Already archived.The registry has already placed the addon or factory registration under this key into the archived state. The registry blocks a second archive call on an entry it already considers archived.Confirm the current state of the registration before calling archive. No further step is required if the entry already carries the archived state.errorNoAlreadyArchived(bytes32)
DALP-4025Already distributed.The push airdrop contract already recorded a non-zero claimed amount for this index, which means the contract already distributed tokens for it. The contract blocks a second distribution for the same index.Each airdrop index supports one distribution. Verify the contract has not already processed this index before you submit the distribution request.errorNoAlreadyDistributed()
DALP-4026Already initialized.The contract or feature already completed initialization. This guard prevents a second initialization call from overwriting the configured state.The contract supports one initialization per deployment. Check whether the contract already ran initialization before calling the initialize function.errorNoAlreadyInitialized()
DALP-4027Already matured.The contract already moved this token into the matured state. Operations that require a pre-maturity state, such as setting the maturity date or triggering maturity a second time, are blocked once the contract sets the matured flag.Check the token's maturity status before submitting this request. You cannot change maturity-related configuration after the token reaches the matured state.errorNoAlreadyMatured()
DALP-4028Key already registered.The directory already has an entry registered under this key. Token types, compliance modules, and addon types each enforce unique registration keys.Use a unique registration key. Retrieve the existing entry if you need to reference the already-registered resource.errorNoAlreadyRegistered(bytes32)
DALP-4029Ambiguous interest provider.During conversion, the contract resolved {{providerCount}} interest providers and could not determine which one to use. Configure the conversion feature with an explicit interest provider so that resolution selects exactly one.Configure the conversion feature with an explicit interest provider so that resolution is unambiguous before triggering conversion.errorNoAmbiguousInterestProvider(uint256)
DALP-4030Amount exceeds int256 max.One of the settlement flow amounts exceeds the maximum value representable as a signed 256-bit integer. The XvP settlement uses signed integers to compute net positions, so all flow amounts must fit within that range.Reduce the flow amount so that it does not exceed 2^255 - 1 before submitting the settlement.errorNoAmountExceedsInt256Max()
DALP-4031And or operation requires two operands.The identity verification compliance expression contains an AND or OR node that does not have at least two operands on the evaluation stack at that point. The expression has a structural problem at that node.Correct the expression so that every AND or OR node follows at least two TOPIC or sub-expression nodes. Validate the expression structure before submitting it.errorNoAndOrOperationRequiresTwoOperands()
DALP-4032And or operations require two operands.The identity verification expression passed to IdentityVerificationLib contains an AND or OR operation node that does not have at least two operands on the evaluation stack at that position.Ensure that at least two TOPIC or sub-expression result nodes appear before each AND or OR node in the expression. Review the expression structure and resubmit.errorNoAndOrOperationsRequireTwoOperands()
DALP-4033Approval already exists.An active, unexpired approval for this exact token, sender identity, recipient identity, and amount already exists; a different approver created it. The contract prevents duplicate approvals from separate approvers for the same transfer parameters.Check for an existing active approval for these transfer parameters. Either use the existing approval or wait for it to expire before creating a new one from a different approver.errorNoApprovalAlreadyExists()
DALP-4034Approval already used.A previous transfer already consumed the transfer approval record for this sender-to-recipient pair. Each approval is single-use: once a transfer succeeds, the contract records the approval as used and blocks any further transfer against it.Request a new transfer approval for this sender-to-recipient pair and token amount, then resubmit the transfer.errorNoApprovalAlreadyUsed()
DALP-4035Transfer approval expired.The transfer approval record for this sender-to-recipient pair has passed its expiry timestamp. The contract enforces that you consume approvals before their deadline.Request a fresh transfer approval with a suitable expiry, then resubmit the transfer before that expiry passes.errorNoApprovalExpired()
DALP-4036Approval required.No transfer approval record exists for this sender-to-recipient pair and token amount. The token's transfer compliance module requires an explicit approval to be on-chain before the transfer can proceed.Create a transfer approval for the sender identity, recipient identity, and exact token amount, then resubmit the transfer.errorNoApprovalRequired()
DALP-4037Archive not registered.The registration key you supplied does not correspond to any registered system addon. The contract requires the addon to exist in the registry before you can archive it.Verify the registration key against the addon registry and resubmit with a key that matches an existing registered addon.errorNoArchiveNotRegistered(bytes32)
DALP-4038Array length mismatch.Two input arrays passed to this call have different lengths. The contract requires all array parameters to be the same length so each element maps to a corresponding element in the other arrays.Ensure all array arguments have equal length and resubmit the call.errorNoArrayLengthMismatch()
DALP-4039Array length mismatch.The names array and the signatures array passed to the topic scheme registry have different lengths. The contract requires these two arrays to be the same length so each topic name maps to exactly one signature.Provide equal-length names and signatures arrays, then resubmit. The arrays must have {{namesLength}} and {{signaturesLength}} elements respectively.errorNoArrayLengthMismatch(uint256,uint256)
DALP-4040Associated contract not set.The on-chain identity contract has no associated contract address configured. The issueClaimTo path requires a non-zero associated contract address before you can issue claims on behalf of a contract.Configure the associated contract address on this identity contract before calling claim issuance operations.errorNoAssociatedContractNotSet()
DALP-4041Authorization contract already registered.The claim authorization contract at the supplied address is already present in the registry. The registry accepts each authorization contract only once.Remove the existing registration for this contract before re-registering it, or supply a different authorization contract address.errorNoAuthorizationContractAlreadyRegistered(address)
DALP-4042Authorization contract not registered.The claim authorization contract at the supplied address is not present in the registry. The contract requires a registration to exist before you can remove it.Register the authorization contract before attempting to remove it, or verify the correct contract address.errorNoAuthorizationContractNotRegistered(address)
DALP-4043Batch size exceeds limit.The number of entries in the batch exceeds the airdrop contract's maximum of 100. The contract enforces this ceiling to stay within safe gas bounds.Split the batch into segments of 100 entries or fewer and submit each segment separately.errorNoBatchSizeExceedsLimit()
DALP-4044Below min conversion amount.The conversion amount you submitted is below the token's minimum conversion threshold. The contract checks that the amount you want to convert meets or exceeds the configured minimum before proceeding.Increase the conversion amount to at least the minimum required. The current minimum is {{minimum}} and your amount was {{amount}}.errorNoBelowMinConversionAmount(uint256,uint256)
DALP-4045Buyer not eligible.The buyer's wallet does not pass the token's compliance check. The token sale delegates eligibility to the token's on-chain compliance module, which returned false for this buyer and amount.Verify that the buyer's identity has the required compliance claims and that the purchase amount is within the allowed limits for this buyer, then retry.errorNoBuyerNotEligible()
DALP-4046Caller not factory.Only the factory contract that deployed this XvP settlement contract may call this function. The caller's address does not match the stored factory address.Route this call through the factory contract that created this settlement, or verify you are calling the correct settlement address.errorNoCallerNotFactory()
DALP-4047Cancel not allowed.The settlement cannot be cancelled in its current state. Cancellation is blocked either because the contract has already recorded a revealed HTLC secret, or because the settlement holds external flows with full approval but has not yet collected unanimous cancel votes.If the secret remains unrevealed and the settlement has external flows, use proposeCancel to submit a cancel vote. Each local participant must vote before the contract cancels the settlement.errorNoCancelNotAllowed()
DALP-4048Cancel vote already cast.This participant has already submitted a cancel vote for this settlement. The contract records one cancel vote per participant and rejects duplicate votes.Withdraw the existing cancel vote with withdrawCancelProposal before casting a new one, or proceed without re-voting.errorNoCancelVoteAlreadyCast(address)
DALP-4049Cancel vote not cast.The contract holds no cancel vote from this participant for this settlement. Withdrawing a cancel vote requires that you previously submitted one via proposeCancel.Submit a cancel vote with proposeCancel before attempting to withdraw it.errorNoCancelVoteNotCast(address)
DALP-4050Cannot execute to zero address.The ERC-734 key manager does not permit on-chain executions targeting the zero address. The target address provided in the execution call is the zero address.Provide a valid non-zero target address for the execution call.errorNoCannotExecuteToZeroAddress()
DALP-4051Cannot initialize logic contract.You called the initialize function directly on a logic (implementation) contract that the constructor already configured. Only proxy instances may be initialized; the logic contract itself must remain uninitialized.Call initialize only on the proxy contract, not on the implementation contract directly.errorNoCannotInitializeLogicContract()
DALP-4052Cannot recover self.The token recovery request named the same wallet as both the source and the destination. The contract requires the new wallet to differ from the wallet you are recovering.Provide a different destination wallet address for the recovery. The new wallet and the lost wallet must not be the same address.errorNoCannotRecoverSelf()
DALP-4053Cannot remove default validator.The module at the supplied address is the account factory's currently configured default validator. The contract does not permit you to remove the default validator while it holds that designation.Assign a different default validator before removing this module, or remove a different module that is not the default validator.errorNoCannotRemoveDefaultValidator(address)
DALP-4054Contract already linked.The contract's identity registry already holds an on-chain identity for the address you supplied. Each contract address can be linked to exactly one identity, and the contract rejects a second registration attempt to prevent duplicate links.Retrieve the existing identity for the contract address before submitting. If you genuinely need a new identity, an authorized account must first remove the old link.errorNoContractAlreadyLinked(address)
DALP-4055Conversion id already used.The conversion identifier computed for this request was already recorded as used. The contract enforces replay protection by rejecting any conversion that produces a previously seen identifier.Do not resubmit an identical conversion request. Each conversion produces a unique identifier based on token, target, holder, trigger, and an incrementing nonce. Submitting a new conversion with fresh parameters will generate a distinct identifier.errorNoConversionIdAlreadyUsed(bytes32)
DALP-4056Conversion minter missing.The conversion feature could not locate a conversion minter on the target token. A system manager must register a valid minter contract on the target token before the contract can finalize conversions.Ensure the target token has a conversion minter installed and configured. Check the token's feature set and register the minter if it is absent.errorNoConversionMinterMissing()
DALP-4057Conversion window closed.The token's configured conversion window has ended. The current block timestamp is past the window's end time, so the contract no longer accepts conversion requests.Check the token's conversion window end time. The contract processes conversions only within the configured window. Contact the token issuer if you believe the window should be extended.errorNoConversionWindowClosed()
DALP-4058Conversion window not open.The token's conversion window has not started yet. The current block timestamp is before the window's start time, so the contract rejects conversion requests until the window opens.Check the token's conversion window start time and resubmit after the window opens. You can read the configured start timestamp from the token's conversion configuration.errorNoConversionWindowNotOpen()
DALP-4059Create2 empty bytecode.The deployment bytecode supplied to the CREATE2 factory was empty. The factory requires non-empty bytecode to deploy a contract at a deterministic address.Verify that the bytecode you pass to the deployment call is complete and non-empty. The contract always rejects an empty bytes value at the deployment step.errorNoCreate2EmptyBytecode()
DALP-4060Feed update deadline expired.The signed feed update carries a non-zero deadline that has already passed. The contract rejects updates whose deadline falls before the current block timestamp to prevent replay of stale price data.Request a fresh signed update with a deadline set in the future and resubmit. The issuer must re-sign the update with an updated deadline and nonce.errorNoDeadlineExpired()
DALP-4061Decimal mismatch.The replacement feed reports a different decimal precision than the feed it is replacing. The directory enforces that scalar feed upgrades preserve the same decimal count to prevent precision mismatches in downstream consumers.Supply a replacement feed whose decimals() return value matches the existing feed's decimals. Verify both feeds report the same value before submitting the replacement.errorNoDecimalMismatch(uint8,uint8)
DALP-4062Default validator not set.The account factory has no default validator configured. The simple account creation path requires a system manager to register a default validator before you can create wallets without an explicit validator parameter.Ensure the account factory's default validator is set before creating accounts via the default path. Alternatively, supply an explicit validator address in the account creation parameters.errorNoDefaultValidatorNotSet()
DALP-4063Delegate and revert.The ERC-4337 EntryPoint's delegateAndRevert function always reverts with this error after performing a delegatecall. The function is a diagnostic tool that returns the delegatecall result inside the revert data rather than propagating a real failure.Decode the success and ret fields from the revert data to inspect the outcome of the delegatecall. The delegateAndRevert diagnostic endpoint intentionally produces this error and it does not represent an on-chain state problem.errorNoDelegateAndRevert(bool,bytes)
DALP-4064Denomination mismatch.The denomination asset recorded in the conversion configuration does not match the denomination asset provided by the trigger or interest rate provider. The conversion feature requires all parties to reference the same denomination currency.Ensure the trigger or provider you are using carries the same denomination asset as the token's conversion configuration. Check the expected denomination address from the error arguments and compare it with your trigger's denomination.errorNoDenominationMismatch(address,address)
DALP-4065Deployment address mismatch.The identity contract deployed by the factory landed at a different address than the one computed by CREATE2 before deployment. This indicates a mismatch in the salt, constructor arguments, or bytecode used for the address prediction.Verify that the salt and constructor arguments you supplied for the address prediction exactly match those you passed to the deployment call. The contract encountered an internal consistency error; contact support if the problem persists after confirming your inputs are unchanged.errorNoDeploymentAddressMismatch()
DALP-4066Deposit withdrawal failed.The ERC-4337 stake manager attempted to transfer the deposited ETH to the specified withdrawal address, but the ETH transfer call failed. The error arguments carry the revert reason the failed call returned.Check that the withdrawal address is able to receive ETH (not a contract that rejects ETH or has an insufficient gas stipend). Inspect the revertReason field in the error for more detail, then retry with a valid withdrawal address.errorNoDepositWithdrawalFailed(address,address,uint256,bytes)
DALP-4067Directory already set.The system contract's directory reference already points to a non-zero address. The contract accepts only one directory assignment and rejects any attempt to overwrite it.The directory is a one-time configuration. If the current directory address is wrong, the system must undergo redeployment or migration rather than an overwrite via setDirectory.errorNoDirectoryAlreadySet()
DALP-4068Directory not set.The system contract requires a non-zero directory address, but no one has set one yet. Directory-dependent operations will revert until a valid directory address is in place.Set the directory address on the system contract before calling directory-dependent operations. Use setDirectory or initializeWithDirectory with a valid address.errorNoDirectoryNotSet()
DALP-4069Duplicate feature.The list of features passed to the token configuration contains the same feature contract address more than once. Each feature address must appear at most once in an ordered feature set.Remove duplicate entries from the features list before resubmitting. Each feature address must be unique within the ordered list supplied to the token configuration call.errorNoDuplicateFeature(address)
DALP-4070Duplicate module.The same compliance module address appears more than once in the initial compliance module set supplied to the token. The contract rejects duplicate modules to prevent redundant or conflicting compliance checks.Remove the duplicate module address from the compliance module list before resubmitting. Each module address must appear only once in the initial module set.errorNoDuplicateModule(address)
DALP-4071Duplicate signature.You supplied a signature from the same address more than once in a multi-signature verification context. The contract rejects duplicate signers to prevent a single key from counting multiple times toward a threshold.Ensure that each signer address contributes exactly one signature to the set. Remove the duplicate signature before resubmitting.errorNoDuplicateSignature(address)
DALP-4072Duplicate type id.Two features in the list you submitted share the same type identifier. Each feature type may be installed at most once per token; the contract rejects a second feature that reports the same typeId.Remove one of the conflicting features from the list so that each typeId appears only once. Check each feature's typeId before assembling the feature list.errorNoDuplicateTypeId(bytes32)
DALP-4073ETH not accepted.The proxy contract does not accept direct ETH transfers. Its receive function exists solely to block accidental ETH sends, which the contract would trap with no way to recover.Do not send ETH directly to this contract address. If you intend to interact with a payable function, call that function explicitly rather than sending a plain ETH transfer.errorNoETHNotAccepted()
DALP-4074ETH transfers not allowed.The contract proxy does not accept ETH deposits. Its receive() function reverts unconditionally because the proxy has no withdrawal mechanism, and any ETH sent would be permanently locked inside it.Do not send ETH directly to this contract address. If your request includes a value field, set it to zero before resubmitting.errorNoETHTransfersNotAllowed()
DALP-4075Eip7702 sender not delegate.The sender address has deployed code, but its bytecode does not start with the EIP-7702 delegation prefix (0xef0100). The EntryPoint requires the sender to be a valid EIP-7702 delegated account when an EIP-7702 initCode marker is present in the UserOperation.Authorize the sender account as an EIP-7702 delegate before submitting this UserOperation. Verify the EIP-7702 authorization transaction landed on-chain for the sender address.errorNoEip7702SenderNotDelegate(address)
DALP-4076Eip7702 sender without code.The sender address has no deployed bytecode. When the UserOperation includes an EIP-7702 initCode marker, the EntryPoint requires code at the sender address before reading its delegation target.Submit the EIP-7702 authorization to establish the sender's delegation on-chain before sending this UserOperation. The sender must have bytecode present at the time the EntryPoint processes the operation.errorNoEip7702SenderWithoutCode(address)
DALP-4077Empty arrays provided.You submitted a batch topic-scheme registration with no entries. The contract requires at least one name-and-signature pair in the input arrays.Include at least one topic scheme in the names and signatures arrays before calling batchRegisterTopicSchemes.errorNoEmptyArraysProvided()
DALP-4078Empty expression not allowed.The module configuration received an empty expression array. This module requires at least one claim-topic node to define its verification logic.Supply a non-empty array of ExpressionNode entries when configuring this compliance module's scope.errorNoEmptyExpressionNotAllowed()
DALP-4079Empty id.A registration call supplied a zero bytes32 identifier. The directory contract requires every token type, compliance module, or addon to carry a non-zero identifier.Provide a non-zero bytes32 identifier for the item you are registering.errorNoEmptyId()
DALP-4080Empty name.You submitted a topic scheme registration or update with an empty name string. The registry requires every topic scheme to have a non-empty name, because the name computes the topic identifier.Provide a non-empty string for the name parameter when registering or updating a topic scheme.errorNoEmptyName()
DALP-4081Empty signature.You submitted a topic scheme registration or update with an empty signature string. The registry requires every topic scheme to carry a non-empty ABI signature that describes the claim data type.Provide a non-empty ABI type signature string for the signature parameter when registering or updating a topic scheme.errorNoEmptySignature()
DALP-4082Exceeded cap.Minting the requested amount would push the token's total supply above its configured cap. The error returns the would-be supply (newSupply) and the maximum allowed supply (cap) so you can calculate a conforming mint amount.Reduce the mint amount so that the resulting total supply stays at or below the cap value returned in the error.errorNoExceededCap(uint256,uint256)
DALP-4083Execution already performed.The contract already carried out the execution request identified by executionId. An ERC-734 execution can only run once; the contract marks it as executed on success and rejects any further approval attempts.Check the execution state before calling approve. If you need to perform the same call again, create a new execution request with execute() to receive a fresh executionId.errorNoExecutionAlreadyPerformed(uint256)
DALP-4084Execution failed.A low-level call that the contract expected to succeed returned a failure indicator. The calling contract reverts to surface this failure rather than silently continuing.Check the target contract address and calldata for correctness. Simulate the call to inspect any revert data before retrying.errorNoExecutionFailed()
DALP-4085The requested resource could not be found.The executionId you supplied to approve() is greater than or equal to the current execution nonce, so no execution request with that identifier exists on this identity contract.Retrieve the correct executionId from the ExecutionRequested event that execute() emitted when the execution was first created, then retry with that value.errorNoExecutionIdDoesNotExist(uint256)
DALP-4086Expression stack overflow.The compliance expression evaluator's internal boolean stack overflowed during postfix evaluation. This occurs when the expression pushes more intermediate results than the stack can hold at once, typically from deeply nested or unbalanced operator sequences.Simplify the compliance expression by reducing the nesting depth of AND, OR, and NOT operators. Ensure the postfix expression is well-formed and balanced so that at no point during evaluation does the stack depth exceed the number of expression nodes.errorNoExpressionStackOverflow()
DALP-4087Expression too complex.The compliance expression contains more than 32 nodes (MAX_EXPRESSION_NODES). The contract enforces this limit to bound gas consumption during expression evaluation.Reduce the expression to 32 nodes or fewer. Consider combining related claim topics at the off-chain level before encoding the expression.errorNoExpressionTooComplex()
DALP-4088Failed deployment.A contract deployment via CREATE2 or a proxied factory call returned address(0), indicating the deployment did not succeed. OpenZeppelin deployment utilities raise this error when the deployed bytecode is empty.Verify the deployment bytecode is non-empty and that no constructor is reverting. Check that the CREATE2 salt and factory address are correct, then retry.errorNoFailedDeployment()
DALP-4089Failed op.The ERC-4337 EntryPoint rejected the UserOperation at index opIndex during handleOps. The reason string identifies the failing component: AA1x means factory, AA2x means account, AA3x means paymaster.Read the reason string to identify which component failed (factory, account, or paymaster) and the specific error code. Run simulateValidation to diagnose the rejection before resubmitting.errorNoFailedOp(uint256,string)
DALP-4090Failed op with revert.The ERC-4337 EntryPoint rejected the UserOperation at index opIndex, and the sub-call provided additional revert data in inner. The reason string identifies the failing component (factory, account, or paymaster) as in FailedOp.Decode the inner bytes to read the nested revert reason from the sub-call. Use simulateValidation to reproduce the failure and identify the root cause before resubmitting.errorNoFailedOpWithRevert(uint256,string,bytes)
DALP-4091Failed send to beneficiary.After processing UserOperations, the EntryPoint attempted to transfer collected fees to the beneficiary address but the ETH transfer failed. The revertData field contains the inner revert from the beneficiary contract.Ensure the beneficiary address can accept ETH (it must not revert on receive). Inspect the revertData to diagnose why the beneficiary rejected the transfer.errorNoFailedSendToBeneficiary(address,uint256,bytes)
DALP-4092Feature already exists.A feature of this type is already deployed for the given token address. The token feature factory stores one feature per (token, feature-type) pair and rejects a second creation for the same token.Query the factory to retrieve the existing feature address for this token before creating a new one. Use replaceFeature instead of createFeature if you need to swap the existing feature.errorNoFeatureAlreadyExists()
DALP-4093Feature creation failed.The contract attempted to deploy a new token feature contract using CREATE2, but the deployment returned the zero address. The bytecode did not deploy to the computed address, likely because the same salt was already in use or the bytecode is empty.Confirm the feature has not already been deployed for this token and salt combination. If the feature does not yet exist, verify the feature factory implementation is correctly configured before retrying.errorNoFeatureCreationFailed()
DALP-4094The requested resource could not be found.The asset factory could not locate a registered feature factory for the requested feature type. The factory hashes the feature type identifier and looks it up in the addon registry, but the registry returned no entry for that address.Register a feature factory for this feature type in the addon registry before creating an asset that uses it. Use the feature type name exactly as registered (e.g. "historical-balances").errorNoFeatureFactoryNotFound(bytes32)
DALP-4095Future lookup.The requested timepoint is ahead of the contract's current clock value. Historical balance and supply queries only accept timepoints at or before the current block, so the contract blocks the call to prevent reads of data that does not yet exist.Pass a timepoint at or before the current block when querying historical balances or total supply. The error returns both the requested timepoint and the current timepoint so you can correct the value.errorNoFutureLookup(uint256,uint48)
DALP-4096Global module already added.The compliance module at the provided address is already registered as a global module. The registry tracks modules by address and rejects duplicate additions to prevent the same rules from applying twice.Check the current list of global compliance modules before calling addGlobalComplianceModule. If the module is already present, no further registration is needed.errorNoGlobalModuleAlreadyAdded(address)
DALP-4097The requested resource could not be found.The compliance module at the provided address is not currently registered as a global module. The operation (remove or update parameters) requires the module to exist in the global registry.Verify the module address is correct and confirm it has been added as a global compliance module before attempting to remove or update it.errorNoGlobalModuleNotFound(address)
DALP-4098Governor already cast vote.The voter address has already submitted a vote for this proposal. The Governor contract records each vote by address per proposal and rejects a second vote from the same address.Each address may vote only once per proposal. Check whether the address has already voted before submitting a castVote call.errorNoGovernorAlreadyCastVote(address)
DALP-4099Governor already queued proposal.The Governor has already queued this proposal in the timelock. A proposal can only be queued once, and the Governor rejects a second queue request for the same proposalId.Check the proposal state before calling queue. If the proposal is already in the Queued state, wait for the timelock delay to expire and then execute it directly.errorNoGovernorAlreadyQueuedProposal(uint256)
DALP-4100Governor disabled deposit.The Governor contract has the token deposit mechanism disabled. The contract blocks deposit calls when this feature is turned off at the contract level.This Governor does not accept token deposits. Review the governance contract configuration to understand which participation method is supported.errorNoGovernorDisabledDeposit()
DALP-4101Governor insufficient proposer votes.The proposer's current voting weight is below the proposal threshold required by the Governor. The contract compares the proposer's votes at the current block against the configured threshold and blocks proposals that do not meet it.The error returns the proposer address, current votes, and the required threshold. Increase the proposer's delegated voting weight to at least the threshold value before submitting a proposal.errorNoGovernorInsufficientProposerVotes(address,uint256,uint256)
DALP-4102Proposal arrays have mismatched or zero length.The propose call requires the targets, values, and calldatas arrays to be the same length and to contain at least one entry. The contract received arrays whose lengths differ or all three are empty.Ensure targets, values, and calldatas each contain the same number of entries and that the proposal includes at least one call before submitting.errorNoGovernorInvalidProposalLength(uint256,uint256,uint256)
DALP-4103Vote signature does not match the stated voter.The signature supplied to castVoteBySig or castVoteWithReasonAndParamsBySig did not recover to the voter address. The contract verifies the EIP-712 signature before recording the vote.Re-sign the vote data with the private key that controls the voter address, making sure to sign the correct proposalId, support, and (if applicable) reason and params values.errorNoGovernorInvalidSignature(address)
DALP-4104Vote params have the wrong length for the chosen vote type.When casting a full vote (support 0, 1, or 2), the params field must be empty. When casting a fractional vote (support 255), params must be exactly 48 bytes encoding three packed uint128 values (againstVotes, forVotes, abstainVotes).Pass an empty params for a full vote, or pass exactly 48 bytes encoded as abi.encodePacked(uint128, uint128, uint128) for a fractional vote.errorNoGovernorInvalidVoteParams()
DALP-4105Vote support value is outside the accepted range.The support field accepts only 0 (Against), 1 (For), or 2 (Abstain) for a full vote, and 255 for a fractional vote. Any other value causes the contract to reject the ballot.Set support to 0, 1, or 2 for a standard vote. Set support to 255 and provide the required 48-byte params for a fractional vote.errorNoGovernorInvalidVoteType()
DALP-4106Voting period must be at least one block.The Governor contract requires the voting period to be a positive value. A voting period of zero would open and immediately close every proposal, so the contract rejects it.Set the voting period to a value greater than zero when calling setVotingPeriod or during Governor initialization.errorNoGovernorInvalidVotingPeriod(uint256)
DALP-4107Governor nonexistent proposal.No proposal exists with the given proposalId. The Governor derives proposal IDs deterministically from the proposal parameters; an ID that was never created returns no record.Verify the proposalId by recomputing it from the original proposal parameters (targets, values, calldatas, description hash) or by reading it from the ProposalCreated event the contract emitted when you submitted the proposal.errorNoGovernorNonexistentProposal(uint256)
DALP-4108Governor not queued proposal.The proposal is not in the Queued state. Executing a proposal through a timelock-backed Governor requires you to queue the proposal first and wait for the timelock delay to elapse.Check the proposal state. If it is in the Succeeded state, call queue first. If it is already Queued, wait for the timelock delay to pass before calling execute.errorNoGovernorNotQueuedProposal(uint256)
DALP-4109Governor only executor.An address other than the Governor's designated executor (typically the timelock contract) sent this call. Governor operations like relay require the executor itself to send the message.Route this call through the governance execution path rather than sending it directly. Submit the operation as a governance proposal and let the timelock execute it.errorNoGovernorOnlyExecutor(address)
DALP-4110Governor queue unavailable on this contract.You called queue on a Governor that has no timelock or queue module. This Governor executes proposals directly without a queuing phase.Do not call queue on this Governor. After a proposal reaches the Succeeded state, call execute directly.errorNoGovernorQueueNotImplemented()
DALP-4111Governor restricted proposer.The Governor's proposer guard has restricted the proposer address. The contract maintains an allowlist or blocklist of addresses permitted to create proposals.Confirm that the proposer address is on the Governor's approved proposer list. Contact the governance administrator to request proposer access if needed.errorNoGovernorRestrictedProposer(address)
DALP-4112Governor unable to cancel.The caller does not hold the right to cancel this proposal. The contract permits cancellation only by the original proposer (when their votes have dropped below threshold) or by a designated guardian address.Only the original proposer or a guardian can cancel this proposal. If the proposer's voting weight has fallen below the proposal threshold, the proposer themselves may cancel it.errorNoGovernorUnableToCancel(uint256,address)
DALP-4113Governor unexpected proposal state.The proposal is in a lifecycle state that does not permit the requested operation. For example, executing requires the Queued state, canceling requires Active or Pending, and voting requires Active. The error carries the current state and a bitmask of acceptable states.Read the proposal state before performing governance operations. The error returns the current state and the expected states bitmask so you can determine what step to take next in the proposal lifecycle.errorNoGovernorUnexpectedProposalState(uint256,uint8,bytes32)
DALP-4114Hard cap exceeded.The requested token purchase would push the total amount sold past the sale's hard cap. The contract tracks cumulative tokens sold and rejects any purchase that would exceed the configured maximum supply for this sale.Reduce the purchase amount so that the total sold does not exceed the hard cap. You can query totalSold and hardCap on the token sale contract to determine the remaining capacity.errorNoHardCapExceeded()
DALP-4115Hard cap must be positive.You submitted a token sale creation request with a hard cap of zero. The factory requires a positive hard cap to define the maximum number of tokens available for sale.Provide a hardCap value greater than zero when calling createTokenSale.errorNoHardCapMustBePositive()
DALP-4116Hashlock reveal not required.You called revealSecret on an XvP settlement that has no external cross-chain flows. Hashlock secret revelation applies only to settlements that involve external flows; settlements with only local flows do not use a hashlock.Check the settlement's hasExternalFlows flag before calling revealSecret. For settlements with only local flows, proceed directly to execution without revealing a secret.errorNoHashlockRevealNotRequired()
DALP-4117History not supported.The price feed runs in LATEST_ONLY mode, which retains only the most recent observation. The Chainlink-compatible getRoundData function requires historical round storage, which this feed does not maintain.Use latestRoundData to retrieve the most recent value from this feed. If historical round access is required, redeploy the feed with BOUNDED or FULL history mode enabled.errorNoHistoryNotSupported()
DALP-4118Identities required.The transfer-approval compliance module checks that both the sender and the recipient have a registered on-chain identity. When either party's identity address resolves to zero, the contract cannot look up a valid approval record and blocks the transfer.Ensure both the sending and receiving wallet addresses have an on-chain identity registered in the identity registry before submitting this transfer.errorNoIdentitiesRequired()
DALP-4119Implementation not set in factory.The proxy contract queries the factory for its logic implementation address at deployment time. The factory holds no implementation address yet, so the returned address is zero and the proxy cannot initialize.Set a valid implementation address on the factory before deploying or upgrading this proxy.errorNoImplementationNotSetInFactory()
DALP-4120Index out of bounds.The index you supplied is greater than or equal to the total number of deployed systems recorded in the factory. The contract cannot return a system at a position that does not exist.Call getSystemCount() first to check the valid range, then supply an index between 0 and getSystemCount() minus 1.errorNoIndexOutOfBounds(uint256,uint256)
DALP-4121Initial key already setup.The ERC-734 identity contract already has a management key set during initialization. The contract rejects a second initialization call to prevent overwriting the existing key set.The identity contract is already fully initialized. No further key setup call is needed. To change keys, use the key-management functions on the live identity instead.errorNoInitialKeyAlreadySetup()
DALP-4122Initialization deadline passed.The vesting airdrop contract requires claimants to initialize their vesting schedule before a fixed deadline. The current block timestamp is past that deadline, so new vesting initializations are no longer accepted.Vesting initialization for this airdrop has closed. Contact the token issuer to confirm whether a new airdrop round will be opened.errorNoInitializationDeadlinePassed()
DALP-4123Initialization with zero address.You supplied a zero address as the implementation for this proxy to delegate to. A proxy cannot forward calls to the zero address, so initialization is rejected.Supply a valid, non-zero implementation contract address when deploying or initializing this proxy.errorNoInitializationWithZeroAddress()
DALP-4124Your account does not have enough resources for this operation.The requested yield claim amount exceeds the interest that has accrued for this holder across all active yield periods. The contract tracks accrued interest per period and rejects claims that exceed the available total.Reduce the claim amount to at most the available accrued interest, or wait for additional interest to accrue before claiming.errorNoInsufficientAccruedInterest(uint256,uint256)
DALP-4125Your account does not have enough resources for this operation.The ERC-4337 EntryPoint rejected a deposit withdrawal because the requested withdrawal amount exceeds the account's or paymaster's current deposit balance held in the EntryPoint.Reduce the withdrawal amount to at most the current deposited balance shown in the EntryPoint for this account or paymaster.errorNoInsufficientDeposit(uint256,uint256)
DALP-4126Your account does not have enough resources for this operation.The conversion requested a principal amount that exceeds the holder's current token balance. The contract validates the available balance before executing any conversion.Reduce the principal conversion amount to at most the holder's current token balance, or pass zero to convert the full available balance.errorNoInsufficientPrincipal(uint256,uint256)
DALP-4127Your account does not have enough resources for this operation.The DALPVault multisig transaction requires a minimum number of valid signer confirmations before execution. The number of signatures provided is below that required threshold.Collect the remaining required signatures from authorized vault signers and resubmit the transaction.errorNoInsufficientSignatures(uint256,uint256)
DALP-4128Your account does not have enough resources for this operation.The DALPVault multisig uses weighted signatures and requires the combined weight of all provided signers to meet or exceed a configured threshold. The total weight of the submitted signatures is below that threshold.Add signatures from higher-weight signers or collect more signer confirmations until the combined weight meets the required threshold.errorNoInsufficientWeight(uint256,uint256)
DALP-4129Interest provider missing.The conversion feature targets accrued interest, but no interest provider contract is attached to this token. Without a provider the contract cannot calculate the interest amount to convert.Attach a valid interest provider to the token before triggering an interest-based conversion.errorNoInterestProviderMissing()
DALP-4130Interface registration limit reached.Each SMART token extension can register a fixed maximum number of ERC-165 interface identifiers. The contract has filled all available slots in the interface registry, so it cannot accept another interface.This token type has reached its maximum number of registered interfaces. Remove an unused extension or contact the token issuer to request a contract upgrade that supports more interfaces.errorNoInterfaceRegistrationLimitReached()
DALP-4131Internal function.The ERC-4337 EntryPoint rejected a direct external call to a function that only the EntryPoint itself may call as part of its internal user-operation processing loop.This function is part of the EntryPoint's internal execution flow. Submit the operation through the standard ERC-4337 user-operation submission path instead of calling this function directly.errorNoInternalFunction()
DALP-4132Interoperable address empty reference and address.When formatting an ERC-7930 interoperable address, both the chain reference and the address components were empty. At least one of the two components must contain data for the encoding to be valid.Provide either a non-empty chain reference, a non-empty address component, or both when constructing the interoperable address.errorNoInteroperableAddressEmptyReferenceAndAddress()
DALP-4133Interoperable address parsing error.The byte sequence supplied does not conform to the ERC-7930 version-1 interoperable address encoding. The parser could not extract a valid version header, chain type, chain reference, or address from the input.Verify that a conforming ERC-7930 v1 encoder produced the interoperable address bytes and that no bytes were truncated or corrupted before submitting.errorNoInteroperableAddressParsingError(bytes)
DALP-4134Access manager must implement the required interface.The contract initialization checks that the access manager address supports the IDALPSystemAccessManager interface via ERC-165. The provided address failed that check.Pass the address of a deployed IDALPSystemAccessManager-compliant contract to the initializer.errorNoInvalidAccessManager()
DALP-4135Nonce does not match the account's current nonce.The contract uses OpenZeppelin's Nonces utility to prevent replay attacks. The nonce supplied with the signed message does not equal the account's stored current nonce.Fetch the account's current nonce from the contract before signing, and include that value in the message.errorNoInvalidAccountNonce(address,uint256)
DALP-4136Addon implementation address is zero.The system addon registry requires a non-zero implementation address when registering a new addon. The implementation_ argument passed to registerSystemAddon was the zero address.Deploy the addon implementation contract and pass its address to registerSystemAddon.errorNoInvalidAddonAddress()
DALP-4137New implementation address is zero.The XvP settlement factory's updateImplementation function requires a non-zero replacement implementation address. The zero address was supplied.Provide the address of a deployed XvP settlement implementation contract when calling updateImplementation.errorNoInvalidAddress()
DALP-4138Withdrawal amount is zero.The fixed yield schedule contract requires a non-zero denomination asset amount when withdrawing. A withdrawal of zero tokens is not a valid operation.Specify a non-zero amount of denomination asset tokens to withdraw.errorNoInvalidAmount()
DALP-4139Claim authorization contract address is zero or missing the required interface.The contract validates each authorization contract by calling supportsInterface for IClaimAuthorizer. The provided address is either the zero address or a contract that did not return true for that interface check.Supply the address of a deployed contract that correctly implements IClaimAuthorizer and passes ERC-165 interface detection.errorNoInvalidAuthorizationContract(address)
DALP-4140Yield basis-per-unit is zero.The fixed treasury yield schedule requires a non-zero basisPerUnit value. A value of zero produces no yield and is treated as a configuration error.Set basisPerUnit to a positive integer equal to the yield amount per token unit before submitting the schedule.errorNoInvalidBasisPerUnit()
DALP-4141Fee beneficiary address is zero.The EIP-4337 EntryPoint requires the beneficiary address passed to handleOps to be a non-zero address. A zero address cannot receive the gas-cost refund.Pass a valid, non-zero address as the beneficiary argument when calling handleOps.errorNoInvalidBeneficiary(address)
DALP-4142Token supply cap is zero or below the current total supply.The contract enforces a cap that must be greater than zero and, when updated, must be at least as large as the current total supply. A cap of zero would make minting impossible, and a cap below current supply would be inconsistent.Provide a cap value that is greater than zero and greater than or equal to the current token total supply.errorNoInvalidCap(uint256)
DALP-4143Subject address is zero.The trusted issuers meta-registry requires a non-zero subject address when assigning a subject-specific registry. The zero address is not a valid subject.Provide the actual on-chain address of the subject whose registry entry is being configured.errorNoInvalidContractAddress()
DALP-4144Conversion window end is at or before the start, or already past.The contract checks two conditions: the window end must be after the window start, and the window end minus one must be at or after the current block timestamp. The provided window fails at least one of these checks.Set the window start to a time before the window end, and set the end to a future timestamp (at least one second ahead of the current block time).errorNoInvalidConversionWindow(uint256,uint256)
DALP-4145Token decimal precision exceeds the maximum of 18.The SMART token core enforces a maximum of 18 decimal places to remain compatible with WAD-based fixed-point arithmetic. A decimals value above 18 is out of range.Set the decimals parameter to a value between 0 and 18 inclusive.errorNoInvalidDecimals(uint8)
DALP-4146Bond denomination asset address is zero.A bond must be linked to a denomination asset (the currency token used for face-value accounting). The zero address is not a valid asset contract.Provide the on-chain address of the ERC-20 token that denominates the bond before initializing.errorNoInvalidDenominationAsset()
DALP-4147Feeds directory address is zero.The scalar feed aggregator adapter stores the directory address as an immutable at construction time. A zero address cannot be used as a feeds directory.Pass the address of the deployed IFeedsDirectory contract when constructing the adapter.errorNoInvalidDirectory()
DALP-4148Directory address is zero.Several contracts (the system factory, the global trusted issuers registry, and the topic scheme registry) require a non-zero directory address during initialization. Without a valid directory the contract cannot resolve implementation addresses.Provide the address of the deployed IDALPDirectory contract during construction or initialization.errorNoInvalidDirectoryAddress()
DALP-4149Yield end date is not after the start date.The fixed treasury yield schedule requires the end date to be strictly greater than the start date. Providing an end date equal to or before the start date produces a zero-length or reversed schedule.Set the end date to a timestamp that is at least one second after the start date.errorNoInvalidEndDate()
DALP-4150Airdrop end time is not after the start time.The time-bound airdrop requires its end time to be strictly greater than the start time. An end time equal to or before the start time creates a zero-length or reversed claim window.Set the end time to a timestamp at least one second after the start time.errorNoInvalidEndTime()
DALP-4151Compliance expression does not reduce to exactly one result.The identity-verification compliance module evaluates a postfix boolean expression. After processing all operands and operators the evaluation stack must contain exactly one value. A stack count other than one means the expression is structurally malformed.Correct the compliance expression so every operator consumes the right number of operands and the final stack holds exactly one boolean result.errorNoInvalidExpressionMustEvaluateToOneResult()
DALP-4152Identity verification expression stack did not resolve to a single result.After evaluating the postfix claim expression in IdentityVerificationLib, the internal stack index must equal 1. A stack index other than 1 indicates unbalanced operators or extra operands remain.Review the postfix expression for unbalanced operators or extra operands, then resubmit with a well-formed expression that leaves exactly one value on the stack.errorNoInvalidExpressionStackResult()
DALP-4153XvP flow external chain ID matches the current chain.An XvP settlement flow marked as external must reference a different blockchain. The provided externalChainId equals the chain ID of the contract's own network, which is a contradiction.Set externalChainId to the chain ID of the remote network involved in the cross-chain leg, not the chain where this contract is deployed.errorNoInvalidExternalChainId(uint64)
DALP-4154Bond face value is zero.A bond's face value is the principal amount and must be a positive integer. A face value of zero makes the bond economically meaningless and is rejected at initialization.Set faceValue to the intended positive principal amount before initializing the bond.errorNoInvalidFaceValue()
DALP-4155Push airdrop factory address is zero or does not support the required interface.The push airdrop proxy validates the factory address by checking that it is non-zero and that the contract at that address implements IDALPPushAirdropFactory via ERC-165. Either check failed.Supply the address of a deployed IDALPPushAirdropFactory contract that passes ERC-165 interface detection for that type.errorNoInvalidFactoryAddress()
DALP-4156Token feature configuration data failed validation.The token feature factory's validateConfig rejected the provided configuration bytes. This sentinel error is raised when no more specific domain error applies. Common causes include passing non-empty config data to a feature that requires empty config, or config that does not decode to expected parameters.Check the specific feature factory's validateConfig requirements. Features that take no configuration expect empty bytes; features that take parameters require correctly ABI-encoded config data.errorNoInvalidFeatureConfig()
DALP-4157Global trusted issuers registry address must implement the required interface.During V2 migration, the contract checks that the provided global registry address implements IDALPTrustedIssuersRegistry via ERC-165. The address at the provided location did not return true for that interface ID.Provide the address of a contract that correctly implements and exposes IDALPTrustedIssuersRegistry through ERC-165 interface detection.errorNoInvalidGlobalRegistryAddress(address)
DALP-4158Feed history size is zero in BOUNDED mode.When the issuer-signed scalar feed is configured in BOUNDED history mode, it must retain at least one historical entry. A historySize of zero is not permitted in this mode.Set historySize to a positive integer equal to the number of historical entries the feed should retain. Switch to UNBOUNDED mode if a fixed history size is not needed.errorNoInvalidHistorySize()
DALP-4159Proposed implementation does not support the required contract interface.The contract requires any registered implementation to pass an ERC-165 interface check before it is accepted. The address provided does not advertise the expected interface.Supply an implementation contract that correctly implements and advertises the required interface via ERC-165 supportsInterface.errorNoInvalidImplementation()
DALP-4160Token implementation address is the zero address.The contract requires a non-zero, ERC-165-conforming token implementation address. A zero address was supplied.Provide the address of a deployed token implementation contract that supports the required SMART token interface.errorNoInvalidImplementationAddress()
DALP-4161Implementation contract does not support the expected module interface.The contract checks via ERC-165 that the supplied implementation address supports a specific interface (identified by interfaceId). The address must implement ERC-165 and advertise support for that interface.Supply the address of an implementation contract that supports the interface identified by the interfaceId field returned in the error.errorNoInvalidImplementationInterface(address,bytes4)
DALP-4162Initial management key address is the zero address.ERC-734 identity setup requires a non-zero management key to seed the key store. A zero address was provided.Provide a valid, non-zero wallet address as the initial management key.errorNoInvalidInitialManagementKey()
DALP-4163Contract already initialized.OpenZeppelin's Initializable guard prevents a contract from being initialized more than once. The contract's initialization slot is already consumed.Call initialize only once, at deployment time. If an upgrade is needed, use the appropriate reinitializer function for the new version.errorNoInvalidInitialization()
DALP-4164Initialization deadline must be at least one second in the future.The vesting airdrop contract requires initializationDeadline to be strictly greater than the current block timestamp. A value at or before the current time was supplied.Set the initialization deadline to a timestamp that is at least one second after the current block time.errorNoInvalidInitializationDeadline()
DALP-4165Batch input arrays have mismatched lengths.The batch claim operation requires all input arrays (indices, claim amounts, total amounts, merkle proofs) to be the same length. The arrays provided have different lengths.Ensure all arrays passed to the batch call contain the same number of elements.errorNoInvalidInputArrayLengths()
DALP-4166Yield distribution interval must be greater than zero.The yield schedule configuration requires a non-zero distribution interval (in seconds). A value of zero was supplied.Set the distribution interval to a positive number of seconds representing how often yield is distributed.errorNoInvalidInterval()
DALP-4167Trusted issuer address is the zero address.Registering a trusted issuer requires a non-zero contract address. A zero address was provided.Provide the address of a deployed claim issuer contract as the trusted issuer.errorNoInvalidIssuerAddress()
DALP-4168The source wallet is not registered as lost or the caller is not its registered replacement.Token recovery requires the source wallet to be marked as lost in the identity registry, and the caller's new wallet must match the registry's recorded replacement for that source. One of these conditions was not met.Confirm that the wallet to recover from is marked as lost in the identity registry and that the recovery is initiated from the wallet designated as its replacement.errorNoInvalidLostWallet()
DALP-4169Address is not a recognized compliance module.The compliance contract requires each module address to be non-zero and to declare support for ISMARTComplianceModule via ERC-165. The address provided failed this check.Supply the address of a deployed contract that correctly implements and advertises ISMARTComplianceModule.errorNoInvalidModule()
DALP-4170Feed update nonce is out of sequence.The issuer-signed scalar feed requires each update's nonce to be exactly one greater than the issuer's last accepted nonce. The nonce in the submitted update does not match this expected value.Fetch the current nonce for the issuer from the feed contract and submit the update with a nonce equal to that value plus one.errorNoInvalidNonce()
DALP-4171Feed update observedAt timestamp is zero.The issuer-signed scalar feed requires a non-zero observedAt timestamp in every update. A zero value was submitted.Set observedAt to the Unix timestamp (in seconds) at which the data value was observed.errorNoInvalidObservedAt()
DALP-4172OnchainID address is the zero address.The yield schedule contract requires a non-zero OnchainID contract address when setting the identity. A zero address was provided.Provide the address of the deployed OnchainID contract associated with this yield schedule.errorNoInvalidOnchainID()
DALP-4173OnchainID address is the zero address.The XvP settlement contract requires a non-zero OnchainID address when the factory calls setOnchainId. A zero address was provided.Provide the address of the deployed OnchainID contract for this settlement instance.errorNoInvalidOnchainId()
DALP-4174A required sale configuration parameter is zero or exceeds the allowed range.The token sale contract validates each numeric configuration parameter (sale duration, hard cap, token decimals, price ratio, soft cap, presale settings, extension duration). A value of zero or an out-of-range value was supplied for one of these.Review the sale configuration and ensure all numeric parameters are non-zero and within accepted bounds. Token decimals must not exceed 24.errorNoInvalidParameter()
DALP-4175Asset configuration has an empty required field.The asset factory requires non-empty name, symbol, and assetTypeName strings in the configuration. At least one of these fields was an empty string.Provide non-empty values for name, symbol, and assetTypeName in the asset configuration.errorNoInvalidParameters()
DALP-4176Compliance module configuration parameters are not accepted.A compliance module's validateParameters function rejected the provided configuration bytes. The error includes a reason string describing the specific constraint that was violated (for example, empty parameters, a zero hold period, or a duplicate entry).Consult the reason string in the error and correct the module configuration to satisfy that constraint before resubmitting.errorNoInvalidParameters(string)
DALP-4177Paymaster field in the user operation decodes to the zero address.The EIP-4337 EntryPoint unpacks the paymasterAndData field of the user operation and requires the extracted paymaster address to be non-zero. The decoded address was the zero address.Supply a valid, non-zero paymaster contract address in the paymasterAndData field, or omit paymasterAndData entirely to use no paymaster.errorNoInvalidPaymaster(address)
DALP-4178The paymasterAndData field is shorter than the minimum required length.The EIP-4337 EntryPoint requires paymasterAndData, when present, to be at least PAYMASTER_DATA_OFFSET bytes long so it can unpack the paymaster address and gas limits. The field provided is shorter than this minimum.Encode paymasterAndData with the full required structure: paymaster address (20 bytes) followed by verification gas limit and post-op gas limit (each packed as uint128), then any additional paymaster-specific data.errorNoInvalidPaymasterData(uint256)
DALP-4179Paymaster signature length exceeds available paymaster data.The ERC-4337 entry point decoded a pmSignatureLength value from the paymaster-and-data field that would extend before the start of the paymaster data. The encoded length must fit within the data that follows the fixed paymaster header.Reconstruct the paymaster-and-data payload so that the appended signature length value does not exceed dataLength minus the minimum paymaster data size with suffix.errorNoInvalidPaymasterSignatureLength(uint256,uint256)
DALP-4180Payment currency rejected for this token sale.The contract rejects a payment currency that is the sale token itself, any ERC20 token whose decimals() call reverts, or any token with more than 24 decimal places. All three conditions prevent safe price conversion.Use a different ERC20 token as the payment currency. Confirm the token is not the sale token, that its decimals() function returns successfully, and that the returned value is 24 or below.errorNoInvalidPaymentCurrency()
DALP-4181Period number is outside the range of configured yield periods.The fixed yield schedule reverts when the requested period is zero or greater than the total number of periods calculated from the schedule configuration.Supply a period number between 1 and the value returned by the schedule's total-periods query.errorNoInvalidPeriod()
DALP-4182Sale phase cannot transition to public sale from the current status.The transitionToPublicSale function requires the sale to be in the PRESALE phase. Calling it from any other status, including SETUP or PUBLIC_SALE, causes a revert.Activate the pre-sale phase first. Once the sale is in PRESALE status, call transitionToPublicSale to advance it.errorNoInvalidPhaseTransition()
DALP-4183Token sale price calculation produced an unusable result.A price computation within the token sale contract encountered parameters that would produce an overflow, division by zero, or otherwise unresolvable result.Review the price ratio and token decimal configuration. Ensure the base price and payment currency ratio are both non-zero and that the resulting amount fits within the expected numeric range.errorNoInvalidPriceCalculation()
DALP-4184Vesting or purchase range parameters are in the wrong order.The contract enforces that vestingCliff does not exceed vestingDuration, and that minPurchase does not exceed maxPurchase. Either pairing is out of order.Set the cliff to be less than or equal to the total vesting duration. Set the minimum purchase amount to be less than or equal to the maximum purchase amount.errorNoInvalidRange()
DALP-4185Yield rate must be greater than zero.The fixed yield schedule rejects a yield rate of zero basis points. A zero rate would produce no yield distribution.Provide a non-zero value for the yield rate expressed in basis points.errorNoInvalidRate()
DALP-4186Redemption target address is the zero address.The redeemable token extension requires a non-zero owner address when processing a redemption. Passing the zero address is rejected before any token movement occurs.Supply the address of the account whose tokens are being redeemed. The address must be a valid, non-zero Ethereum address.errorNoInvalidRedeemAddress()
DALP-4187Redemption amount must be greater than zero.The redeemable token extension rejects a redemption call where the token amount is zero. Redeeming zero tokens has no effect and is treated as an error.Provide a redemption amount that is at least 1 token unit.errorNoInvalidRedeemAmount()
DALP-4188Registry address is the zero address.The identity registry contract requires a non-zero address when setting a trusted issuers registry. The zero address cannot refer to a deployed contract.Provide the address of a deployed trusted issuers registry contract.errorNoInvalidRegistryAddress()
DALP-4189Registry address does not refer to a usable registry contract.The contract encodes the provided address in the error and reverts because the address is not a valid registry. Zero addresses and addresses that fail the required interface check are both rejected.Replace the registry address with the address of a correctly deployed and compatible registry contract.errorNoInvalidRegistryAddress(address)
DALP-4190Required confirmation count exceeds the number of signers.A multisig contract rejects any configuration where the number of required confirmations is greater than the total number of registered signers. Such a threshold can never be reached.Set the required confirmation count to a value that is less than or equal to the current number of signers.errorNoInvalidRequirement(uint256,uint256)
DALP-4191This operation cannot run while the sale is in its current status.The token sale contract enforces specific lifecycle statuses for each operation. The current status does not match the status the operation requires.Check the current sale status and complete any prerequisite steps, such as activation or finalization, before retrying.errorNoInvalidSaleStatus()
DALP-4192Feed topic schema hash does not match the required scalar schema.The feeds directory only accepts topics whose schema hash equals SCALAR_SCHEMA_HASH. The topic's registered signature produced a different hash, meaning the topic is not typed as a scalar feed.Register the feed under a topic whose schema signature matches the scalar schema, or register the topic with the correct scalar type signature before adding the feed.errorNoInvalidScalarSchemaHash(bytes32,bytes32)
DALP-4193Secret preimage does not match the settlement hashlock.The XvP settlement contract checks that keccak256(secret) equals the stored hashlock. The value provided does not produce the expected hash.Provide the exact secret bytes whose keccak256 hash matches the hashlock stored in this settlement.errorNoInvalidSecret()
DALP-4194ShortString storage encoding is corrupt.The OpenZeppelin ShortStrings library encodes string length in the low byte of a bytes32 slot. A value greater than 31 in that byte indicates a corrupt or miswritten short-string value.This error reflects an internal data integrity issue. Contact support if it appears during a normal operation.errorNoInvalidShortString()
DALP-4195Signature malformed or verification failed.The issuer-signed scalar feed rejects signatures that have a structurally malformed EIP-1271 envelope, a zero ECDSA recovery result, a non-contract signer address in the EIP-1271 path, or an s value in the upper half of the curve order (malleable signature).Re-sign the payload using the authorized issuer key. Ensure the signature uses the correct encoding for either the ECDSA path (65 bytes, canonical s) or the EIP-1271 path (abi-encoded signer address and inner signature).errorNoInvalidSignature()
DALP-4196ECDSA signature must be exactly 65 bytes.The issuer-signed scalar feed's ECDSA verification path requires a signature of exactly 65 bytes (32 bytes r, 32 bytes s, 1 byte v). A shorter or longer byte string cannot be decoded.Provide a standard 65-byte ECDSA signature. If using a smart-wallet signer, use the EIP-1271 envelope path instead.errorNoInvalidSignatureLength()
DALP-4197Recovered signer does not hold a CLAIM key on the issuer identity.The issuer-signed scalar feed validates that the address that signed the payload holds key purpose 3 (CLAIM) on the issuer's on-chain identity contract. The recovered address does not satisfy this check.Sign the payload with a key that is registered on the issuer identity contract with CLAIM purpose (purpose 3). Contact the issuer to add the signing key if needed.errorNoInvalidSigner()
DALP-4198Stake amount is zero or exceeds the maximum allowed.The ERC-4337 stake manager rejects a stake deposit when the resulting total stake is zero or exceeds type(uint112).max. Either no value was sent, or the cumulative stake would overflow the storage slot.Send a non-zero ETH amount with the stake call. If the account already has a large existing stake, ensure the sum of the existing stake and the new deposit stays within the uint112 maximum.errorNoInvalidStake(uint256,uint256)
DALP-4199Yield schedule start date is not in the future.The contract requires the start date to be strictly after the current block timestamp when creating a new yield schedule. A start date at or before the current time is not accepted.Set the start date to a timestamp that is at least one second after the current block time before submitting.errorNoInvalidStartDate()
DALP-4200Airdrop start time is not in the future.The contract requires the claim window start time to be strictly after the current block timestamp. A start time in the past or equal to the current time is not accepted.Set the start time to a future timestamp before submitting the airdrop configuration.errorNoInvalidStartTime()
DALP-4201Identity registry storage address is zero.The identity registry contract requires a non-zero address for its storage contract. A zero address was provided.Supply the address of a deployed identity registry storage contract.errorNoInvalidStorageAddress()
DALP-4202Subject address does not match the token's on-chain identity.The trusted issuers registry on this token only accepts queries where the subject address equals the token's own onchainID(). The provided subject address differs from that value.Pass the token's on-chain identity address as the subject parameter.errorNoInvalidSubjectAddress()
DALP-4203System contract address is zero or missing the required interface.The proxy requires a non-zero system address that supports the IDALPSystem interface. The provided address is either zero or does not pass the interface check.Provide the address of a deployed system contract that correctly implements IDALPSystem.errorNoInvalidSystemAddress()
DALP-4204Airdrop start and end times do not form a usable claim window.The combination of start time and end time supplied for this airdrop does not form a valid claim window. The end time must be at least one second after the start time, and the start time must be in the future.Set a future start time and an end time that is strictly after the start time before submitting.errorNoInvalidTimeWindow()
DALP-4205Sale or vesting timestamp conflicts with required time ordering.The contract enforces that sale start, vesting start, presale end, and sale end times form a valid, non-overlapping sequence. One of the supplied timestamps violates this ordering.Ensure the sale start is in the future, the vesting start is after the sale end, and the presale end falls within the sale window.errorNoInvalidTiming()
DALP-4206Topic ID zero is not allowed in compliance expressions.The compliance module's expression evaluator requires each topic node to carry a non-zero topic ID. A topic node with value zero was found in the supplied expression.Replace any topic node with value zero with a valid, non-zero topic ID before submitting the expression.errorNoInvalidTopicIdZeroNotAllowed()
DALP-4207Topic scheme registry address is zero.The feed or feeds directory requires a non-zero address for the topic scheme registry contract. A zero address was supplied during initialization.Provide the address of a deployed topic scheme registry contract.errorNoInvalidTopicSchemeRegistry()
DALP-4208Identity registry topic scheme registry address is zero.The identity registry contract requires a non-zero address for the topic scheme registry when initializing or updating that reference. A zero address was provided.Provide the address of a deployed topic scheme registry contract.errorNoInvalidTopicSchemeRegistryAddress()
DALP-4209Treasury address is zero.The maturity redemption factory and the fixed treasury yield feature both require a non-zero treasury address. A zero address was supplied.Provide the address of a deployed treasury contract before submitting the feature configuration.errorNoInvalidTreasury()
DALP-4210Trusted issuers registry address is zero.The issuer-signed scalar feed requires a non-zero address for the trusted issuers registry contract during initialization. A zero address was provided.Provide the address of a deployed trusted issuers registry contract.errorNoInvalidTrustedIssuersRegistry()
DALP-4211Unstake delay is zero or less than the current delay.The ERC-4337 stake manager requires the new unstake delay to be greater than zero and at least as large as the previously set delay. The provided value violates one of these constraints.Supply an unstake delay value that is greater than zero and greater than or equal to the current unstakeDelaySec recorded for this account.errorNoInvalidUnstakeDelay(uint256,uint256)
DALP-4212User wallet address is zero.The identity registry requires a non-zero wallet address when registering, recovering, or updating an identity. A zero address was supplied for the user wallet.Supply the actual wallet address of the user whose identity is being registered or recovered.errorNoInvalidUserAddress()
DALP-4213Withdrawal destination address is zero.The airdrop contract requires a non-zero address as the destination when executing a token withdrawal. A zero address was passed as the recipient.Provide a valid non-zero wallet or contract address as the withdrawal destination.errorNoInvalidWithdrawalAddress()
DALP-4214Issuer already exists.The trusted issuers registry already contains an entry for the supplied issuer address. The registry allows each issuer address to appear only once.Check the current registry contents before adding an issuer. If the issuer's claim topics need updating, use the update function rather than adding a duplicate entry.errorNoIssuerAlreadyExists(address)
DALP-4215Issuer cannot be zero address.You supplied the zero address as the claim issuer when registering a claim. A trusted issuer must be a deployed contract capable of signing claims, and the zero address does not satisfy that requirement.Supply the address of a deployed claim issuer contract instead of the zero address.errorNoIssuerCannotBeZeroAddress()
DALP-4216The requested resource could not be found.The supplied issuer address does not appear in the trusted issuers registry. The contract allows updates and removals only for issuers that are already registered.Confirm the issuer address is correct. If the issuer was never registered, add it before attempting to update or remove it.errorNoIssuerDoesNotExist(address)
DALP-4217You do not have permission for this operation.The issuer identity address submitted with the feed update is not listed as a trusted issuer for this feed's topic and subject in the trusted issuers registry. The feed only accepts updates from pre-authorized issuers.Register the issuer in the trusted issuers registry for this feed's topic and subject before submitting updates, or use a different issuer that is already authorized.errorNoIssuerNotAuthorized()
DALP-4218The requested resource could not be found.The contract attempted to remove the issuer at the given address from the trusted-issuers list for a specific claim topic, but that issuer was never added to that topic's list. The registry tracks which issuers each claim topic authorises, and this combination has no entry.Verify that you previously added the issuer address to the claim topic's trusted-issuers list before attempting removal. Retrieve the current list for the claim topic and confirm the address is present.errorNoIssuerNotFoundInTopicList(address,uint256)
DALP-4219Key already has this purpose.The on-chain identity key you are adding already holds the requested purpose. The ERC-734 key registry records each purpose only once per key.Check the key's current purposes with getKey() before calling addKey(). If the purpose is already present, no further step is needed.errorNoKeyAlreadyHasThisPurpose(bytes32,uint256)
DALP-4220Key cannot be zero.You supplied a zero key hash (bytes32(0)) to a key operation. The ERC-734 contract requires a non-zero key identifier for all key registry operations.Supply a valid non-zero key hash, typically derived as keccak256(abi.encode(address)) for an Ethereum address key.errorNoKeyCannotBeZero()
DALP-4221The requested resource could not be found.The key hash you referenced does not exist in the ERC-734 key registry. The registry only holds keys that a prior addKey() call explicitly added.Confirm the key hash is registered by calling keyHasPurpose() or getKey() before attempting removal. If the key is missing, add it first with addKey().errorNoKeyDoesNotExist(bytes32)
DALP-4222Key does not have this purpose.The key exists in the ERC-734 registry, but it does not hold the purpose you are trying to remove. The contract requires you to assign a purpose to a key before you can revoke it.Call getKey() to inspect the key's current purposes before calling removeKey(). Only attempt to remove a purpose that appears in the key's purposes array.errorNoKeyDoesNotHaveThisPurpose(bytes32,uint256)
DALP-4223Kind mismatch.A replaceFeed() call specified a feed kind that differs from the kind of the feed already registered at that subject-and-topic slot. The registry enforces that a replacement feed must be the same kind as the one it replaces.Check the existing feed's kind with getFeed() and supply a replacement feed of the same kind. To change the kind, remove the existing feed first, then register a new one.errorNoKindMismatch(uint8,uint8)
DALP-4224Length mismatch.A batch operation received two arrays (recipients and amounts) whose lengths differ. The contract requires one-to-one correspondence between each recipient address and its corresponding amount.Ensure the toList and amounts arrays you pass to the batch call contain the same number of elements before submitting.errorNoLengthMismatch()
DALP-4225Locked amount mismatch.During XvP settlement execution, the contract tried to release more tokens from escrow than the participant had locked. The escrowed balance for that asset and account is less than the amount the settlement leg requires.Confirm that the participant's locked balance for the asset covers the full settlement amount before submitting. If the escrow is short, the participant must top up the locked amount first.errorNoLockedAmountMismatch(address,address,uint256,uint256)
DALP-4226Max features reached.The token's feature list already holds the maximum of 32 features, or the incoming list exceeds that limit. The configurable token contract enforces a hard cap of 32 registered features.Reduce the number of features in the ordered list to 32 or fewer. Remove features that are no longer needed before registering new ones.errorNoMaxFeaturesReached()
DALP-4227Maximum allocation exceeded.The buyer's cumulative token purchase would exceed the per-address maximum allocation configured for the sale, or the presale per-address cap. The sale contract tracks each buyer's total across all purchases and blocks any that push the running total past the limit.Check the buyer's existing purchase total and the sale's maxPurchase and presale.maxPerAddress limits before submitting. Reduce the token amount so the cumulative total stays within the configured cap.errorNoMaximumAllocationExceeded()
DALP-4228Meta registry cannot provide complete answer.The trusted-issuers meta-registry received a call to an aggregation operation that it cannot satisfy on its own. The meta-registry is a registry-of-registries and certain operations require a direct registry, not the aggregating proxy.Call the operation directly on the specific subject registry or system registry rather than on the meta-registry. Retrieve the target registry address from getRegistryForSubject() or getSystemRegistry() first.errorNoMetaRegistryCannotProvideCompleteAnswer()
DALP-4229Metadata immutable.The contract marked this metadata key as immutable when it first stored the value. The contract permanently blocks any subsequent update or removal of metadata stored under an immutable key.Metadata stored under an immutable key cannot change. Use a different key for the updated value, or design the token so immutable keys only hold data that must never change.errorNoMetadataImmutable()
DALP-4230Missing type identifier.The addon implementation contract does not expose a typeId() function or the call reverted. The system addon registry requires every implementation to declare a unique type identifier before the registry can accept it.Ensure the implementation contract implements IWithTypeIdentifier and returns a non-reverting typeId(). Deploy or supply a corrected implementation before retrying registration.errorNoMissingTypeIdentifier(address)
DALP-4231Module already added.The compliance module at the given address is already registered on this token. The token contract allows each module to appear only once in its active compliance list.Check the token's current compliance modules before calling addComplianceModule(). If the module is already present, no step is needed.errorNoModuleAlreadyAdded()
DALP-4233Module type already registered.A module with the same type identifier is already registered in the account factory's module registry. The factory allows only one module per type identifier.Check the registered modules list and confirm no module with the same typeId is already present before calling registerModule(). To replace an existing module, remove it first with removeModule().errorNoModuleAlreadyRegistered(bytes32,address)
DALP-4234The requested resource could not be found.The compliance module at the given address is not present in this token's active compliance list. The token cannot update parameters or remove a module that was never added.Call the token's module-listing function to verify which modules are active before attempting to update or remove one. If you need the module, add it with addComplianceModule() first.errorNoModuleNotFound()
DALP-4236Module not registered.The module address does not appear in the account factory's module registry. Operations such as removing a module or setting it as the default validator require prior registration.Register the module with registerModule() before referencing it in removeModule() or setDefaultValidator(). Confirm the address matches the one originally registered.errorNoModuleNotRegistered(address)
DALP-4237No approval to revoke.The revokeApproval() call found no active, unconsumed transfer approval for the specified token, sender identity, recipient identity, and amount combination. The approval either never existed, already expired, or was already consumed by a transfer.Confirm an active approval exists for the exact token, sender identity, recipient identity, and amount before calling revokeApproval(). Use getApproval() or getExactApproval() to check the current state.errorNoNoApprovalToRevoke()
DALP-4238No bytecode.The address supplied to registerModule() has no deployed contract bytecode. The account factory requires every module to be a deployed contract with executable code.Confirm the module contract deployed successfully to the target address before registering it. Check deployment transaction receipts and confirm the address is correct for the target network.errorNoNoBytecode(address)
DALP-4239No checkpoint at timepoint.The requested timepoint is earlier than the first recorded checkpoint for the account or total supply in the historical-balances extension. When strict mode is on, the contract requires the timepoint to fall within the tracked history range.Query balanceOfAt() or totalSupplyAt() with strict=false to get a zero result for timepoints before the first checkpoint, or supply a timepoint at or after the first recorded checkpoint. Call the function without strict mode if a pre-history result of zero is acceptable.errorNoNoCheckpointAtTimepoint(uint256)
DALP-4240No contribution to refund.The token sale is in a failed state (soft cap not reached), but the caller's recorded contribution for the specified currency is zero. The contract only allows a refund claim when a positive contribution exists for that currency.Confirm you used the correct investor address and currency address. If you contributed under a different currency or address, submit the refund request with those values.errorNoNoContributionToRefund()
DALP-4241No initial admins.You called initialization with an empty list of admin addresses. The access manager or yield schedule requires at least one admin address to complete setup.Provide a non-empty array of admin addresses when deploying or initializing this contract.errorNoNoInitialAdmins()
DALP-4242No local flows.A cross-party value protocol (XvP) settlement requires at least one local sender flow on the current chain. You constructed this settlement with flows that are all external-chain only, leaving no local participants to initiate on-chain transfers.Include at least one flow where the sender is on the current chain before creating the settlement.errorNoNoLocalFlows()
DALP-4243No yield available.You attempted to claim yield, but no completed accrual periods carry a positive balance for this holder. This occurs when no periods have completed yet, the holder already claimed all completed periods, or the holder held no tokens during any unclaimed period.Wait for at least one yield period to complete and ensure the account holds tokens during that period before claiming.errorNoNoYieldAvailable()
DALP-4244Initialization required.The contract requires a prior initialization step before this call can proceed. The real estate asset contract checks that initialization stored premint parameters before allowing premint to complete.Ensure you fully initialized the contract with a non-zero premint amount before calling the premint completion step.errorNoNotInitialized()
DALP-4245Contract initialization sequence required.You called a function decorated with onlyInitializing outside the contract's initialization sequence. This guard is part of OpenZeppelin's Initializable pattern and prevents protected setup functions from running after initialization is complete.This function runs only during the contract's initialize call chain. Calling it after deployment is complete has no effect and the contract blocks it.errorNoNotInitializing()
DALP-4246Module installation required.The ERC-7579 ECDSA validator module has no owner recorded for the calling smart account. Install the module on the account before updating its owner record.Install the ECDSA validator module on the smart account first, then retry the owner update.errorNoNotInstalled()
DALP-4247Not matured.The token has a maturity redemption feature, but you requested redemption before the platform set the maturity flag on-chain. The contract requires the token to reach a matured state before it allows redemption.Wait for the token to reach its maturity date and for the maturity flag to be set on-chain before submitting a redemption.errorNoNotMatured()
DALP-4248Not operation requires one operand.During evaluation of an identity verification expression tree, the evaluator encountered a NOT node with an empty operand stack. A NOT operation consumes exactly one stack value, so the expression must have at least one preceding operand.Review the compliance expression tree structure. Each NOT node must appear after exactly one operand node.errorNoNotOperationRequiresOneOperand()
DALP-4249Not registered.You asked the global directory to retrieve a token type, compliance module, or addon by ID, but no entry with that ID exists in the registry. Nothing ever registered this ID, or the registry no longer holds it.Verify the registry ID is correct. List available entries in the global directory to confirm the target appears before retrying.errorNoNotRegistered(bytes32)
DALP-4250Not registered feature.A call to executeFeatureUpdate or executeFeatureApproval on a SMART token came from an address that is not in the token's registered feature set. Only feature contracts explicitly added to the token may trigger internal token updates.Ensure the token's feature registry includes the caller's feature contract before calling these entry points.errorNoNotRegisteredFeature(address)
DALP-4251Not staked.The ERC-4337 EntryPoint's stake manager requires the paymaster or account to have an active, locked stake before this operation can proceed. The stake is either zero, below the required minimum, or the unstake delay has not elapsed.Add stake to the EntryPoint for the paymaster account and ensure the unstake delay period has passed before retrying.errorNoNotStaked(uint256,uint256,bool)
DALP-4252Observed at too far in future.The observedAt timestamp in the submitted feed update is further in the future than the feed's configured drift allowance permits. The contract compares observedAt to block.timestamp + driftAllowance and rejects values that exceed this bound.Reduce the observedAt timestamp so it falls within the feed's drift allowance relative to the current block time.errorNoObservedAtTooFarInFuture()
DALP-4253Onchain id already set.The XvP settlement's on-chain identity address already holds a non-zero value. The contract blocks any reassignment of the identity address once set.The on-chain identity for this settlement already has a value. No further call to setOnchainId is needed.errorNoOnchainIdAlreadySet()
DALP-4254Out of range access.A byte-packing read or write operation in OpenZeppelin's Packing library attempted to access a byte range that lies outside the bounds of the packed value. The requested offset and length exceed the 32-byte word size.Review the byte offset and length parameters passed to the packing call and ensure they fit within the 32-byte boundary.errorNoOutOfRangeAccess()
DALP-4255Owner already set.The ERC-7579 ECDSA validator module already has an owner recorded for the calling smart account. The onInstall function can only set the owner once per account.The validator is already installed on this account. Use updateOwner to rotate the owner address instead of calling onInstall again.errorNoOwnerAlreadySet()
DALP-4256Partial conversion disabled.The conversion feature on this token has partial conversion disabled. The requested conversion amount is less than the holder's full available principal, which the contract treats as a partial conversion.Submit the conversion for the full available principal amount, or contact the token issuer to confirm whether this token supports partial conversions.errorNoPartialConversionDisabled()
DALP-4257Paymaster unauthorized.An address other than the configured EntryPoint called the paymaster's validatePaymasterUserOp or postOp entry point. The EntryPoint contract and its canonical resolver are the only callers these functions accept.Only the ERC-4337 EntryPoint calls these paymaster entry points. Do not call them directly.errorNoPaymasterUnauthorized(address)
DALP-4258Paymaster zero entry point.You initialized or updated the paymaster with a zero address as the EntryPoint. The contract requires a non-zero EntryPoint address for the ERC-4337 validation pipeline to function.Provide the deployed ERC-4337 EntryPoint contract address when initializing or updating the paymaster.errorNoPaymasterZeroEntryPoint()
DALP-4259Paymaster zero signer.You initialized or updated the paymaster with a zero address as the trusted signer. EIP-712 sponsorship ticket verification requires a non-zero signer address.Provide a valid non-zero signer address when initializing or rotating the paymaster signer.errorNoPaymasterZeroSigner()
DALP-4260Phase not active.The token sale contract requires an active phase (PRESALE or PUBLIC_SALE) before it accepts purchases. You attempted a purchase while the sale was in SETUP, PAUSED, SUCCESS, or FAILED, where the contract does not accept purchases.Check the current sale status before submitting a purchase. Wait until the sale operator advances the sale to PRESALE or PUBLIC_SALE, then retry.errorNoPhaseNotActive()
DALP-4261Post op reverted.The ERC-4337 EntryPoint requires each paymaster's post-operation call to succeed after a user operation executes. The paymaster's postOp function reverted, causing the EntryPoint to reject the operation.Review the returnData included in the error for the specific reason the paymaster's postOp reverted. Ensure the paymaster has sufficient deposit and that its validation logic matches the executed operation.errorNoPostOpReverted(bytes)
DALP-4262Premint already completed.The real-estate token contract's premint step can only be completed once, immediately after deployment. The factory already called completePremint successfully, and you attempted a second call.Premint completion is a one-time factory step. Do not call completePremint after it has already succeeded. If you need to mint additional tokens, use the standard mint flow instead.errorNoPremintAlreadyCompleted()
DALP-4263Proxy creation failed.The contract factory computed a deterministic deployment address with CREATE2 before deploying, but the deployed contract landed at a different address. This indicates a salt or bytecode mismatch between the prediction and the actual deploy.Ensure the deployment salt and initialization parameters you pass to the factory match exactly what you used to predict the address. Retry the deployment with consistent inputs.errorNoProxyCreationFailed()
DALP-4264Purchase amount too low.The token sale contract blocks purchases or token withdrawals when the effective amount is zero or below the configured minimum. This can occur when: the payment amount is zero, the payment is too small to convert to any tokens at the current rate, the withdrawable vested amount is zero, or the first purchase is below the sale's minimum purchase limit.Ensure the purchase amount converts to at least one token unit at the current rate and meets the sale's minimum purchase requirement. For token withdrawals, check that the vesting schedule has released a non-zero amount before calling withdrawTokens.errorNoPurchaseAmountTooLow()
DALP-4265Query before enabled.The historical balances feature only records checkpoints from the block at which it was enabled. You queried a timepoint ({{requestedTimepoint}}) that is earlier than the enabledAt timepoint ({{enabledAt}}), so no checkpoint data exists for that period.Query a timepoint at or after the value returned as enabledAt in the error. Historical balance data is not available for blocks before the token activated this feature.errorNoQueryBeforeEnabled(uint256,uint48)
DALP-4266Recipient not verified.The identity verification compliance module checks each recipient against the token's identity registry and required claim-topic expression before allowing a transfer or mint. The recipient's on-chain identity does not hold the required claims (such as KYC or AML) from trusted issuers.The recipient must complete the required identity verification process and have the necessary claims issued to their on-chain identity. Once the claims are present and the identity registry confirms the recipient as verified, retry the transfer.errorNoRecipientNotVerified()
DALP-4267Recover zero address.The emergency ERC-20 recovery function requires both the token address and the recipient address to be non-zero. You supplied a zero address for one of those parameters.Provide a valid non-zero token contract address and a valid non-zero recipient address when calling the ERC-20 recovery function.errorNoRecoverZeroAddress()
DALP-4268Reentrancy.The ERC-4337 EntryPoint detected a reentrant call into a protected function. The EntryPoint guards certain operations against reentrancy, and a call attempted to re-enter while a prior call was still executing.Do not call EntryPoint-protected functions from within a callback triggered by an ongoing EntryPoint execution. Review the call stack to eliminate the reentrant path.errorNoReentrancy()
DALP-4269Reentrant initialization.The fixed yield schedule contract detected a reentrant call during its initialization sequence. The initialize function must complete before anything calls it again.The initialization sequence must run to completion before any further calls to the contract are made. Ensure no external callbacks or nested calls re-enter the contract's initialize function.errorNoReentrantInitialization()
DALP-4270Refund grace period active.When a token sale ends in a FAILED state, the contract preserves the payment pool for investor refunds during a fixed grace period. An attempt was made to withdraw funds from the sale contract before the refund grace period has elapsed.Wait until the refund grace period expires before withdrawing funds from a failed sale. Investors should claim their refunds using claimRefund during the grace period. After the period ends, the withdrawal call will succeed.errorNoRefundGracePeriodActive()
DALP-4271The requested resource could not be found.You attempted a registry key migration but no implementation is registered under the source key ({{oldKey}}). The registry cannot remap a key that has no existing entry.Verify that the source type key you pass to the remap call matches an addon or factory implementation that is currently registered. List registered keys first and confirm the correct source key before retrying.errorNoRemapSourceNotFound(bytes32)
DALP-4272Remap target already exists.You attempted a registry key migration but the target key ({{newKey}}) derived from the implementation's typeId is already occupied by another registered implementation. Each type key must map to exactly one implementation.The new key resolved from the implementation's typeId conflicts with an existing registration. Remove or remap the existing entry at the target key first, or resolve the typeId collision between implementations before retrying.errorNoRemapTargetAlreadyExists(bytes32)
DALP-4273Replicated execution already performed.The on-chain identity contract's approve function checks that an execution has not already been carried out before processing an approval. The contract already performed execution {{executionId}} and will not approve it again.The contract approves and runs each execution exactly once. Check the execution state before calling approve. If you need to perform the same operation again, submit a new execution request via the execute function.errorNoReplicatedExecutionAlreadyPerformed(uint256)
DALP-4274The requested resource could not be found.The on-chain identity contract's approve function validates that the execution ID exists before processing. The supplied {{executionId}} is greater than or equal to the current execution nonce, meaning the contract has never created an execution with that ID.Verify the execution ID by checking the current execution nonce on the identity contract. Only IDs below the nonce represent valid pending executions. Submit a new execution request to obtain a valid ID.errorNoReplicatedExecutionIdDoesNotExist(uint256)
DALP-4275Revocation not allowed after commit.The XvP settlement has external (cross-chain) flows and all local participants have already approved, committing the settlement to the external counterparty. Once the counterparty chain acts on that commitment, individual parties can no longer revoke their approval.To cancel a fully-committed external settlement, use the cancel vote mechanism so all parties agree to cancel together rather than attempting an individual revocation.errorNoRevocationNotAllowedAfterCommit()
DALP-4276The requested resource could not be found.The scalar feed operates in bounded-history mode and the ring buffer has evicted the requested round, or the feed never recorded that round ID. The feed retains only a fixed number of past rounds.Request a round ID that falls within the feed's current retention window. Use the latest round ID if historical data for the requested round is no longer available.errorNoRoundNotFound(uint80)
DALP-4277Sale duration must be positive.The token sale factory requires a positive, non-zero sale duration. A duration of zero would create a sale that ends immediately and can never accept purchases.Supply a saleDuration value greater than zero when calling createTokenSale.errorNoSaleDurationMustBePositive()
DALP-4278Sale ended.The current block timestamp is at or past the sale's configured end time. The sale's purchase window has closed and the contract no longer accepts purchases.This token sale no longer accepts purchases. Check the sale's end time and, if a new sale is needed, create a new sale instance.errorNoSaleEnded()
DALP-4279Sale never activated.The finalizeSale call targeted a sale that is still in SETUP status, meaning the sale was configured but never activated. The finalization path requires the sale to have been activated at least once.The contract cannot finalize a sale that was never activated. To recover the sale token balance, use the appropriate withdrawal path for a non-activated sale, or contact your platform administrator.errorNoSaleNeverActivated()
DALP-4280Sale not active.The requested operation requires the sale to be in PRESALE or PUBLIC_SALE phase, but the sale is currently in a different phase (for example, SETUP, PAUSED, ENDED, or FAILED). Phase-gated operations such as purchasing tokens or pausing can only proceed when the sale is running.Check the current sale phase. If the sale administrator has paused the sale, they must resume it before purchases can proceed.errorNoSaleNotActive()
DALP-4281Sale not ended.The operation requires the sale to have ended, but the current block timestamp is still before the sale's configured end time and the contract has not moved the sale to ENDED status. Operations such as finalizing the sale or withdrawing unsold tokens are only permitted after the sale window closes.Wait until the sale's end time has passed, then retry the operation.errorNoSaleNotEnded()
DALP-4282Sale not failed.Refunds are only available when the sale has reached a FAILED final state (the soft cap did not reach its target). The sale is currently in a different final state such as SUCCESS, or the contract has not yet finalized it.Refunds are only claimable on failed sales. If the sale succeeded, purchased tokens are available to withdraw via the token withdrawal path instead.errorNoSaleNotFailed()
DALP-4283Sale not finalized as success.This sale has a soft cap configured. The contract blocks token withdrawal until the sale administrator finalizes the sale as SUCCESS, confirming the soft cap was met. This prevents buyers from withdrawing tokens while refunds might still apply if the sale ultimately fails.Wait for the sale administrator to call finalizeSale. Once the contract records the sale as SUCCESS, token withdrawal becomes available.errorNoSaleNotFinalizedAsSuccess()
DALP-4284Sale not started.The current block timestamp is before the sale's configured start time. The purchase window has not yet opened.Wait until the sale's start time arrives before submitting a purchase.errorNoSaleNotStarted()
DALP-4285Sale start must be in future.The sale start timestamp provided to createTokenSale is earlier than the current block timestamp. The contract requires the sale to start in the future so there is a defined period for setup and activation.Provide a saleStart value that is greater than the current block timestamp when calling createTokenSale.errorNoSaleStartMustBeInFuture()
DALP-4286Salt already taken.The identity factory uses CREATE2 for deterministic deployment. A previous deployment from this factory already consumed the salt derived from the provided wallet or contract address, so the factory cannot create a second identity at the same deterministic address.Each wallet or contract address can only have one identity created via this factory. Retrieve the existing identity address using the factory's lookup functions rather than creating a new one.errorNoSaltAlreadyTaken(string)
DALP-4287Same address.The address passed to updateImplementation matches the implementation address already registered in the XvP settlement factory. The contract rejects a no-operation replacement of an implementation with itself.Provide a different implementation address that has not already been set on this factory.errorNoSameAddress()
DALP-4288Schedule not active.The fixed treasury yield schedule's start date has not yet arrived. Yield accrual begins only on or after the configured startDate, so the contract has no yield to calculate before that point.Wait until the yield schedule's start date has passed before calling calculateAccruedYield.errorNoScheduleNotActive()
DALP-4289Schema hash mismatch.The IssuerSignedScalarFeed has a pinned schema hash and the hash computed from the topic's current definition does not match that pinned value. This protects the feed from accepting data formatted for a different schema version.Build the data update against the same topic schema the feed used at deployment. If the topic schema has changed, a new feed instance is required.errorNoSchemaHashMismatch()
DALP-4290Schema hash mismatch.The feeds directory rejected a replacement feed because its schema hash differs from the schema hash recorded for the existing feed at that topic. The directory enforces schema consistency so consumers can rely on a stable data structure.Supply a replacement feed compiled against the same schema as the existing feed, or register a new feed under a different topic.errorNoSchemaHashMismatch(bytes32,bytes32)
DALP-4291Secret already revealed.The contract already recorded a secret reveal for this XvP settlement's hashlock. Each hashlock-gated settlement accepts exactly one secret reveal.The secret is already on-chain. You can proceed directly to execution without revealing the secret again.errorNoSecretAlreadyRevealed()
DALP-4292Secret not revealed.The XvP settlement uses a hashlock gate and you attempted to execute before revealing the secret on-chain. The contract blocks execution until you submit the pre-image of the hashlock.Call the revealSecret function with the correct pre-image before attempting to execute the settlement.errorNoSecretNotRevealed()
DALP-4293Self transfer.One of the settlement flows specifies the same address as both sender and recipient. A transfer from an address to itself has no net effect and the contract rejects it as a configuration error.Review the settlement flows and correct any flow where flow.from and flow.to are the same address.errorNoSelfTransfer()
DALP-4294Sender address result.The ERC-4337 EntryPoint's getSenderAddress function always reverts with SenderAddressResult to return the computed counterfactual smart account address. The revert carries the address as data and signals successful address discovery, not a failure.Read the sender address from the revert data of the getSenderAddress call. Decode the SenderAddressResult(address) error to extract the computed address.errorNoSenderAddressResult(address)
DALP-4295Sender's key lacks the required purpose.The caller's address does not hold an ACTION_KEY purpose on the ERC-734 identity contract. The identity gate checks that the sender's key hash carries ACTION_KEY before allowing the requested call to proceed.Add the ACTION_KEY purpose to the caller's key on the identity contract, then retry the call.errorNoSenderLacksActionKey()
DALP-4296Sender lacks management key.The caller's address does not hold a MANAGEMENT_KEY purpose on the ERC-734 identity contract. The identity gate checks that the sender's key hash carries MANAGEMENT_KEY before allowing key management or approval calls.Have an existing MANAGEMENT_KEY holder add the MANAGEMENT_KEY purpose to the caller's key on the identity contract, then retry the call.errorNoSenderLacksManagementKey()
DALP-4297Sender not local.The caller is not registered as a local participant in this XvP settlement. Only addresses designated as local counterparties during settlement setup may perform this step.Retry the call from an address registered as a local participant in this settlement, or verify the correct settlement contract address.errorNoSenderNotLocal()
DALP-4298Signature unchanged.The topic scheme's signature is already set to the value you submitted. The registry rejects an update when the new signature is byte-for-byte identical to the one currently stored on-chain.Supply a different signature string when calling the update function, or skip the call if the current signature is already correct.errorNoSignatureUnchanged(string,string)
DALP-4299Signature validation failed.The EIP-4337 EntryPoint could not validate the aggregated signature produced by the aggregator at the address returned in the error. The aggregator's own validation check rejected the bundle's combined signature.Confirm the aggregator contract at the reported address is correct and that the signatures in the UserOperation bundle match the aggregation scheme.errorNoSignatureValidationFailed(address)
DALP-4300Slippage exceeded.The token amount calculated from your payment is below the minimum you specified. The sale contract enforces slippage protection: if the computed output is less than your stated minimum, the purchase reverts to protect you from an unfavorable price.Lower your minimum token amount or increase your payment amount, then resubmit the purchase.errorNoSlippageExceeded(uint256,uint256)
DALP-4301Soft cap not reached.A soft cap is configured on this sale and the sale has not yet reached a successful finalization. The contract requires successful finalization before allowing fund withdrawals, to prevent funds from leaving while a failed-sale refund window may still apply.Wait for the sale to finalize as SUCCESS before withdrawing funds. Check the current sale status and finalize if the soft cap has been met.errorNoSoftCapNotReached()
DALP-4302Stake still locked.The stake's unlock period has not elapsed yet. The EIP-4337 StakeManager records a scheduled withdrawal time and blocks the actual withdrawal until the current block timestamp reaches that time.Wait until the withdrawal time reported in the error (withdrawTime) has passed, then retry the withdrawal.errorNoStakeNotUnlocked(uint256,uint256)
DALP-4303Stake withdrawal failed.The EIP-4337 StakeManager attempted to transfer the withdrawn stake as native ETH to the destination address, but the transfer call failed. The revert reason from the failed transfer is included in the error.Verify that the withdrawal address can receive native ETH (it must not revert on plain transfers) and that sufficient gas is available, then retry the withdrawal.errorNoStakeWithdrawalFailed(address,address,uint256,bytes)
DALP-4304Stale observation.The feed update's observedAt timestamp is older than the timestamp of the most recently accepted observation. The issuer-signed scalar feed enforces monotonic ordering to prevent older data from overwriting newer data.Submit an update whose observedAt value is greater than or equal to the current latest observation timestamp recorded by the feed.errorNoStaleObservation()
DALP-4305String too long.The string value supplied exceeds 31 bytes, which is the maximum length that the OpenZeppelin ShortStrings library can pack into a single storage slot.Shorten the string to 31 bytes or fewer before submitting the call.errorNoStringTooLong(string)
DALP-4306System access manager not set.The compliance contract requires a system access manager address before this call can proceed, and no address has been configured yet.Configure the system access manager on the compliance contract before retrying this call.errorNoSystemAccessManagerNotSet()
DALP-4307System addon implementation not set.The system registry attempted to update the implementation address for an addon type whose implementation slot has never been populated. The registry allows updates only to addon types previously registered with an initial implementation.Register the addon type with an initial implementation address before attempting to update it. Confirm that the addonTypeHash in the error matches the intended addon type.errorNoSystemAddonImplementationNotSet(bytes32)
DALP-4308Addon type name already registered.An addon type with the given name is already registered in the system addon registry (V1, name-based). Each addon type name must be unique across all registrations.Choose a different type name for the new addon registration, or retrieve the existing addon proxy for the already-registered type name.errorNoSystemAddonTypeAlreadyRegistered(string)
DALP-4309Addon type already registered.An addon type with the given typeId is already registered and currently active in the system addon registry (V2, typeId-based). The registry permits re-registration only for archived addon types.Use the existing addon proxy for the registered typeId, or archive the existing registration before re-registering with the same typeId.errorNoSystemAddonTypeAlreadyRegisteredV2(bytes32)
DALP-4310System already bootstrapped.The system bootstrap function has already run and completed. The system accepts bootstrap only once; calling bootstrap again on an already-initialized system is blocked.Do not call bootstrap again on this system. If you need to update individual subsystem implementations, use the dedicated setter functions on the system contract.errorNoSystemAlreadyBootstrapped()
DALP-4311System trusted issuers registry implementation not set.The system bootstrap or setter call requires a non-zero trusted issuers registry implementation address, but the provided address is zero. The system validates this address before deploying or updating the registry proxy.Provide a valid, deployed trusted issuers registry implementation address when calling the system bootstrap or the setSystemTrustedIssuersRegistryImplementation function.errorNoSystemTrustedIssuersRegistryImplementationNotSet()
DALP-4312Terms already set.The sale's terms hash can only be set while the sale is in SETUP status. The sale has already been activated, so the terms hash is now locked.The terms hash for this sale cannot change after activation. To use different terms, deploy a new sale contract with the correct terms hash before activation.errorNoTermsAlreadySet()
DALP-4313Terms not accepted.A terms hash is set on this sale and the buyer has not yet accepted it. The sale contract requires each buyer to call acknowledgeTerms before the contract processes their purchase.Call acknowledgeTerms on the sale contract from the buyer's address before submitting the purchase.errorNoTermsNotAccepted()
DALP-4314Terms not set.The acknowledgeTerms call requires a terms hash configured on the sale, but the sale admin has not set one yet. Buyers cannot acknowledge terms until the admin publishes them.Have the sale admin call setTermsHash with the correct terms hash before buyers attempt to acknowledge terms.errorNoTermsNotSet()
DALP-4315Payment currency limit exceeded.The token sale contract enforces a maximum of 10 accepted payment currencies to prevent unbounded iteration during refund processing. Adding this currency would exceed that limit.Remove an existing payment currency before adding a new one, or reduce the number of accepted currencies to stay within the 10-currency limit.errorNoTooManyPaymentCurrencies()
DALP-4316The requested resource could not be found.The topic scheme registry could not locate the topic ID in its internal enumeration array during a removal. The topic ID has an index of zero, meaning it was never recorded in the array.Confirm the topic ID exists in the registry before attempting to remove it. Use the registry's lookup functions to verify the topic is registered.errorNoTopicIdNotFoundInArray(uint256)
DALP-4317Topic mismatch.The feed update's topic ID does not match the topic ID this feed contract was configured for. Each issuer-signed scalar feed is pinned to exactly one topic at deployment.Submit the update to the feed contract whose pinned topic ID matches the topic ID in your update payload.errorNoTopicMismatch()
DALP-4318Topic not registered.The feeds directory requires a registered topic scheme for every topic ID before a feed can be registered or updated. No scheme has been registered for this topic ID in the topic scheme registry.Register a topic scheme for this topic ID in the topic scheme registry, then retry the feed registration.errorNoTopicNotRegistered(uint256)
DALP-4319Topic scheme already exists.A topic scheme with this name already exists in the registry. The name is hashed to derive the topic ID, and that ID is already occupied.Choose a unique name for the new topic scheme. To update an existing scheme's signature, use the update function rather than the registration function.errorNoTopicSchemeAlreadyExists(string)
DALP-4320The requested resource could not be found.No topic scheme is registered for this topic ID, either locally or via the parent chain. The registry requires a scheme to exist before you can query or use it.Register a topic scheme for this topic ID before performing this operation. Verify the topic ID is correct and that it matches a scheme in the registry.errorNoTopicSchemeDoesNotExist(uint256)
DALP-4321The requested resource could not be found.No topic scheme is registered under this name. The registry cannot resolve the name to a topic ID with an associated scheme.Verify the name matches a scheme registered in the topic scheme registry. Names are case-sensitive and must match exactly.errorNoTopicSchemeDoesNotExistByName(string)
DALP-4322Topic scheme registry implementation not set.The system contract has no topic scheme registry implementation address configured. This address must be set before the system can bootstrap or perform operations that require the registry.Set the topic scheme registry implementation address on the system contract using the appropriate system manager function before proceeding.errorNoTopicSchemeRegistryImplementationNotSet()
DALP-4323Trigger already exists.The contract already holds a conversion trigger with this ID. Triggers are identified by their ID, and each ID must be unique.Use a different trigger ID, or disable the existing trigger before publishing a new one with the same ID.errorNoTriggerAlreadyExists(bytes32)
DALP-4324Trigger expired.The conversion trigger has passed its expiry timestamp. The contract checks that the current block timestamp does not exceed the trigger's configured expiry.Publish a new conversion trigger with an updated expiry timestamp in the future, then retry the conversion.errorNoTriggerExpired(bytes32)
DALP-4325Trigger not active.The referenced conversion trigger exists but the contract deactivated it. Only triggers with their active flag set can be used for conversions.Publish a new conversion trigger or reactivate the existing one through the appropriate trigger management call before retrying.errorNoTriggerNotActive(bytes32)
DALP-4326The requested resource could not be found.No conversion trigger exists for this trigger ID. The contract checks that the trigger's publishedAt field is non-zero before allowing a conversion.Publish a conversion trigger with the expected trigger ID before attempting the conversion.errorNoTriggerNotFound(bytes32)
DALP-4327Trusted issuers meta registry implementation not set.The system contract requires a trusted issuers meta registry implementation address before it can bootstrap or deploy identity infrastructure. No address is set.Set the trusted issuers meta registry implementation address on the system contract using the system manager function before proceeding.errorNoTrustedIssuersMetaRegistryImplementationNotSet()
DALP-4328The requested resource could not be found.The referenced multisig transaction does not exist at the requested index. The transaction index is out of range for the contract's transaction list.Verify the transaction index is correct and within the range of recorded transactions before submitting the request.errorNoTxDoesNotExist(uint256,uint256)
DALP-4329Tx executed.The multisig contract already executed the transaction at this index. Each transaction can run only once.Check the transaction status before submitting an execution request. The contract executes each transaction exactly once.errorNoTxExecuted(uint256)
DALP-4330You do not have permission for this operation.The caller's address does not match the address the contract requires for this operation. This contract restricts certain calls to a specific address, such as the factory that deployed it.Ensure the call originates from the authorized address for this operation. Check the contract's deployment configuration to identify the required caller.errorNoUnauthorized()
DALP-4331You do not have permission for this operation.The caller does not hold any of the token roles required to perform this operation on the bound token contract. The feature logic enforces role-based access for every guarded call.Grant the required token role to the caller on the token contract, then retry the operation.errorNoUnauthorizedCaller()
DALP-4332You do not have permission for this operation.An address other than the bound token contract called a compliance hook (transferred, created, or destroyed). The compliance contract enforces that only the registered token may invoke these hooks.Ensure these compliance hooks are invoked only by the token contract associated with this compliance instance. The contract rejects direct calls from other addresses.errorNoUnauthorizedCaller(address,address)
DALP-4333You do not have permission for this operation.An address other than the associated contract submitted a claim to this on-chain contract identity. This identity contract only allows its associated contract address to issue claims on its behalf.Trigger claim issuance through the associated contract rather than calling the identity directly from a different address.errorNoUnauthorizedContractOperation(address)
DALP-4334You do not have permission for this operation.The caller is not registered as an authorized converter for this token. The conversion minter checks the authorizedConverters mapping before allowing a conversion mint.Add the caller's address to the authorized converters list on the token contract. Then retry the conversion mint.errorNoUnauthorizedConverter(address)
DALP-4335You do not have permission for this operation.The token feature factory checks the caller's role before creating or replacing a feature. The call needs TOKEN_FACTORY_MODULE_ROLE at the system level or GOVERNANCE_ROLE on the subject token, and the calling address held neither.Ensure the caller holds TOKEN_FACTORY_MODULE_ROLE in the system, or holds GOVERNANCE_ROLE on the token whose feature is being created. Then resubmit the request.errorNoUnauthorizedFeatureCreation()
DALP-4336You do not have permission for this operation.The token contract, its configured compliance contract, or the system compliance contract must call compliance module hooks (transferred, created, destroyed). The address in the error did not match any of these permitted callers.Route compliance hook calls through the token or its compliance contract. Direct calls to compliance module hooks from other addresses are not permitted.errorNoUnauthorizedHookCaller(address)
DALP-4337You do not have permission for this operation.The owning contract's permission check (canAddClaim or canRemoveClaim) returned false for the calling address. Contract identities delegate claim management authorization to their owning contract, and the caller was not approved.Obtain approval from the owning contract for this address before calling addClaim, removeClaim, registerClaimAuthorizationContract, or removeClaimAuthorizationContract on the contract identity.errorNoUnauthorizedOperation(address)
DALP-4338You do not have permission for this operation.The multi-signature contract verified that the submitted signer address does not hold SIGNER_ROLE. Only registered signers may participate in or update multi-sig operations.Verify that the signer address holds SIGNER_ROLE on the multi-sig contract. Add the address to the signer set before submitting a transaction or weight update that references it.errorNoUnauthorizedSigner(address)
DALP-4339You do not have permission for this operation.An address other than the associated token contract called the voting power feature's internal voting-units function. The feature restricts this query to the token itself.Query voting units through the token contract or the feature's public getVotingUnits view function rather than calling the internal hook directly.errorNoUnauthorizedVotingUnitsQuery()
DALP-4340Unknown expression type.The on-chain RPN expression evaluator in the identity verification library encountered a node whose type does not match any known ExpressionType (TOPIC, AND, OR). The expression tree stored in the compliance rule contains an unrecognized node.Reconstruct the compliance expression using only supported node types (TOPIC, AND, OR) and redeploy it. If the platform produced the expression, contact support and report the error.errorNoUnknownExpressionType()
DALP-4341Unregistered key.The directory contract requires you to register a key before you can set its implementation or instance. The key passed to setImplementation or setInstance carried no registered interface, so the contract rejected the call.Register the directory key first by calling registerImplementation or registerInstance with the key and its expected interface. Once registered, setImplementation or setInstance will accept the call.errorNoUnregisteredKey(bytes32)
DALP-4342Unsupported attribute.The ERC-7786 cross-chain gateway source contract received a message attribute with a 4-byte selector that is not recognized by this gateway implementation. The gateway cannot forward messages that carry unsupported attributes.Remove the unsupported attribute from the cross-chain message before sending, or use a gateway implementation that declares support for the attribute selector returned in the error.errorNoUnsupportedAttribute(bytes4)
DALP-4343Unsupported execution operation.Contract identities do not support ERC-734 execution operations (approve, execute). These functions always revert because contract-owned identities manage authorization through their owning contract, not through the ERC-734 execution queue.Use the owning contract's authorization mechanisms instead of calling ERC-734 approve or execute on a contract identity. User wallet identities support these operations if needed.errorNoUnsupportedExecutionOperation()
DALP-4344Unsupported key operation.Contract identities block ERC-734 key management operations (addKey, removeKey). Contract-owned identities do not maintain a key registry; the owning contract controls access.Manage access through the owning contract's permission model rather than calling ERC-734 addKey or removeKey on a contract identity. Use a user wallet identity if key-based access control is required.errorNoUnsupportedKeyOperation()
DALP-4345Unsupported payment currency.The token sale contract requires you to register payment currencies before accepting purchases. You have not added the currency address used in the buy call to the sale's accepted payment currencies list.Use a payment currency that you have registered for this sale. Call paymentCurrencies on the sale contract to see which currencies the sale accepts, then resubmit with a supported currency address.errorNoUnsupportedPaymentCurrency()
DALP-4346Value not positive.The issuer-signed scalar feed has requirePositive enabled, and the submitted value was zero or negative. The feed enforces that all accepted values must be strictly positive when this flag is set.Submit a value greater than zero. If the data source produces zero or negative values for this feed, disable the requirePositive flag when configuring the feed, or filter the update before submission.errorNoValueNotPositive()
DALP-4347Delegation signature expired.The ERC-5805 delegateBySig call presented a signature whose expiry timestamp has passed. The Votes contract rejects expired signatures to prevent replay of stale delegation authorizations.Generate a new delegateBySig signature with an expiry timestamp in the future and resubmit. The expiry argument in the error shows the timestamp the contract found to be expired.errorNoVotesExpiredSignature(uint256)
DALP-4348Wallet already linked.The identity factory already maps this wallet address to an existing identity contract. Each wallet address can link to at most one identity in the factory.Check the existing identity for this wallet using the factory's lookup before attempting creation. If you genuinely need a new identity, remove the wallet from its current identity first.errorNoWalletAlreadyLinked(address)
DALP-4349Wallet already marked as lost.The identity registry has already recorded this wallet address as lost in the pending or accepted identity layer. The registry blocks recording a wallet as lost a second time, and a lost wallet cannot be the replacement wallet in a recovery.Check the wallet's current status in the identity registry before initiating recovery. Use a different replacement wallet address, or contact the identity manager if the lost status was set in error.errorNoWalletAlreadyMarkedAsLost(address)
DALP-4350Wallet in management keys.The identity factory detected that the wallet address being registered also appears in the management keys list supplied during creation. A wallet's own address cannot serve as an explicit management key because the contract rejects redundant key entries to prevent configuration errors.Remove the wallet address from the managementKeys array before submitting the identity creation request. The wallet already receives management access through its account registration.errorNoWalletInManagementKeys()
DALP-4351Withdrawal already scheduled.The airdrop contract already has a withdrawal scheduled and waiting for its timelock to elapse. Only one withdrawal can be pending at a time.Wait for the existing scheduled withdrawal to complete or cancel it before scheduling a new one. Call executeWithdrawal after the timelock elapses, or cancelWithdrawal to clear the pending state.errorNoWithdrawalAlreadyScheduled()
DALP-4352Withdrawal not due.The ERC-4337 EntryPoint stake manager requires callers to wait for the full unstake delay after calling unlockStake before withdrawing. The current block timestamp has not yet reached the scheduled withdrawal time returned in the error.Wait until the block timestamp reaches the withdrawTime value returned in the error, then resubmit the withdrawStake call. The error includes both the eligible withdrawal time and the current block timestamp.errorNoWithdrawalNotDue(uint256,uint256)
DALP-4353Withdrawal not ready.The airdrop contract has a withdrawal scheduled, but the timelock delay period has not yet elapsed. The contract requires a waiting period between scheduling and executing a withdrawal.Wait until the timelock period has fully elapsed after the scheduleWithdrawal call, then resubmit executeWithdrawal.errorNoWithdrawalNotReady()
DALP-4354Withdrawal not scheduled.You called executeWithdrawal or withdrawTokens without a prior scheduleWithdrawal call. The two-step withdrawal process requires you to schedule a withdrawal before the contract executes it.Call scheduleWithdrawal first to start the timelock period. After the delay has elapsed, call executeWithdrawal.errorNoWithdrawalNotScheduled()
DALP-4355Wrapped error.The ERC-4337 EntryPoint caught a revert from an inner call, such as a paymaster or account execution, and re-emits it as this error. The error carries the target address, the called function selector, the raw revert reason, and any extra detail bytes. The original failure originates inside the inner contract, not in the EntryPoint itself.Decode the nested reason bytes to find the root revert. The target and selector fields identify which contract and function reverted. Resolve the inner error using those details.errorNoWrappedError(address,bytes4,bytes,bytes)
DALP-4356Yield schedule active.The token's yield schedule has already started: its start date is at or before the current block timestamp. The contract blocks minting after the yield schedule becomes active to preserve the fairness of yield distribution.The contract closes minting once the yield schedule becomes active. Check the yield schedule's start date before attempting to mint, or contact the token issuer to confirm the minting window.errorNoYieldScheduleActive()
DALP-4357Yield schedule already set.A yield schedule is already associated with this token. The contract permits only one yield schedule per token and reverts if you attempt to set a second one.Read the current yieldSchedule address on the token before calling set. If the token already has a schedule, the contract blocks assigning another one.errorNoYieldScheduleAlreadySet()
DALP-4358A required value cannot be zero.A required address parameter was the zero address. The contract requires a non-zero address at this position.Supply a valid, deployed contract address for the parameter that triggered this error. Check each address argument in your call for the zero value.errorNoZeroAddress()
DALP-4359A required value cannot be zero.The address parameter named in the field argument was the zero address. The contract requires a non-zero address for that field.Provide a valid, deployed contract or wallet address for the field identified in the error. The field value in the error data names the specific parameter that was zero.errorNoZeroAddress(string)
DALP-4360A required value cannot be zero.An address argument that must be non-zero was the zero address. The contract enforces this guard before performing the operation.Provide a valid, deployed contract address for the parameter that was zero.errorNoZeroAddressNotAllowed()
DALP-4361A required value cannot be zero.The owner address provided during ECDSA validator installation or update was the zero address. The validator requires a real key-holding address as the account owner.Provide a non-zero EOA or contract address as the owner when installing or updating the ECDSA validator module.errorNoZeroAddressOwner()
DALP-4362A required value cannot be zero.A token amount argument was zero where the contract requires a positive value. The operation requires a non-zero quantity to proceed.Provide a positive, non-zero token amount. For conversion minting, this is the targetAmount to mint; verify the conversion calculation produces a value greater than zero.errorNoZeroAmount()
DALP-4363A required value cannot be zero.You called distribute or batchDistribute with an amount of zero. The contract requires each distribution entry to transfer at least one token unit.Ensure every distribution amount in your distribute or batchDistribute call is greater than zero. Remove or correct any zero-amount entries before submitting.errorNoZeroAmountToDistribute()
DALP-4364A required value cannot be zero.The vesting airdrop claim calculated zero claimable tokens for this index. The vesting schedule has not released any additional tokens since the last claim, so the transfer amount is zero.Wait until more tokens have vested before claiming. Check the vesting strategy's schedule to determine when the next release occurs.errorNoZeroAmountToTransfer()
DALP-4365A required value cannot be zero.The denomination asset address provided to the maturity redemption feature was the zero address. The feature requires a deployed ERC-20 contract as the payout currency.Provide a valid, deployed ERC-20 token address as the denomination asset when configuring the maturity redemption feature.errorNoZeroDenominationAsset()
DALP-4366A required value cannot be zero.The conversion pricing calculation produced an effective price of zero. This can happen when the configured discount is so high that the round price rounds down to zero after applying basis-point arithmetic.Reduce the discount percentage so that the effective price remains above zero, or increase the round price per share. Verify the discount and cap configuration for this conversion trigger.errorNoZeroEffectivePrice()
DALP-4367A required value cannot be zero.You deployed the EntryPoint wrapper with a zero-address canonical EntryPoint. The wrapper has no target to forward calls to and cannot operate.Deploy the EntryPoint wrapper with the correct canonical ERC-4337 EntryPoint address. Confirm the address is a deployed contract before passing it to the constructor.errorNoZeroEntryPoint()
DALP-4368A required value cannot be zero.The face value parameter for the maturity redemption feature was zero. The face value determines the redemption payout per token unit, so it must be a positive amount.Provide a positive face value (in the smallest unit of the denomination asset) when initializing the maturity redemption feature.errorNoZeroFaceValue()
DALP-4369A required value cannot be zero.The recipient address for the conversion minting call was the zero address. The contract requires a real wallet or contract address to receive the minted target tokens.Provide a valid, non-zero recipient address in the conversion minting call.errorNoZeroRecipient()
DALP-4370A required value cannot be zero.The conversion calculation computed a target amount of zero. The principal or interest, after the contract applies the effective price and token decimals, rounds down to zero tokens of the target asset.Increase the principal amount you are converting, or adjust the effective price configuration so that the resulting target amount is at least one token unit of the target asset.errorNoZeroTargetAmount()
DALP-4371A required value cannot be zero.The treasury address provided to the maturity redemption feature was the zero address. The treasury holds the denomination asset used for redemption payouts and must be a valid deployed address.Provide a valid, non-zero treasury address when initializing or reconfiguring the maturity redemption feature.errorNoZeroTreasuryAddress()
DALP-4372Cannot remove last validator.Removing this validator module would leave the account with no validators. An account with no validators cannot validate UserOperations and becomes permanently inoperable.Install a replacement validator module before removing the current one, so the account always retains at least one active validator.errorNoCannotRemoveLastValidator()
DALP-4373Validator module limit exceeded.Installing this validator module would exceed the account's maximum of {{maxValidators}} validator modules. The contract enforces this limit to keep UserOp validation gas costs bounded.Remove an existing validator module before installing a new one, keeping the total at or below {{maxValidators}}.errorNoTooManyValidators(uint256)
DALP-4374Operation unavailable on this contract.The contract function you called has no implementation. The contract reached the selector but the body is a stub that always reverts.This function is not available on this contract version. Check the API reference to confirm the correct method name and contract version, then retry with a supported call.errorNoNotImplemented()
DALP-4375Paymaster not deployed.The ERC-4337 EntryPoint simulation found that the paymaster address you supplied has no deployed bytecode. The EntryPoint rejects the user operation because it cannot call a contract that does not exist at that address.Confirm the paymaster contract has deployed bytecode on the target network, then provide its correct address before resubmitting the user operation.errorNoPaymasterNotDeployed(address)
DALP-4376Max staleness value is zero.The price resolver requires a max staleness threshold that is greater than zero seconds. A value of zero would disable the staleness check entirely, which the contract does not permit.Provide a positive number of seconds for the max staleness threshold.errorNoInvalidMaxStaleness()
DALP-4377Paymaster entry point not contract.Someone updated the paymaster's stored EntryPoint address to a value that has no deployed bytecode at that location. The contract requires the EntryPoint to be a live contract so it can call into it during validation.Supply the address of the currently deployed EntryPoint contract. Confirm the address has code on the target network before calling setEntryPoint.errorNoPaymasterEntryPointNotContract(address)
DALP-4378Asset type name required.The asset factory requires every DALP asset deployment to include a non-empty asset type name, because the name is part of the CREATE2 salt. Without it, the predicted deployment address is ambiguous and the factory cannot proceed.Call predictAccessManagerAddressForAssetType rather than the generic predictor. Supply a non-empty assetTypeName string that identifies the concrete asset type.errorNoAssetTypeNameRequired()
DALP-4379Parent registry address is self-referencing, unsupported, or creates a cycle.The chained registry requires a parent that is a distinct address implementing the required registry interface and absent from this contract's own chain. The provided address fails at least one of these conditions.Provide the address of a different, already-deployed registry contract whose parent chain excludes this contract entirely.errorNoInvalidParentAddress(address)
DALP-4380Implementation not registered.The compliance module registry has no registered entry for the requested typeId. Either the typeId was never registered, or it refers to a different registry. The registry blocks the call to prevent deploying or upgrading with an unknown module type.Verify that the typeId you are using matches a module type previously registered in this compliance module registry. Use the registry's enumeration to list registered types and confirm your typeId.errorNoImplementationNotRegistered(bytes32)
DALP-4381Instance deployment failed.The CREATE2 deployment of the compliance module instance returned address zero, meaning the EVM assembly creation call did not produce a contract. This typically occurs when the same salt already has a deployment at that address or the bytecode is malformed.Check whether a module instance for this engine and typeId was already deployed at the predicted address. If so, use the existing instance rather than redeploying.errorNoInstanceDeploymentFailed()
DALP-4382Compliance module configuration contains a constraint violation.The compliance module rejected the supplied configuration. The error includes a reason string describing the specific constraint that failed, such as a zero value where a positive one is required, a duplicate entry, or an address that exceeds an allowed limit.Correct the configuration field identified in the error reason and resubmit. Consult the error reason string for the exact constraint.errorNoInvalidConfig(string)
DALP-4383Not module admin.The compliance module's updateConfig call requires the caller to be either the compliance engine that owns the module or an address the engine has granted module admin status. The caller held neither role.Use an address that is the compliance engine for this module, or one that the engine's isModuleAdmin check returns true for. Contact the platform operator to have the correct address granted module admin status.errorNoNotModuleAdmin()
DALP-4384Registry not available.The compliance engine tried to resolve the compliance module registry through the system contract, but the system contract's registry address is zero. The registry address must be set on the DALPSystem proxy before compliance operations can proceed.Confirm that the DALPSystem proxy has a non-zero complianceModuleRegistry address configured. Platform setup requires this; contact the operator if the registry address is absent.errorNoRegistryNotAvailable()
DALP-4389Module family mismatch.An attempt was made to upgrade a compliance module implementation to a contract from a different V1/V2 family than the one originally registered. Changing the family would break all existing per-engine proxy instances that delegate to the current implementation.Supply a replacement implementation from the same module family (V1 or V2) as the originally registered type. To switch families, uninstall the existing module type and register a new one.errorNoModuleFamilyMismatch(bool,bool)
DALP-4390Type id mismatch.The new compliance module implementation reports a typeId that does not match the typeId you are registering it under. The registry enforces this to prevent a module from replacing one of a different type.Ensure the implementation contract's typeId() return value matches the typeId key you are registering it under. Check the implementation contract to confirm its declared type.errorNoTypeIdMismatch(bytes32,bytes32)
DALP-4392Max chain depth exceeded.A chained registry (topic scheme or trusted issuers) attempted to set a parent that would create a parent chain longer than 3 levels. The contract enforces this depth limit to prevent unbounded traversal during lookups.Restructure the registry hierarchy so that no chain from a child registry to a root registry exceeds 3 hops. Remove an intermediate level or flatten the hierarchy before setting the parent.errorNoMaxChainDepthExceeded()
DALP-4393Not a validator module.The address passed as a validator module during account creation does not satisfy the ERC-7579 validator interface. The account factory verifies this before creating the smart account to prevent creating accounts with non-functional validators.Use a module address registered in the account factory that implements the ERC-7579 Module interface with module type VALIDATOR. Confirm the module contract reports the correct module type before submitting.errorNoNotAValidatorModule(address)
DALP-4394System registry not available.The token identity registry factory requires one or more system registries to be set on the DALPSystem proxy before a token identity registry can deploy. The named registry address resolves to zero.Confirm all required system registries are configured on the DALPSystem proxy. The registryName field in the error identifies the missing registry. Contact the platform operator to complete system setup.errorNoSystemRegistryNotAvailable(string)
DALP-4396V1 hook must bypass adapter.You called a state-changing compliance hook (transferred, created, or destroyed) directly on the V1 compliance module adapter. The adapter does not handle these hooks because V1 modules require the engine to be msg.sender, so the engine must call the wrapped V1 module directly.Do not call state-changing hooks on the adapter contract. Read the v1Module() and config() from the adapter, then call the hook on the V1 module directly from the compliance engine.errorNoV1HookMustBypassAdapter()
DALP-4400The account {{account}} does not have the required role to perform this operation.The contract verified that account {{account}} does not hold the required role in the on-chain access manager. Each protected function consults the token's access manager contract, which stores role assignments. The access manager blocks the call when it finds no matching grant for that account.Contact your administrator to request the necessary permissions.errorNoAccessControlUnauthorizedAccount(address,bytes32)
DALP-4401Only the owner of this resource can perform this operation.The function is restricted to the contract owner, and the calling address is not the current owner recorded on-chain. Ownership is a single address stored in the contract. The contract blocks every other address from owner-only calls.Contact the owner or administrator for assistance.errorNoOwnableUnauthorizedAccount(address)
DALP-4402The calling address is not permitted to perform this operation.The contract delegates authorization to an external access manager, and that manager has determined the calling address is not permitted to call this function. The restriction is set at the access manager level, not within the token contract itself.Contact your administrator to request access.errorNoAccessManagedUnauthorized(address)
DALP-4404System already set.The contract already has a non-zero DALPSystem proxy address stored. The contract permits this reference only once to prevent silent redirection.The system reference is write-once after initial setup. If you need to point to a different system, re-deploy the compliance contract. Verify the currently configured system address before attempting to set it again.errorNoSystemAlreadySet()
DALP-4405System not set.The compliance contract tried to resolve the compliance module registry, but no DALPSystem proxy address has been configured yet. The registry address flows through the system proxy and the contract cannot resolve it without one.Call setSystem on the compliance contract with the DALPSystem proxy address before attempting registry-dependent operations. Perform this one-time initialization during platform setup.errorNoSystemNotSet()
DALP-4406Scope expression too complex.The compliance module scope being set contains at least one expression array that exceeds 32 nodes, or a country list that exceeds 250 entries. The contract enforces these limits to keep on-chain evaluation within gas bounds.Reduce each expression array in the module scope to 32 nodes or fewer and each country inclusion or exclusion list to 250 entries or fewer. Split into multiple scopes if you need more granularity.errorNoScopeExpressionTooComplex()
DALP-4407Management keys not supported.The identity implementation deployed at this proxy does not support the V2 interface required for management keys. Management keys can only be set on identities backed by a V2-compatible implementation.Deploy the identity proxy without management keys when using a V1 implementation, or upgrade to an implementation that supports the IDALPContractIdentityV2 interface before providing management keys.errorNoManagementKeysNotSupported()
DALP-4408Config immutable.The CapitalRaiseLimit compliance module already has a configuration set from its first initialization, and the module policy locks that configuration permanently. The contract blocks any subsequent updateConfig call.The CapitalRaiseLimit module configuration locks at initialization and the contract does not allow changes afterwards. To use different parameters, deploy a new module instance with the desired configuration.errorNoConfigImmutable()
DALP-4409Binding already active.The compliance module binding for the given instance address is already in the active state. The contract prevents a no-op re-enable from silently succeeding, which would mask double-submission bugs.Check the current binding state before calling enable. No further call is needed if the binding is already active.errorNoBindingAlreadyActive(address)
DALP-4410Binding already inactive.The compliance module binding for the given instance address is already in the inactive state. The contract prevents a no-op disable from silently succeeding, which would mask double-submission bugs.Check the current binding state before calling disable. No further call is needed if the binding is already inactive.errorNoBindingAlreadyInactive(address)
DALP-4411Binding not active.The compliance module binding for the given instance address exists in the registry but has a disabled state. Operations such as reconfiguring the module or updating its scope require an active binding, so the contract blocks the call until you re-enable it.Re-enable the compliance module binding for the instance address before retrying. Call the enable binding operation with the same instance address to restore it to active status.errorNoBindingNotActive(address)
DALP-4412The requested resource could not be found.The compliance module registry holds no record for the given instance address. The contract looks up the binding by address and finds no type identifier, meaning you never installed this module or it has already been fully uninstalled.Verify that the instance address is correct and that the compliance module has been installed on the token. Install the module first if you have not registered it.errorNoBindingNotFound(address)
DALP-4413You do not have permission for this operation.The caller of setOnchainID does not satisfy authorization from any validator installed on the account. Single-owner validators require the recorded EOA owner to call directly. Threshold validators require the call to arrive as a UserOp self-call so a quorum check runs first.Call setOnchainID from the authorized owner address, or route the call through a UserOp self-call if the account uses a threshold validator. Confirm which validator is installed on the account and satisfy its canManage check.errorNoUnauthorizedOnchainIDSetter(address)
DALP-4414Caller {{caller}} is not authorized to create management keys for contract {{contractAddress}}.The caller ({{caller}}) does not hold the authorization required to create management keys for the contract identity at {{contractAddress}}. Contract identity creation with management keys requires an authorized signer.Use an authorized contract-management signer or ask an administrator to create the contract identity.errorNoUnauthorizedContractManagementKeys(address,address)
DALP-4415Caller {{caller}} is not authorized to create an identity for wallet {{wallet}}.The identity factory requires that the wallet creates its own on-chain identity by calling as itself. Caller {{caller}} attempted to create the identity for wallet {{wallet}}, but the factory accepts direct creation only when the caller and the wallet address match. This prevents any third party from pre-claiming a wallet's CREATE2 identity slot.Call createIdentity as the wallet itself, or have the wallet owner sign createIdentityWithManagementKeyAuthorization before a relayer submits (required when seeding management keys or claim authorizers).errorNoUnauthorizedWalletManagementKeys(address,address)
DALP-4416Account onchain id mismatch.The account at the computed address already stores an ONCHAINID that does not match the expectedOnchainID you supplied in the creation parameters. The factory validates this when you supply a non-zero expectedOnchainID.Supply the correct expectedOnchainID that matches the ONCHAINID already recorded on the existing account, or omit expectedOnchainID if you do not need to enforce an identity match.errorNoAccountOnchainIDMismatch(address,address,address)
DALP-4417Account creation authorization deadline expired.The authorization you supplied carries a deadline that has already passed. The factory checks block.timestamp against the deadline encoded in the authorization parameters and rejects the call when the deadline is in the past.Request a new account creation authorization signed with a future deadline, then resubmit the call before that deadline passes.errorNoExpiredAccountCreationAuthorization(uint256)
DALP-4418Account creation authorization signature does not recover the required owner.The account factory verified the EIP-712 authorization signature and recovered a signer address that does not match the required owner address. The signature is from a different key than expected.Have the correct owner sign a fresh account creation authorization and resubmit.errorNoInvalidAccountCreationAuthorization(address,address)
DALP-4419Unexpected validator init data.You submitted account creation with non-empty validatorInitData but provided no explicit validator address. When you use the default validator, the factory sets the init data automatically and does not accept caller-supplied init data.Remove the validatorInitData from the request when creating an account with the default validator, or supply an explicit validator address that accepts the provided init data.errorNoUnexpectedValidatorInitData()
DALP-4420Empty batch.You submitted batchCreate with an empty entries array. The feed factory requires at least one entry to process and rejects a call with nothing to do.Include at least one entry in the batch before submitting. Each entry must be a fully specified feed creation request.errorNoEmptyBatch()
DALP-4421Conversion trigger expiry timestamp is in the past.When a non-zero expiry is provided, the contract requires it to be strictly in the future. The supplied expiresAt value refers to a time that has already passed.Set expiresAt to a future timestamp, or pass zero to create a trigger that never expires.errorYesInvalidExpiry(uint256)
DALP-4422The authorized converter must be a conversion feature.When authorizing a converter address on the minter feature, the contract verifies via ERC-165 introspection that the address implements the IConversionFeature interface. The address at {{converter}} did not return a positive response to the interface check, so the contract rejected the authorization.Select a loan token conversion feature address that supports IConversionFeature, then retry.errorNoNotAConversionFeature(address)
DALP-4423Your account does not have enough resources for this operation.The transfer approval record for the sender-recipient pair has a remaining allowance that is smaller than the requested transfer amount. The contract enforces that the approval covers the full amount before permitting the transfer.Request a new transfer approval for an amount at least as large as the transfer you intend to make, or reduce the transfer amount to fit within the existing approval balance.errorNoInsufficientApproval()
DALP-4424Basis per unit zero.The fixed treasury yield feature configuration sets basisPerUnit to zero. The contract requires a non-zero value because yield calculations divide by basisPerUnit to compute payouts.Set basisPerUnit to a positive non-zero value in the feature configuration before creating the fixed treasury yield feature.errorNoBasisPerUnitZero()
DALP-4425Config data must be empty.The token feature factory for this feature type does not accept configuration data. The default validateConfig implementation rejects any non-empty configData because this feature has no configurable parameters.Submit the createFeature or replaceFeature call with an empty configData byte array for this feature type.errorNoConfigDataMustBeEmpty()
DALP-4426Config data required.The token feature factory requires non-empty configuration data for this feature type, but the call arrived with an empty configData byte array. Features such as maturity redemption and fixed treasury yield encode their parameters in configData.Provide the ABI-encoded configuration parameters for this feature type in configData. Consult the feature factory's validateConfig signature for the expected encoding.errorNoConfigDataRequired()
DALP-4427Discount too high.The discountBps value in the conversion feature configuration exceeds 9999 basis points (99.99%). The contract enforces this limit so the effective conversion price remains non-zero: effectivePrice = roundPrice * (10000 - discountBps) / 10000.Set discountBps to a value between 0 and 9999 inclusive in the conversion feature configuration.errorNoDiscountTooHigh(uint256)
DALP-4428Duplicate converter address.The initialConverters list you provided to the conversion minter feature contains the same converter address more than once. The factory checks for duplicates to ensure each converter appears exactly once.Remove duplicate entries from the initialConverters array so every address appears exactly once before submitting the feature creation request.errorNoDuplicateConverterAddress(address)
DALP-4429End date not after start date.The endDate in the fixed treasury yield configuration is less than or equal to the startDate. The contract requires endDate to be strictly after startDate for the yield schedule to be valid.Set endDate to a Unix timestamp that is strictly greater than startDate in the feature configuration.errorNoEndDateNotAfterStartDate(uint256,uint256)
DALP-4430End date zero.The endDate in the fixed treasury yield configuration is zero. The contract requires a non-zero endDate to define when yield accrual stops.Set endDate to a non-zero Unix timestamp in the feature configuration before creating the fixed treasury yield feature.errorNoEndDateZero()
DALP-4431Escrow required for lock method.The conversion feature uses the Lock debt reduction method, which requires an escrow contract address to hold locked tokens, but you did not provide one. The contract enforces this dependency at configuration time.Supply a non-zero escrow contract address in the conversion feature configuration when using the Lock debt reduction method.errorNoEscrowRequiredForLockMethod()
DALP-4432Face value zero.The faceValue in the maturity redemption feature configuration is zero. The contract requires a non-zero face value to calculate redemption payouts per token unit at maturity.Set faceValue to a positive non-zero value in the maturity redemption feature configuration before creating the feature.errorNoFaceValueZero()
DALP-4433Implementation address zero.The implementation address provided to the token feature factory upgrade call is the zero address. The contract requires a deployed contract address for the new implementation.Provide the address of the deployed feature implementation contract when calling validateImplementation or the upgrade path on the feature factory.errorNoImplementationAddressZero()
DALP-4435Interval zero.The interval parameter in the fixed treasury yield feature configuration is zero. The contract requires a non-zero interval to define the time step between yield accrual periods.Set interval to a positive non-zero duration in seconds in the feature configuration before creating the fixed treasury yield feature.errorNoIntervalZero()
DALP-4436Conversion window start is after the end timestamp.The contract requires conversionWindowStart to be at or before conversionWindowEnd when an end is set. A start timestamp later than the end produces a window that can never open.Set conversionWindowStart to a timestamp that is equal to or earlier than conversionWindowEnd, then resubmit the configuration.errorNoInvalidConversionWindow()
DALP-4437Converter address at position {{index}} is the zero address.Each address in the initial converters list must be a non-zero address. The contract found the zero address at list position {{index}}.Replace the zero address at index {{index}} with the intended converter address and resubmit.errorNoInvalidConverterAddress(uint256)
DALP-4438Treasury address is the zero address.The fixed treasury yield feature requires a non-zero treasury address to receive yield distributions. A zero address was supplied.Supply the address of the treasury contract that will receive yield payments.errorNoInvalidTreasuryAddress()
DALP-4439No feature to replace.You called replaceFeature for a token that has no feature currently registered in this factory. The factory requires an existing feature before it can replace one.Call createFeature first to register a feature for this token, then use replaceFeature to update it.errorNoNoFeatureToReplace()
DALP-4440Rate zero.The fixed treasury yield feature requires a non-zero yield rate. The rate field in the configuration data resolved to zero, so the factory rejected the deployment.Supply a positive integer for the yield rate field in the feature configuration and resubmit.errorNoRateZero()
DALP-4441Replacement not supported.The permit feature factory does not support in-place replacement. Its configuration is always empty, so every predicted address for a given token is identical to the one already deployed.To change permit behavior, remove the existing permit feature and deploy a new one. The replaceFeature path is not available for this factory type.errorNoReplacementNotSupported()
DALP-4442Replacement would collide.The new configuration produces the same CREATE2 address as the feature already registered for this token. This happens when the replacement configuration is identical to the configuration used to deploy the current feature.Change at least one configuration parameter so the replacement resolves to a different address, then resubmit the replaceFeature call.errorNoReplacementWouldCollide()
DALP-4443Start date zero.The fixed treasury yield feature requires a non-zero start date timestamp. The startDate field in the configuration data resolved to zero, so the factory rejected the deployment.Supply a valid Unix timestamp for the startDate field in the feature configuration and resubmit.errorNoStartDateZero()
DALP-4444Implementation interface check failed.The contract probed the proposed implementation address for ERC-165 support and the call reverted rather than returning a boolean. The implementation contract does not respond correctly to interface introspection.Verify that the implementation address is a deployed contract that correctly implements ERC-165 supportsInterface without reverting, then resubmit the implementation registration.errorNoImplementationInterfaceCheckFailed()
DALP-4445Implementation missing interface.The proposed implementation contract returned false when queried for ERC-165 interface support for the required feature interface (interfaceId). The contract exists but does not expose the expected capability.Ensure the implementation contract declares support for the required feature interface via supportsInterface, then resubmit the implementation registration.errorNoImplementationMissingInterface(bytes4)
DALP-4446Not deployer.Only the original deployer of the DALPDirectoryDeferredProxy can call initializeProxy. The caller's address does not match the deployer address recorded at construction.Call initializeProxy from the same account that deployed the proxy contract.errorNoNotDeployer()
DALP-4447Proxy already initialized.The DALPDirectoryDeferredProxy has already run initializeProxy. The contract records a proxy-initialized storage flag on first call, and the contract blocks any further initialization attempt.The proxy is ready for use and needs no further initialization. If you intended to upgrade, use the UUPS upgrade path instead.errorNoProxyAlreadyInitialized()
DALP-4448Proxy uninitialized.The DALPDirectoryDeferredProxy has not yet run initializeProxy. The ERC1967 implementation slot holds no address, so the proxy cannot forward calls.Call initializeProxy on the proxy contract before making any other calls through it.errorNoProxyUninitialized()
DALP-4449Bundler call failed.The paymaster refund splitter tried to forward the bundler portion of a refund to the configured bundler address, but the native ETH transfer reverted.Verify that the configured bundler address is able to receive native ETH (not a contract that rejects transfers), then retry the refund routing.errorNoBundlerCallFailed()
DALP-4450Bundler share in basis points exceeds 10000.The paymaster refund splitter requires the bundler share bps to be at most 10000 (100%). The supplied value {{bps}} is higher than that limit.Provide a bps value between 0 and 10000 inclusive, where 10000 represents 100% of the refund going to the bundler.errorNoInvalidBps(uint16)
DALP-4451Bundler address is the zero address.The paymaster refund splitter requires a non-zero bundler address to route the bundler share of refunds. A zero address was supplied during initialization.Supply the address of the bundler that will receive its share of EntryPoint refunds.errorNoInvalidBundler()
DALP-4453Paymaster address does not point to a deployed paymaster contract.The refund splitter requires the paymaster to be a deployed contract that implements depositEntryPoint() and returns a valid, deployed EntryPoint address. The supplied address is either zero, has no deployed code, or its depositEntryPoint call failed or returned a zero/undeployed address.Supply the address of a deployed paymaster contract that implements depositEntryPoint() and whose depositEntryPoint resolves to a live EntryPoint contract.errorNoInvalidPaymaster()
DALP-4454Paymaster call failed.The paymaster refund splitter tried to deposit the paymaster portion of a refund to the paymaster's EntryPoint, but the deposit call reverted.Verify that the paymaster's canonical EntryPoint is operational and accepts deposits, then retry the refund routing.errorNoPaymasterCallFailed()
DALP-4455A required value cannot be zero.The Multicall3Reference wrapper requires a valid underlying Multicall3 contract address. The address provided to the constructor was the zero address.Provide the address of a deployed Multicall3 contract when constructing the Multicall3Reference wrapper.errorNoZeroMulticall3()
DALP-4456Not refundable.The XvP settlement does not currently owe funds back to you. The refund path opens only when the settlement is cancelled or the cutoff date has passed, and your approval has not been executed.Check the settlement status. If the settlement executed, use the delivery claim path instead. If the cutoff passed or the settlement was cancelled by the counterparty, confirm your approval state and retry the refund claim.errorNoNotRefundable()
DALP-4457Stake management must call the canonical EntryPoint directly.The EntryPointReference wrapper intentionally blocks stake management calls (addStake, unlockStake, withdrawStake). The canonical ERC-4337 EntryPoint records stake keyed by msg.sender, so forwarding through the wrapper would credit stake to the wrapper address rather than your contract.On canonical-entrypoint chains, route paymaster stake operations (addStake, unlockStake, withdrawStake) and deposits through the canonical EntryPoint rather than the EntryPointReference wrapper.errorNoStakeManagementMustCallCanonical()

Internal (OpenZeppelin / low-level)

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-9001Access 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.errorNoAccessControlBadConfirmation()
DALP-9002Access control enforced default admin delay.A default admin transfer is scheduled but the required delay period has not yet 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.errorNoAccessControlEnforcedDefaultAdminDelay(uint48)
DALP-9003Access 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.errorNoAccessControlEnforcedDefaultAdminRules()
DALP-9004Default 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.errorNoAccessControlInvalidDefaultAdmin(address)
DALP-9005Access 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.errorNoAccessControlMissingAnyOfRoles(address,bytes32,bytes32)
DALP-9006Address 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.errorNoAddressEmptyCode(address)
DALP-9007Checkpoint unordered insertion.The contract uses an ordered checkpoint structure that requires each new key to be strictly greater than the previous one. You supplied a key that is less than or equal to the most recent checkpoint key.Ensure checkpoint keys are always written in strictly increasing order. This is typically an internal sequencing constraint; contact support if this error appears unexpectedly.errorNoCheckpointUnorderedInsertion()
DALP-9008ECDSA 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.errorNoECDSAInvalidSignature()
DALP-9009ECDSA 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.errorNoECDSAInvalidSignatureLength(uint256)
DALP-9010ECDSA 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.errorNoECDSAInvalidSignatureS(bytes32)
DALP-9011ERC 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.errorNoERC1155InsufficientBalance(address,uint256,uint256,uint256)
DALP-9012ERC-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.errorNoERC1155InvalidApprover(address)
DALP-9013ERC-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.errorNoERC1155InvalidArrayLength(uint256,uint256)
DALP-9014ERC-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.errorNoERC1155InvalidOperator(address)
DALP-9015ERC-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.errorNoERC1155InvalidReceiver(address)
DALP-9016ERC-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.errorNoERC1155InvalidSender(address)
DALP-9017ERC 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.errorNoERC1155MissingApprovalForAll(address,address)
DALP-9018ERC-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.errorNoERC1967InvalidImplementation(address)
DALP-9019ERC 1967 non payable.The ERC-1967 proxy upgrade path does not accept ETH value. The call sent a non-zero value to a function the contract marks non-payable, so the contract reverted to protect against accidental ETH loss.Resubmit the proxy upgrade call with zero ETH value. Do not attach any ETH to this operation.errorNoERC1967NonPayable()
DALP-9020ERC 1967 proxy uninitialized.The ERC-1967 proxy's implementation slot still holds the zero address. The proxy must hold a concrete implementation address before it can forward any calls.Initialize the proxy by providing a valid implementation contract address. The proxy's implementation slot must be set before the proxy can forward calls.errorNoERC1967ProxyUninitialized()
DALP-9021ERC 20 exceeded safe supply.The ERC-20 token has a hard supply cap. The requested mint would push the total supply from {{increasedSupply}} above the configured cap of {{cap}}, so the contract blocked the operation.Reduce the mint amount so that the resulting total supply stays at or below the cap of {{cap}}. Check the current total supply before submitting the mint request.errorNoERC20ExceededSafeSupply(uint256,uint256)
DALP-9022ERC-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.errorNoERC20InvalidApprover(address)
DALP-9023ERC-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.errorNoERC20InvalidReceiver(address)
DALP-9024ERC-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.errorNoERC20InvalidSender(address)
DALP-9025ERC-20 spender cannot be the zero address.The contract requires the spender in an approve call to be a non-zero address. Granting an allowance to the zero address cannot be used and the standard blocks it.Supply a non-zero spender address when calling approve or increaseAllowance.errorNoERC20InvalidSpender(address)
DALP-9026Permit 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.errorNoERC2612ExpiredSignature(uint256)
DALP-9027Permit 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.errorNoERC2612InvalidSigner(address,address)
DALP-9028Forwarder 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.errorNoERC2771ForwarderExpiredRequest(uint48)
DALP-9029Forwarded 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 forwarded request using the private key of the account declared in the from field, then resubmit.errorNoERC2771ForwarderInvalidSigner(address,address)
DALP-9030ERC 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.errorNoERC2771ForwarderMismatchedValue(uint256,uint256)
DALP-9031ERC 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.errorNoERC2771UntrustfulTarget(address,address)
DALP-9032ERC 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.errorNoERC5805FutureLookup(uint256,uint48)
DALP-9033ERC 6372 inconsistent clock.The ERC-6372 clock extension requires that a contract's declared clock mode matches the values it actually 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.errorNoERC6372InconsistentClock()
DALP-9034ERC 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.errorNoERC721IncorrectOwner(address,uint256,address)
DALP-9035ERC 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.errorNoERC721InsufficientApproval(address,uint256)
DALP-9036ERC-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.errorNoERC721InvalidApprover(address)
DALP-9037ERC-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.errorNoERC721InvalidOperator(address)
DALP-9038ERC-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.errorNoERC721InvalidOwner(address)
DALP-9039ERC-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.errorNoERC721InvalidReceiver(address)
DALP-9040ERC-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.errorNoERC721InvalidSender(address)
DALP-9041ERC 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.errorNoERC721NonexistentToken(uint256)
DALP-9042ERC 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.errorNoERC7579AlreadyInstalledModule(uint256,address)
DALP-9043ERC 7579 cannot decode fallback data.The ERC-7579 account attempted to decode the calldata passed to a fallback handler, but the data does not conform to the expected ABI encoding. The contract aborted the decoding step to prevent malformed calls from reaching the handler.Ensure the calldata sent to the fallback is ABI-encoded according to the handler's expected signature. Check the module documentation for the correct encoding format.errorNoERC7579CannotDecodeFallbackData()
DALP-9044ERC 7579 decoding error.The ERC-7579 account tried to decode module call data but the bytes did not parse into the expected types. The contract reverted to avoid executing with corrupted arguments.Verify that the calldata passed to the module call is correctly ABI-encoded. Re-encode the arguments using the module's declared function signature and resubmit.errorNoERC7579DecodingError()
DALP-9045ERC 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.errorNoERC7579MismatchedModuleTypeId(uint256,address)
DALP-9046ERC 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.errorNoERC7579MissingFallbackHandler(bytes4)
DALP-9047ERC 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.errorNoERC7579MultisigAlreadyExists(bytes)
DALP-9048Multisig 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.errorNoERC7579MultisigInvalidInitData()
DALP-9049Signer 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 20 bytes or shorter, 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.errorNoERC7579MultisigInvalidSigner(bytes)
DALP-9050Signer 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.errorNoERC7579MultisigInvalidWeight(bytes,uint64)
DALP-9051ERC 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.errorNoERC7579MultisigMismatchedLength()
DALP-9052ERC 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.errorNoERC7579MultisigNonexistentSigner(bytes)
DALP-9053ERC 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.errorNoERC7579MultisigUnreachableThreshold(uint64,uint64)
DALP-9054ERC 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.errorNoERC7579MultisigZeroThreshold()
DALP-9055ERC 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.errorNoERC7579UninstalledModule(uint256,address)
DALP-9056ERC 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.errorNoERC7579UnsupportedCallType(bytes1)
DALP-9057ERC 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).errorNoERC7579UnsupportedExecType(bytes1)
DALP-9058ERC 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.errorNoERC7579UnsupportedModuleType(uint256)
DALP-9059Expected pause.The token contract is in the wrong pause state for this call. You may have requested a pause while the contract is already paused, or you called a function that requires the contract to be paused while it is active.Check the current pause state of the token before calling. Call unpause first if the contract is already paused and you want to re-pause, or ensure the contract is paused before you call functions that require the paused state.errorNoExpectedPause()
DALP-9060Failed call.A low-level call to a target contract or address failed. The target may have reverted, run out of gas, or does not exist at the specified address.Confirm the target address is a deployed contract and that it accepts the call. Check that you provide sufficient gas, then retry the operation.errorNoFailedCall()
DALP-9061Your account does not have enough resources 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.errorNoInsufficientBalance(uint256,uint256)
DALP-9062Ownership 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.errorNoOwnableInvalidOwner(address)
DALP-9063Reentrancy 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.errorNoReentrancyGuardReentrantCall()
DALP-9064Safe 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.errorNoSafeCastOverflowedUintDowncast(uint8,uint256)
DALP-9065Safe 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.errorNoSafeERC20FailedOperation(address)
DALP-9066Strings 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.errorNoStringsInsufficientHexLength(uint256,uint256)
DALP-9067UUPS 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.errorNoUUPSUnauthorizedCallContext()
DALP-9068UUPS 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.errorNoUUPSUnsupportedProxiableUUID(bytes32)
DALP-9069Permit 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.errorNoERC2612InvalidSignature(address)
DALP-9081Convert needs the accrued-interest backlog settled first.A full conversion with interest-on-conversion enabled must close the holder's yield accrual as part of the operation. The contract blocks this step when the holder has convertible interest beyond the currently settled cursor window, because closing accrual with an outstanding backlog would silently discard that yield.Settle the backlog to target tokens with convertYield (or to cash with claimYield), then re-submit the convert. The platform normally drains this automatically, so retrying the request usually clears it.errorYesUnsettledConvertibleInterest()

Chain & workflow

DALP CodeMessageWhySuggested FixSeverityRetryableSolidity Error
DALP-CHAIN-EMPTY-REVERTThe blockchain rejected this transaction with no reason code.The transaction reverted with no reason code. This happens when the caller holds insufficient on-chain permissions for the target function, or when the contract is not deployed at the address the system expects on this network.Check that you have the required role for this operation and that the system is fully deployed on this chain. Share the request id with your administrator if the issue persists.errorNoEmptyRevert()
DALP-EXT-TOKEN-NO-CODENo contract exists at {{tokenAddress}} on this network. External token registration requires the token contract to exist at that address.The external token registry checks that the address provided for registration contains deployed bytecode. The address {{tokenAddress}} has no bytecode on this network, so the registry blocks registration before any interface detection can proceed.Verify the address is correct, that you are connected to the right network, and that the token contract exists at that address before retrying.errorNoTokenAddressHasNoCode(address)
DALP-WORKFLOW-FAILEDThe deployment workflow failed before it could finish.The deployment workflow encountered an error that the platform could not classify as an RPC connectivity problem or a decoded contract revert. The workflow stopped before completing all deployment steps.Retry the deployment. If the problem persists, share the correlation id with your administrator.errorYesWorkflowFailed()
DALP-WORKFLOW-RPC-UNAVAILABLEThe blockchain RPC endpoint is temporarily unreachable and the deployment did not complete.The deployment workflow could not reach the blockchain RPC endpoint. The platform classified the request as an RPC connectivity failure (HTTP error, timeout, or socket error) before any transaction was submitted.Retry shortly. If the problem persists, contact your administrator.errorYesRpcUnavailable()
`

DALP Platform API error reference

Complete reference of all Platform API error codes returned by the DALP API, with HTTP status, retryability, and remediation guidance.

On this page

How to use this referenceContentsCompliance & token operationsSettlement & XvPAirdrop & distributionSystem & infrastructureInternal (OpenZeppelin / low-level)Chain & workflow