@avow-finance/verifier 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,113 @@
-# Temporary Holding Version
+# @avow-finance/verifier
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lets a supplier check an Avow commitment before it grants capacity, accept it and report a charge on it, without calling Avow. It reads the signed authorization, the buyer's signed mandate, the supplier's own record of what it agreed to and the chain, and nothing else.
+
+> **Status:** pre-release and testnet only. `tempoChainReader` reads the lock and the keychain on Tempo, and `MemoryChain` stands in for the chain in tests.
+
+## What it checks
+
+`verifySupplierAuthorization` refuses with the first reason code that applies, in this order.
+
+1. The envelope names a message type, that type's version and a chain this code reads. The authorization hasn't expired, stays valid for no more than five minutes, and one of Avow's published keys signed it.
+2. It's for the commitment the supplier agreed to, with the terms hash the supplier signed. KYB marked as test data passes only where the supplier allows it, and only on a testnet.
+3. The supplier's terms hold nothing the terms hash leaves out, and they and the salt produce that terms hash. The terms are version 2 under a template this code knows, or version 1 for a commitment made under it. Version 3 terms are refused here, since this check doesn't read the bookings they rely on. The reserve equals the largest charge, the contest window meets the supplier's profile, and the terms name an arbiter and a day-90 share from 0 to 10,000.
+4. The token is one the supplier accepts for the terms' currency, the amount and deadlines match what the terms map to, the payee is the supplier's own payout address, and the acceptance deadline hasn't passed.
+5. On the chain, the lock comes from Avow's factory and holds a reserve for this commitment that nobody has accepted yet and that matches the authorization. Every value the lock stores and enforces is what `lockTerms` maps the supplier's terms to, and the agent's key or the account's root key funded the reserve.
+6. The agent's key is active, lasts until the release date, and carries the mandate hash Avow named, in the transaction the authorization points to.
+7. When the supplier passes the buyer's signed mandate, the mandate hashes to that value, the buyer's account signed it in Tempo's keychain envelope, and its own limits allow this reserve.
+8. The commitment hasn't passed this check before. That's recorded only after every other check passes.
+
+It throws, rather than refusing, when the setup is wrong, such as a chain reader for another chain or test data on a chain that isn't a testnet.
+
+## Accepting
+
+An acceptance binds the supplier to everything in Avow's approval, so a supplier gets one to sign only from `prepareAcceptance`, and signs it only with `signAcceptance`. `prepareAcceptance` refuses with the first reason that applies.
+
+1. Avow's authorization passes every check above, with the buyer's signed mandate required. It names the buyer and the mandate the supplier's own terms agreement names, and the mandate is that buyer's. A mandate that's forged, expired, revoked with its agent key, or that doesn't allow this supplier, category, currency, token or amount refuses.
+2. Avow's approval names the commitment the supplier agreed to, the supplier's own account, signing key and payout, and the token. Every field the lock enforces is what `lockTerms` maps the supplier's own terms to, the mapping Avow's API signs with, under the terms hash the supplier agreed to.
+3. It names the mandate the authorization names, that mandate's two caps, and a funding key that's the mandate's agent key or the account's root key and that funded the reserve.
+4. The lock stores the digest of exactly this approval and the same terms, and its token and dispute timing are the ones the supplier's profile accepts.
+
+Then it builds the acceptance, which names the lock's digest of the approval and expires within ten minutes, and a disclosure for the person who approves the signature. The disclosure states the reserve and what each charge can take and from when, who receives charges, the free-cancellation and acceptance deadlines, the charge deadline and the release date, and the dispute terms: Avow's confirmation window, the contest window, how long Avow's ruling key and then the arbiter can rule, when a ruling takes effect, and the supplier's day-90 share. `signAcceptance` takes the disclosure's id back, so nothing is signed until an integration has fetched the disclosure and the person has confirmed it. It signs only the frozen object `prepareAcceptance` returned, so a copy or an edit throws, and it refuses a key other than the signing key the approval names.
+
+## Bookings a booking relies on
+
+`verifyDependencies` checks the bookings version 3 terms rely on, `prepareAcceptance` runs it before anything else reads those terms, and [Checking dependencies](../../fern/docs/pages/dependency-check.mdx) says what both check and what they leave unchecked.
+
+## Release consents
+
+A release consent gives the reserve back to the business, and the lock takes it only while the commitment's report count equals the count it names. It gives up the supplier's charge, a reported or confirmed one included. Nothing caps how long a consent lasts, so its disclosure states the exact expiry and how long that is from when it was prepared. `prepareReleaseConsent` reads the commitment from the lock and refuses another supplier's commitment, one the lock wouldn't release on consent, a consent that has expired, and a count the commitment has passed or can never reach. A consent for a later count than the commitment has becomes valid once reports reach it. That's preauthorization, so its disclosure says so, and `signReleaseConsent` refuses to sign it without `preauthorize: true` as well as the disclosure's id. Like `signAcceptance`, it signs only the frozen object its prepare call returned. The consent is signed by the supplier account's root key or an admin key, in Tempo's keychain envelope, and the signature is checked against the chain before it's returned.
+
+## Reports
+
+A report asks the lock to charge the business's reserve, so a supplier gets one to sign only from `prepareReport`, and signs it only with `signReport`. `prepareReport` refuses a kind, commitment id, evidence hash or amount it can't read with `message.invalid`. Then it reads the commitment from the lock and refuses with the first reason that applies.
+
+1. The lock comes from Avow's factory (`chain.lock_unknown`) and holds the commitment (`chain.reserve_missing`) with this supplier's signing key (`chain.supplier_mismatch`).
+2. The commitment is accepted (`report.not_reportable`), no report on it is open (`report.open`), and it has fewer than two reports (`report.limit_reached`).
+3. Its terms carry a charge of the reported kind (`report.kind_not_allowed`), and the amount is above zero and within that charge's most, which is the amount when the supplier names none (`report.amount_invalid`).
+4. The time is at or after that charge's earliest (`report.too_early`) and before the charge deadline (`commitment.ended`). The lock judges both by the chain's clock, so a supplier passes the latest block's time.
+
+Then it builds the report, which expires within ten minutes and never past the charge deadline, and a disclosure for the person who approves the signature. The disclosure states the charge and who it pays, how long Avow has to confirm or refer it, that the rest of the reserve goes back to the business once Avow answers, the contest window, the day-90 share and which of the commitment's two reports this is. The prepared report carries that number as `reportNumber`, and a supplier that keeps it can tell from the lock's report count whether the report landed, even once it's withdrawn. `signReport` takes the disclosure's id back, signs only the frozen object `prepareReport` returned, and refuses a key other than the signing key the lock holds. `reportCall` hands the signed report to the lock with exactly the fields the signature covers, which it takes from the spec's `REPORT_TYPES`. Anyone can send it, so a supplier pays the fee from whichever account it likes.
+
+## References and payments
+
+`verifyCommitmentReference` checks that a commitment reference names a lock Avow's factory created and that the lock holds that commitment under the reference's terms hash. `verifyCommitmentTerms` goes further for anyone holding the terms and salt. The terms have to give that hash, the reference has to name the side the terms' backing secures, and the lock's token has to be one the caller accepts for the terms' currency. The lock then has to enforce exactly what the terms map to, in that token's units. It reads version 1 and version 2 terms, so a commitment made under version 1 stays checkable without Avow.
+
+`verifyPaymentReference` checks a settled payment against the chain. A reference names its own token and any contract can emit an event shaped like a token's, so the caller passes the tokens it accepts, and a reference to any other token is refused before the chain is read. The Tempo reader reads the finalized block, then the receipt and the log at the reference's index. It counts the transaction as final only when its block is at or below the finalized one and is the chain's block at that height, so a receipt from a block that lost a reorg never counts. The check passes only when the transaction succeeded and is final and the log is the TIP-20 `TransferWithMemo` event that token emitted, with exactly the reference's sender, recipient, amount and memo. A plain transfer without a memo, the same event from a contract that isn't a TIP-20 token, and anything read from calldata don't count. A payment is evidence that money moved, and nothing here treats it as backing. A live test sends a payment with a memo on Moderato and checks it end to end.
+
+## Contests
+
+`readBacking` reads a commitment's contest state with the rest of the lock's record. It gives whether the business has contested, the latest report's kind and amount, when a confirmed charge became pending and when the charge paused. `contestInLogs` finds a contest of one side of a commitment among a transaction's logs, from the `Paused` event the lock itself logged with a contest as its cause, and returns the reason code, the statement hash and the pause time. Any contract can log an event shaped like it, so a log from another address counts for nothing. `ChainReader.contest` reads the same from a transaction's receipt on the chain, with the contest's block, whether that block is final as `verifyPaymentReference` judges a payment's, and the report the contest named, read from the lock as of that block. It finds nothing in a transaction that failed or isn't on the chain, and throws when the node can't answer, so an outage never reads as a missing contest. A test decodes the `Paused` log a demo lock on Moderato wrote for a contest.
+
+## What this doesn't protect
+
+These checks are an application-level gate. They protect a supplier that signs only what `prepareAcceptance`, `prepareReleaseConsent` and `prepareReport` return. The lock checks a signature and a digest, so it takes a correctly signed acceptance, consent or report however it was built, and a supplier whose signing tool skips this library gets none of these checks.
+
+The checks also rest on things the verifier doesn't prove.
+
+- **The node.** Everything read from the chain comes through the node the reader talks to, so a supplier reads through a node it chose.
+- **The pinned factory.** A lock counts as Avow's only when the factory the supplier configured says it created it.
+- **Avow's signature.** The authorization stands for the business's KYB, for a person's approval when the mandate asks for one, and for any revocation Avow recorded off the chain.
+- **The supplier's own records.** The terms, the agreed commitment and the supplier's account, key and payout come from the supplier, so a wrong record checks the wrong terms.
+- **The mandate's contents.** The supplier sees the buyer's whole mandate, including its other suppliers, categories and caps.
+- **The lock after the read.** The prepare calls read the lock once. Before an acceptance lands, the reserve can still go back to the business, and the lock then refuses the acceptance, so a supplier grants capacity only once the acceptance's receipt shows it landed.
+- **The person.** The disclosure is only as good as the screen that shows it. The library can make an integration fetch it, but it can't make a person read it, and code that holds the signing key can always sign without this library.
+
+## Use
+
+```ts
+import { TESTNET_DEMO_PROFILE } from '@avow-finance/spec'
+import { prepareAcceptance, signAcceptance, tempoChainReader } from '@avow-finance/verifier'
+
+const chain = tempoChainReader(client, { factory: AVOW_FACTORY })
+const config = {
+  chainId: 42431,
+  avowKeys: [AVOW_AUTHORIZATION_KEY],
+  businessId: MY_BUSINESS_ID,
+  payee: MY_PAYOUT_ADDRESS,
+  account: MY_ACCOUNT,
+  signingKey: MY_SIGNING_KEY_ADDRESS,
+  acceptedTokens: [MY_TOKEN],
+  profile: TESTNET_DEMO_PROFILE,
+  acceptTestData: true,
+}
+// From the terms agreement this supplier signed for the booking.
+const agreed = { commitmentId, termsHash, category: 'compute', buyerBusinessId, mandateHash }
+const now = BigInt(Math.floor(Date.now() / 1000))
+
+const prepared = await prepareAcceptance(
+  { authorization, approval, mandate, agreed, terms, now },
+  { config, chain },
+)
+if (!prepared.ok) throw new Error(prepared.reason)
+
+// Show every section of prepared.disclosure, and sign only once the person confirms it.
+const acceptance = await signAcceptance(prepared, signingKey, {
+  disclosureId: prepared.disclosure.id,
+})
+// Send the acceptance to the lock, wait for the transaction's receipt, then grant the capacity.
+```
+
+Accept on the lock before granting anything. Until acceptance lands, the reserve can still go back to the buyer, for example when the buyer revokes the agent or the acceptance deadline passes. Even after it lands, the business can take the whole reserve back until the free-cancellation deadline.
+
+`verifySupplierAuthorization` passes each commitment once, so a supplier that uses it keeps the first successful result, and keeps its replay guard in a database so a restart doesn't forget which commitments have passed. `prepareAcceptance` records nothing, since the lock takes one acceptance per reserve.

