@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/errors-DSq5wUwt.js

@@ -0,0 +1,466 @@
+import { i as sha256$1 } from "./codecs-Dc1Krpbt.js";
+import { CustomError } from "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) => sha256$1(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 CustomError {
+	code = "operation-not-installable";
+	constructor(message = "The account cannot install the operations asked for.") {
+		super(message);
+	}
+};
+//#endregion
+export { OperationNotInstallableError as A, GrantScopeInvalidError as C, MaintenanceUpdateRefusedError as D, MaintenanceAuthorityMismatchError as E, RemovalTargetNotFoundError as F, SponsorExhaustedError as I, sha256 as L, ReadUnavailableError as M, RecordCorruptedError as N, NoAccountError as O, RecordUnreadableError as P, GrantRosterUnsettledError as S, LastDeviceError as T, GrantNotFoundError as _, ArtefactIntegrityError as a, GrantRevocationPendingError as b, CeremonyCancelledError as c, DeviceEntryNotFoundError as d, DeviceReaderInvalidError as f, GrantLimitReachedError as g, GrantIssueRejectedError as h, AccountNotFoundError as i, PrfUnsupportedError as j, NotAuthorisedError as k, CreationArtefactMismatchError as l, EncryptionKeyMismatchError as m, AccountCreationPendingError as n, AuthorityNotRetiredError as o, DeviceRosterInvalidError as p, AccountExistsError as r, AuthorityRetiredError as s, AccountContractMissingError as t, CreationLockMismatchError as u, GrantOpeningUnavailableError as v, GrantSpendRefusedError as w, GrantRevokedError as x, GrantOriginMissingError as y };