@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/errors-BIftM8ZN.cjs

@@ -0,0 +1,688 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_codecs = require("./codecs-Cswkg7Tm.cjs");
+let ts_custom_error = require("ts-custom-error");
+//#region ../../packages/lib/crypto/src/sha256.ts
+/**
+* SHA-256 of `bytes` as 32 raw bytes, computed synchronously so a caller
+* that must stay synchronous, such as a consent screen encoding a grant
+* scope, has the same digest the asynchronous Web Crypto API would give.
+*/
+const sha256 = (bytes) => require_codecs.sha256(bytes);
+//#endregion
+//#region ../../packages/contract/passport/src/errors.ts
+/**
+* Thrown when the user cancels the passkey ceremony invoked to create or
+* authenticate with a Passport account.
+*/
+var CeremonyCancelledError = class extends ts_custom_error.CustomError {
+	code = "ceremony-cancelled";
+	constructor(message = "The passkey ceremony was cancelled.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the platform authenticator does not support the PRF
+* extension. Passport derives both its signing and storage keys from the
+* passkey's PRF output, so an authenticator without it cannot host an
+* account.
+*/
+var PrfUnsupportedError = class extends ts_custom_error.CustomError {
+	code = "prf-unsupported";
+	constructor(message = "The platform authenticator does not support the PRF extension.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the persisted account record cannot be opened: the sealed
+* envelope is malformed, was tampered with, or the storage key does not
+* match the one that sealed it.
+*/
+var RecordCorruptedError = class extends ts_custom_error.CustomError {
+	code = "record-corrupted";
+	constructor(message = "The persisted account record could not be opened.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a device removal would leave the account with no authorised
+* device, or would remove the device that authorises the removal. Mirrors
+* the guard the Account Custody Contract itself enforces, so it can be
+* surfaced before submitting a transaction.
+*/
+var LastDeviceError = class extends ts_custom_error.CustomError {
+	code = "last-device";
+	constructor(message = "The last device on an account cannot be removed.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the Account Custody Contract rejects the caller's
+* authorisation: an invalid signature, a malformed device key, or a caller
+* entry that is not live in the on-chain device set. This is the
+* security-relevant rejection; a probe that merely fails to locate an
+* entry raises {@link DeviceEntryNotFoundError} instead, and a removal
+* whose target entry is gone raises {@link RemovalTargetNotFoundError}.
+*/
+var NotAuthorisedError = class extends ts_custom_error.CustomError {
+	code = "not-authorised";
+	constructor(message = "The account rejected the authorisation.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the use-counter rescan finds no live entry for this device
+* within the probed windows. Ambiguous by construction: the device may not
+* be registered on the account (or was revoked), or its counter may have
+* moved beyond the probed window, which a synced passkey used heavily on
+* another device can reach between sign-ins here. Not a security event.
+*/
+var DeviceEntryNotFoundError = class extends ts_custom_error.CustomError {
+	code = "device-entry-not-found";
+	constructor(message = "No live device entry was found within the probed counter windows.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a device removal names an entry that is not in the on-chain
+* device set: the target's entry rolled to a new counter since the roster
+* was last synced, or the device was already removed. Not a security
+* event; a rescan refreshes the roster.
+*/
+var RemovalTargetNotFoundError = class extends ts_custom_error.CustomError {
+	code = "removal-target-not-found";
+	constructor(message = "The device entry named for removal is not on the ledger.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the fee sponsor cannot cover the fees for a sponsored
+* transaction, for example because its budget has been exhausted.
+*/
+var SponsorExhaustedError = class extends ts_custom_error.CustomError {
+	code = "sponsor-exhausted";
+	constructor(message = "The fee sponsor could not cover this transaction.") {
+		super(message);
+	}
+};
+/**
+* Thrown when account creation finds a persisted account record already on
+* this device. The record is the only pointer to the deployed contract and
+* this build has no recovery path, so creating over it would orphan the
+* existing account; sign in recognises it instead.
+*/
+var AccountExistsError = class extends ts_custom_error.CustomError {
+	code = "account-exists";
+	constructor(message = "A Passport account already exists on this device; sign in instead.") {
+		super(message);
+	}
+};
+/**
+* Thrown when signing in finds no persisted account record on this device.
+* A record whose address holds no live contract raises
+* {@link AccountContractMissingError}, and a sealed record the configured
+* authoriser cannot open raises {@link RecordUnreadableError}.
+*/
+var AccountNotFoundError = class extends ts_custom_error.CustomError {
+	code = "account-not-found";
+	constructor(message = "No Passport account was found.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an account creation is unfinished: sign-in finds the
+* contract deployed but not every verifier key wave landed, or the
+* initial device not yet activated, or a hosted signer refuses to resume
+* a creation another site started. Sign-in cannot finish a creation;
+* creating the account again on this device, from the site that started
+* it, resumes the deployment from where it stopped.
+*/
+var AccountCreationPendingError = class extends ts_custom_error.CustomError {
+	code = "account-creation-pending";
+	constructor(message = "The Passport account on this device is not finished being created; resume the creation from the site that started it.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the persisted account record names an address that holds no
+* live Account Custody Contract on chain: the contract is gone, or the
+* record belongs to a different network than the one queried.
+*/
+var AccountContractMissingError = class extends ts_custom_error.CustomError {
+	code = "account-contract-missing";
+	constructor(message = "No live Account Custody Contract was found at the recorded address.") {
+		super(message);
+	}
+};
+/**
+* Thrown when none of the envelopes this device holds in the account's
+* inbox opens a secret deriving the `enc_key` the Account Custody
+* Contract advertises: the device was never handed the account keys, was
+* removed before the last rotation, or reads another network or another
+* account. Refusing at sign-in keeps the account from passing as
+* recognised until an entry fails to open.
+*/
+var EncryptionKeyMismatchError = class extends ts_custom_error.CustomError {
+	code = "encryption-key-mismatch";
+	constructor(message = "The derived encryption key does not match the account contract enc_key.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a sealed account record is present but the configured
+* authoriser provides no storage key to open it. A persistence
+* misconfiguration, not an absent account: pairing the authoriser that
+* sealed the record restores access.
+*/
+var RecordUnreadableError = class extends ts_custom_error.CustomError {
+	code = "record-unreadable";
+	constructor(message = "A sealed account record exists but this authoriser provides no storage key to open it.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an operation that needs a ready Passport account is invoked
+* without one: no account is in state, or the flow has not reached
+* 'ready'.
+*/
+var NoAccountError = class extends ts_custom_error.CustomError {
+	code = "no-account";
+	constructor(message = "No ready Passport account is available.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a downloaded proving artefact fails its integrity check,
+* for example a hash mismatch against the expected digest.
+*/
+var ArtefactIntegrityError = class extends ts_custom_error.CustomError {
+	code = "artefact-integrity";
+	constructor(message = "The proving artefact failed its integrity check.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an operation names a grant that is not in the Account
+* Custody Contract's grants map.
+*/
+var GrantNotFoundError = class extends ts_custom_error.CustomError {
+	code = "grant-not-found";
+	constructor(message = "No grant with this identifier was found.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a grant's opening is asked for but this client holds none:
+* the grant was issued by another client of the account, or before the
+* client kept the object fields of its grants. Only the issuing client
+* can export the policy of a grant.
+*/
+var GrantOpeningUnavailableError = class extends ts_custom_error.CustomError {
+	code = "grant-opening-unavailable";
+	constructor(message = "This client holds no opening for the grant, so it cannot export its policy.") {
+		super(message);
+	}
+};
+/**
+* Thrown when issuing a grant would exceed the number of grants the
+* Account Custody Contract holds at once. Revoking a grant frees room.
+*/
+var GrantLimitReachedError = class extends ts_custom_error.CustomError {
+	code = "grant-limit-reached";
+	constructor(message = "The account already holds the maximum number of grants.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a requested grant scope breaks a rule, for example a cap
+* below the per-call cap, an expiry in the past, or a read grant without
+* an rp id. Raised before any transaction is built.
+*/
+var GrantScopeInvalidError = class extends ts_custom_error.CustomError {
+	code = "grant-scope-invalid";
+	constructor(message = "The grant scope is not valid.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a read grant or a device removal is requested but the
+* encryption key held here cannot share the viewing secret: the key opens
+* inbox entries but offers neither the re-encryption a rotation needs nor
+* the sealing a delegate receives the secret through, as a device-only
+* authoriser's does. Raised before any prompt.
+*/
+var ReadUnavailableError = class extends ts_custom_error.CustomError {
+	code = "read-unavailable";
+	constructor(message = "The encryption key held here cannot share the viewing secret, so no read grant can be issued or revoked and no device removed.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a device is enrolled with keys that cannot be its own: a
+* reader key that is not a canonical X25519 key of large order, a device
+* key that is not a compressed Jubjub point, or a device key whose first
+* entry on the account is not the commitment enrolled. Raised before any
+* prompt, so the account keys are never sealed to a reader that does not
+* belong to the enrolled device.
+*/
+var DeviceReaderInvalidError = class extends ts_custom_error.CustomError {
+	code = "device-reader-invalid";
+	constructor(message = "The joining device keys do not match the enrolled device.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the device roster changed underneath a rotation: a
+* registration the live roster key opens landed while the rotation ran,
+* as another device's enrolment does. The rotation refuses before
+* `enc_key` is replaced, so a device enrolled meanwhile is never left on
+* the old key; running it again seals to the roster as it now stands.
+* A hosted signer refuses with it too when a rotation names a reader the
+* roster does not register as named.
+*/
+var DeviceRosterInvalidError = class extends ts_custom_error.CustomError {
+	code = "device-roster-invalid";
+	constructor(message = "The device roster of the account changed during the rotation.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the Account Custody Contract rejects a grant issuance that
+* passed local validation, for example because the grant identifier is
+* already taken.
+*/
+var GrantIssueRejectedError = class extends ts_custom_error.CustomError {
+	code = "grant-issue-rejected";
+	constructor(message = "The account rejected the grant.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a revocation names a grant the Account Custody Contract
+* lists but no longer holds active: it was already revoked and stays in
+* the grants map as an inactive tombstone until its slot is reused or
+* every grant is revoked. Raised before any prompt when the roster shows
+* the grant inactive, and from the contract's own abort should the grant
+* be revoked elsewhere in between.
+*/
+var GrantRevokedError = class extends ts_custom_error.CustomError {
+	code = "grant-revoked";
+	constructor(message = "The grant is already revoked.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the hosted signer refuses to seal a viewing secret to a
+* read grant whose revocation it signed: it forgets the grantee's read key
+* as soon as it signs the revocation, since it cannot see whether the
+* revocation lands. A grant still live with this error has a revocation
+* that never landed, so it is revoked again rather than issued again.
+*/
+var GrantRevocationPendingError = class extends ts_custom_error.CustomError {
+	code = "grant-revocation-pending";
+	constructor(message = "The revocation of this read grant was signed but has not landed, so no newer viewing secret is sealed to it.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an agent prepares a spend its grant does not allow: an
+* operation outside the grant's scope, an amount above the per-call cap
+* or past the cumulative cap, a recipient the grant's pin does not admit,
+* a coin of another colour or above the grant's coin bound, or a policy
+* whose grant id does not derive from its own fields. Raised before
+* anything is signed, so the agent learns it before it submits a call
+* the contract would refuse.
+*/
+var GrantSpendRefusedError = class extends ts_custom_error.CustomError {
+	code = "grant-spend-refused";
+	constructor(message = "The grant does not allow this spend.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a grant is requested by a host that runs under no relying
+* party id. Every grant is bound to the origin of the host that issued it
+* through the grant id, so without one there is no id to issue under.
+* Raised before the chain is read.
+*/
+var GrantOriginMissingError = class extends ts_custom_error.CustomError {
+	code = "grant-origin-missing";
+	constructor(message = "A relying party id is required to issue a grant; none was given to the module.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the indexer never reflects a grant call the chain accepted
+* within the time the flow waits for it. The account record already
+* holds the call's bookkeeping, so a sign-in reads the roster back once
+* the indexer catches up.
+*/
+var GrantRosterUnsettledError = class extends ts_custom_error.CustomError {
+	code = "grant-roster-unsettled";
+	constructor(message = "The grant roster never reflected the accepted call.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an account deployment cannot be completed: the contract's
+* maintenance authority was retired before every verifier key wave
+* landed, so no update can install the missing operations. Unrecoverable:
+* the contract is left as it stands and a new account is the only way on.
+* An install of missing operations on a locked account, whose authority
+* was retired at creation, raises it too, before anything is signed.
+*/
+var AuthorityRetiredError = class extends ts_custom_error.CustomError {
+	code = "authority-retired";
+	constructor(message = "The account retired its maintenance authority before every operation was installed.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a creation resumes over an account the chain shows
+* activated with its deploy-time maintenance authority still live, whether
+* it chose to lock the account or to hand the authority to its devices.
+* The flow retires or hands over the authority before it activates, so
+* the deployment ran outside it; whoever holds the deploy-time key keeps
+* full custody of the account and may have installed verifier keys no
+* check has seen, and a new account is the safe way on.
+*/
+var AuthorityNotRetiredError = class extends ts_custom_error.CustomError {
+	code = "authority-not-retired";
+	constructor(message = "The account was created to be locked, but its maintenance authority is still live.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a creation resumes an unfinished one under another lock
+* choice than the one it was started with. The deployment carries out the
+* choice it recorded, so resuming under another would finish an account
+* other than the one asked for; the message names the recorded choice,
+* which a retry repeats to finish the creation.
+*/
+var CreationLockMismatchError = class extends ts_custom_error.CustomError {
+	code = "creation-lock-mismatch";
+	constructor(message = "The unfinished account creation was started with another lock choice.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a creation resumes an unfinished one started under other
+* pinned verifier keys than this build installs, or recorded without
+* naming them. Finishing it would leave the account with verifier keys of
+* two builds, which no proof of either satisfies, so it is refused before
+* any wave; a new account is the way on.
+*/
+var CreationArtefactMismatchError = class extends ts_custom_error.CustomError {
+	code = "creation-artefact-mismatch";
+	constructor(message = "The unfinished account creation was started under other contract artefacts than this build installs.") {
+		super(message);
+	}
+};
+/**
+* Thrown when the contract's maintenance authority on chain is not the
+* one any roster key this device holds derives: the account is locked,
+* its authority was rotated by a roster this device was never handed, or
+* the keyring belongs to another account. Raised before anything is
+* signed. A resumed creation raises it too when the committee on chain is
+* neither the deploy-time key nor the successor the recorded creation
+* installs, refused before any wave.
+*/
+var MaintenanceAuthorityMismatchError = class extends ts_custom_error.CustomError {
+	code = "maintenance-authority-mismatch";
+	constructor(message = "No roster key this device holds derives the account's maintenance authority.") {
+		super(message);
+	}
+};
+/**
+* Thrown when a maintenance update asks for a change the encryption key
+* does not sign: a replace that installs any authority other than the one
+* the live roster key derives, a verifier key that is not the one pinned
+* for its operation or not in the deployed roster, or no change at all.
+* An install is refused before any key is opened, a replace before
+* anything is signed. A roster rotation over an account whose authority
+* is live raises it too when the encryption key signs no maintenance
+* update at all, as the authority could not follow the roster, and so
+* does an install of missing operations, before any prompt.
+*/
+var MaintenanceUpdateRefusedError = class extends ts_custom_error.CustomError {
+	code = "maintenance-update-refused";
+	constructor(message = "The maintenance update asks for a change the encryption key does not sign.") {
+		super(message);
+	}
+};
+/**
+* Thrown when an install of missing operations names an operation it
+* cannot install, one outside the operation roster this build deploys,
+* such as a recovery circuit or another device arm, or names none at
+* all. Raised before any prompt, naming every such operation; nothing is
+* installed. An operation the account already holds a verifier key for
+* is skipped rather than refused.
+*/
+var OperationNotInstallableError = class extends ts_custom_error.CustomError {
+	code = "operation-not-installable";
+	constructor(message = "The account cannot install the operations asked for.") {
+		super(message);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AccountContractMissingError", {
+	enumerable: true,
+	get: function() {
+		return AccountContractMissingError;
+	}
+});
+Object.defineProperty(exports, "AccountCreationPendingError", {
+	enumerable: true,
+	get: function() {
+		return AccountCreationPendingError;
+	}
+});
+Object.defineProperty(exports, "AccountExistsError", {
+	enumerable: true,
+	get: function() {
+		return AccountExistsError;
+	}
+});
+Object.defineProperty(exports, "AccountNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return AccountNotFoundError;
+	}
+});
+Object.defineProperty(exports, "ArtefactIntegrityError", {
+	enumerable: true,
+	get: function() {
+		return ArtefactIntegrityError;
+	}
+});
+Object.defineProperty(exports, "AuthorityNotRetiredError", {
+	enumerable: true,
+	get: function() {
+		return AuthorityNotRetiredError;
+	}
+});
+Object.defineProperty(exports, "AuthorityRetiredError", {
+	enumerable: true,
+	get: function() {
+		return AuthorityRetiredError;
+	}
+});
+Object.defineProperty(exports, "CeremonyCancelledError", {
+	enumerable: true,
+	get: function() {
+		return CeremonyCancelledError;
+	}
+});
+Object.defineProperty(exports, "CreationArtefactMismatchError", {
+	enumerable: true,
+	get: function() {
+		return CreationArtefactMismatchError;
+	}
+});
+Object.defineProperty(exports, "CreationLockMismatchError", {
+	enumerable: true,
+	get: function() {
+		return CreationLockMismatchError;
+	}
+});
+Object.defineProperty(exports, "DeviceEntryNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return DeviceEntryNotFoundError;
+	}
+});
+Object.defineProperty(exports, "DeviceReaderInvalidError", {
+	enumerable: true,
+	get: function() {
+		return DeviceReaderInvalidError;
+	}
+});
+Object.defineProperty(exports, "DeviceRosterInvalidError", {
+	enumerable: true,
+	get: function() {
+		return DeviceRosterInvalidError;
+	}
+});
+Object.defineProperty(exports, "EncryptionKeyMismatchError", {
+	enumerable: true,
+	get: function() {
+		return EncryptionKeyMismatchError;
+	}
+});
+Object.defineProperty(exports, "GrantIssueRejectedError", {
+	enumerable: true,
+	get: function() {
+		return GrantIssueRejectedError;
+	}
+});
+Object.defineProperty(exports, "GrantLimitReachedError", {
+	enumerable: true,
+	get: function() {
+		return GrantLimitReachedError;
+	}
+});
+Object.defineProperty(exports, "GrantNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return GrantNotFoundError;
+	}
+});
+Object.defineProperty(exports, "GrantOpeningUnavailableError", {
+	enumerable: true,
+	get: function() {
+		return GrantOpeningUnavailableError;
+	}
+});
+Object.defineProperty(exports, "GrantOriginMissingError", {
+	enumerable: true,
+	get: function() {
+		return GrantOriginMissingError;
+	}
+});
+Object.defineProperty(exports, "GrantRevocationPendingError", {
+	enumerable: true,
+	get: function() {
+		return GrantRevocationPendingError;
+	}
+});
+Object.defineProperty(exports, "GrantRevokedError", {
+	enumerable: true,
+	get: function() {
+		return GrantRevokedError;
+	}
+});
+Object.defineProperty(exports, "GrantRosterUnsettledError", {
+	enumerable: true,
+	get: function() {
+		return GrantRosterUnsettledError;
+	}
+});
+Object.defineProperty(exports, "GrantScopeInvalidError", {
+	enumerable: true,
+	get: function() {
+		return GrantScopeInvalidError;
+	}
+});
+Object.defineProperty(exports, "GrantSpendRefusedError", {
+	enumerable: true,
+	get: function() {
+		return GrantSpendRefusedError;
+	}
+});
+Object.defineProperty(exports, "LastDeviceError", {
+	enumerable: true,
+	get: function() {
+		return LastDeviceError;
+	}
+});
+Object.defineProperty(exports, "MaintenanceAuthorityMismatchError", {
+	enumerable: true,
+	get: function() {
+		return MaintenanceAuthorityMismatchError;
+	}
+});
+Object.defineProperty(exports, "MaintenanceUpdateRefusedError", {
+	enumerable: true,
+	get: function() {
+		return MaintenanceUpdateRefusedError;
+	}
+});
+Object.defineProperty(exports, "NoAccountError", {
+	enumerable: true,
+	get: function() {
+		return NoAccountError;
+	}
+});
+Object.defineProperty(exports, "NotAuthorisedError", {
+	enumerable: true,
+	get: function() {
+		return NotAuthorisedError;
+	}
+});
+Object.defineProperty(exports, "OperationNotInstallableError", {
+	enumerable: true,
+	get: function() {
+		return OperationNotInstallableError;
+	}
+});
+Object.defineProperty(exports, "PrfUnsupportedError", {
+	enumerable: true,
+	get: function() {
+		return PrfUnsupportedError;
+	}
+});
+Object.defineProperty(exports, "ReadUnavailableError", {
+	enumerable: true,
+	get: function() {
+		return ReadUnavailableError;
+	}
+});
+Object.defineProperty(exports, "RecordCorruptedError", {
+	enumerable: true,
+	get: function() {
+		return RecordCorruptedError;
+	}
+});
+Object.defineProperty(exports, "RecordUnreadableError", {
+	enumerable: true,
+	get: function() {
+		return RecordUnreadableError;
+	}
+});
+Object.defineProperty(exports, "RemovalTargetNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return RemovalTargetNotFoundError;
+	}
+});
+Object.defineProperty(exports, "SponsorExhaustedError", {
+	enumerable: true,
+	get: function() {
+		return SponsorExhaustedError;
+	}
+});
+Object.defineProperty(exports, "sha256", {
+	enumerable: true,
+	get: function() {
+		return sha256;
+	}
+});