package/dist/accept.d.ts

@@ -0,0 +1,170 @@
+import { type Acceptance, type AnyTerms, type AvowDomain, type ChainedTerms, type HashSigner, type ReasonCode, type Signed } from '@avow-finance/spec';
+import { type Address, type Hex } from 'viem';
+import { type Agreed } from './authorization.js';
+import type { ChainReader } from './chain.js';
+import { type CheckedDependency, type DependencyDeps, type DependencyRefusal } from './dependency.js';
+import { type Disclosure } from './disclosure.js';
+import type { VerifierConfig } from './verify.js';
+/** An acceptance stays valid for ten minutes at most, and never past the acceptance deadline. */
+export declare const ACCEPTANCE_VALIDITY = 600n;
+export interface AcceptanceConfig extends VerifierConfig {
+    /** The supplier's account on the rail, which Avow's approval must name. */
+    account: Address;
+    /** The supplier's signing key, which signs the acceptance and which the approval must name. */
+    signingKey: Address;
+}
+export interface AcceptanceDeps {
+    config: AcceptanceConfig;
+    chain: ChainReader;
+    /**
+     * The chain and factory pairs whose locks a booking relied on may sit in, each with its reader.
+     * Version 3 terms are refused with `dependency.lock_unknown` when this is left out.
+     */
+    dependencies?: DependencyDeps;
+}
+/** What a supplier hands the verifier to get an acceptance to sign. */
+export interface AcceptanceRequest {
+    /** Avow's signed supplier authorization for the commitment, as JSON. */
+    authorization: unknown;
+    /** Avow's signed approval that the reserve carried to the lock, as JSON. */
+    approval: unknown;
+    /** The buyer's signed mandate, as JSON. The acceptance path refuses without it. */
+    mandate: unknown;
+    /**
+     * The commitment the supplier agreed to, from the terms agreement it signed, with the buyer
+     * and the buyer's mandate that agreement names.
+     */
+    agreed: Required<Agreed>;
+    /**
+     * The terms this supplier agreed to for the booking, from its own records. Version 2, version 3
+     * in full for a booking that relies on the supplier's own bookings, or version 1 for a commitment
+     * made under it.
+     */
+    terms: AnyTerms | ChainedTerms;
+    /**
+     * For version 3 terms, the section of each booking they rely on that the supplier shows whoever
+     * checks it, as JSON, in the terms' order.
+     */
+    disclosed?: readonly unknown[];
+    now: bigint;
+    /** The acceptance's nonce, a fresh random one when left out. */
+    nonce?: bigint;
+}
+export interface ReadyAcceptance {
+    ok: true;
+    acceptance: Acceptance;
+    domain: AvowDomain;
+    /** The digest the supplier's signing key signs. */
+    digest: Hex;
+    /** The digest of Avow's approval, which the lock stored and the acceptance names. */
+    approvalDigest: Hex;
+    /** The key that has to sign, the supplier's own signing key. */
+    signingKey: Address;
+    /** What to show the person who approves the signature, before signing. */
+    disclosure: Disclosure;
+    /**
+     * Each booking version 3 terms rely on, with the block it was read at. Empty for a booking that
+     * relies on none.
+     */
+    dependencies: readonly CheckedDependency[];
+}
+/**
+ * The acceptance, or why it was refused. A refusal by the check of a booking relied on says which
+ * one failed and the block it was read at.
+ */
+export type PreparedAcceptance = ReadyAcceptance | {
+    ok: false;
+    reason: ReasonCode;
+} | DependencyRefusal;
+/**
+ * The supported way for a supplier to get an acceptance to sign. An acceptance binds the supplier
+ * to everything in Avow's approval, so this builds one only after every check passes, and refuses
+ * with the first reason that applies.
+ *
+ * 0. For version 3 terms, every booking they rely on passes `verifyDependencies` first, with the
+ *    account Avow's approval names as supplier as the one whose lock has to hold it. That holds
+ *    whoever the terms say checks for the buyer, since the supplier has the terms in full. Nothing
+ *    below reads them before, and the checks below confirm the lock holds exactly that approval.
+ * 1. Avow's authorization passes every check `verifySupplierAuthorization` makes, with the buyer's
+ *    signed mandate required, so a mandate that's forged, expired, revoked with its agent key, or
+ *    that doesn't allow this supplier, category, currency, token or amount refuses.
+ * 2. Avow's approval names the commitment the supplier agreed to, the supplier's own account,
+ *    signing key and payout, and the token, amount, deadlines, contest window, terms hash, charges,
+ *    day-90 share and arbiter of the supplier's own terms.
+ * 3. It names the mandate Avow's authorization names, that mandate's two caps, and a funding key
+ *    that's the mandate's agent key or the account's root key and that funded the reserve.
+ * 4. The lock stores the digest of exactly this approval and the same terms, and its token and
+ *    dispute timing are the ones the supplier's profile accepts.
+ *
+ * It records nothing, since the lock takes one acceptance per reserve. What it returns is frozen,
+ * and `signAcceptance` signs nothing else. The checks protect a supplier who signs only through
+ * these two calls. The lock checks the signature and the digest, so it takes a correctly signed
+ * acceptance however it was built.
+ *
+ * Throws when the setup is wrong or the chain can't be read, as `verifySupplierAuthorization` does.
+ */
+export declare function prepareAcceptance(request: AcceptanceRequest, deps: AcceptanceDeps): Promise<PreparedAcceptance>;
+/**
+ * Signs an acceptance with the supplier's signing key, once the person has seen its disclosure. It
+ * signs only the object `prepareAcceptance` returned, which is frozen, so a copy or an edit of it
+ * throws. It also throws when the confirmation names another disclosure, or when the key isn't
+ * the signing key Avow's approval names.
+ */
+export declare function signAcceptance(prepared: ReadyAcceptance, key: HashSigner, confirmation: {
+    disclosureId: Hex;
+}): Promise<Signed<Acceptance>>;
+/**
+ * The lock's `accept`, as the testnet lock declares it. Anyone can send it, since the lock checks
+ * the supplier's signing key signed the acceptance, so a supplier can send it from any account
+ * that pays the fee.
+ */
+export declare const ACCEPT_ABI: readonly [{
+    readonly type: 'function';
+    readonly name: 'accept';
+    readonly inputs: readonly [{
+        readonly name: 'm';
+        readonly type: 'tuple';
+        readonly components: readonly [{
+            readonly name: 'commitmentId';
+            readonly type: 'bytes32';
+        }, {
+            readonly name: 'side';
+            readonly type: 'uint8';
+        }, {
+            readonly name: 'approvalHash';
+            readonly type: 'bytes32';
+        }, {
+            readonly name: 'termsHash';
+            readonly type: 'bytes32';
+        }, {
+            readonly name: 'amount';
+            readonly type: 'uint256';
+        }, {
+            readonly name: 'token';
+            readonly type: 'address';
+        }, {
+            readonly name: 'acceptBy';
+            readonly type: 'uint64';
+        }, {
+            readonly name: 'nonce';
+            readonly type: 'uint256';
+        }, {
+            readonly name: 'expiry';
+            readonly type: 'uint64';
+        }];
+    }, {
+        readonly name: 'signature';
+        readonly type: 'bytes';
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: 'nonpayable';
+}];
+/**
+ * The call that hands a signed acceptance to its lock, with the fields exactly as they were signed,
+ * so the lock checks the same digest the supplier's key signed.
+ */
+export declare function acceptCall(acceptance: Signed<Acceptance>): {
+    to: Address;
+    data: Hex;
+};
+//# sourceMappingURL=accept.d.ts.map

package/dist/accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../src/accept.ts"],"names":[],"mappings":"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"}