@trusset/sdk 0.1.0 → 0.5.0

package/README.md

@@ -1,8 +1,12 @@
 # @trusset/sdk
 
-TypeScript SDK for the Trusset tokenization infrastructure API. Built for financial institutions, banks, and fintechs integrating MiCA/eWpG-compliant tokenized asset management.
+TypeScript SDK for the Trusset API, built for banks, exchanges and fintechs that integrate tokenized securities. It ships three modules:
 
-Zero dependencies. Works in Node.js 18+ and modern runtimes with native `fetch`.
+- `customers`: customer records, on-chain identity verification and claims, KYC links, verification profiles, database sync.
+- `lending`: external securities lending (markets, the lender of record, loans, liquidations, vaults, whitelists, bots, hooks, asset data).
+- `tokens`: importing an existing security token and publishing its profile and instrument record, which a lending market needs.
+
+The SDK has no runtime dependencies and runs on Node.js 22 or later. It is non-custodial: Trusset never holds, asks for or uses a private key. Every on-chain write is signed by a wallet you control, and you can pass any ethers v5 `Signer` or sign the returned calldata somewhere else entirely.
 
 ## Setup
 
@@ -10,237 +14,237 @@ Zero dependencies. Works in Node.js 18+ and modern runtimes with native `fetch`.
 npm install @trusset/sdk
 ```
 
-Requires an API key from your Trusset instance dashboard. Each API key is scoped to a single instance (isolated environment with its own data, contracts, and network config).
+Each API key belongs to one instance. Development instances run on Sepolia, production instances on Ethereum mainnet, and lending also runs on Polygon for production instances that use it. The backend picks the network from the key; the SDK never chooses one.
 
 ```ts
 import { TrussetClient } from '@trusset/sdk'
 
-const trusset = new TrussetClient({
-  apiKey: 'tsk_live_...',
-  // baseUrl defaults to https://api.trusset.org
-})
+const trusset = new TrussetClient({ apiKey: process.env.TRUSSET_API_KEY! })
 ```
 
-## Modules
+## How writes are signed
 
-The SDK currently ships the `customers` module. Tokenization, trading, and lending modules will follow.
+Every write that changes chain state has two legs: the API returns unsigned calldata, your wallet signs and broadcasts it, and a confirm call posts the transaction hash so the backend verifies the mined receipt and records it. Each write method covers both legs in one of three ways.
 
-### customers.manage - CRUD and search
+Call it with its input alone to get the unsigned transaction or plan. Nothing is signed and nothing is recorded.
 
 ```ts
-// Create a customer (with or without a wallet)
-const customer = await trusset.customers.manage.create({
-  name: 'Acme GmbH',
-  country: 'DE',
-  investorType: 'PROFESSIONAL',
-  externalId: 'your-internal-id-123',
+const prepared = await trusset.lending.loans.open(marketId, {
+  collateralAmount: '1000',
+  borrowAmount: '500',
+  borrowerAddress: '0x7451D81d7C1639c14B041Ba65e11378146d19a86',
 })
+```
 
-// The customer gets a referenceKey if no wallet was provided.
-// Link a wallet later:
-await trusset.customers.manage.linkWallet({
-  referenceKey: customer.referenceKey!,
-  walletAddress: '0x...',
-})
+Pass `{ signer }` and the SDK signs every step in order, waits for each to mine on the signer's own provider, confirms with the hash of the step the API names, and returns the recorded result together with every transaction it sent.
 
-// Search
-const byName = await trusset.customers.manage.searchByName('Acme')
-const byWallet = await trusset.customers.manage.searchByWallet('0x...')
-const byExtId = await trusset.customers.manage.searchByExternalId('your-internal-id-123')
+```ts
+import { Wallet, providers } from 'ethers'
 
-// List with pagination
-const page = await trusset.customers.manage.list({ limit: 50, offset: 0, search: 'bank' })
+const borrower = new Wallet(process.env.BORROWER_KEY!, new providers.JsonRpcProvider(process.env.RPC_URL))
+const loan = await trusset.lending.loans.open(marketId, { collateralAmount: '1000', borrowAmount: '500' }, { signer: borrower })
+console.log(loan.loanId, loan.transactions)
+```
 
-// Update
-await trusset.customers.manage.update(customer.id, { country: 'AT' })
+Pass `{ txHash }` to confirm a transaction you broadcast yourself, for example from a hardware wallet, an MPC system, a Safe or another smart-contract wallet. Send the hash of the mined outer transaction; the API resolves Safe, ERC-4337 and EIP-7702 calls.
 
-// Archive
-await trusset.customers.manage.archive(customer.id)
+```ts
+const recorded = await trusset.lending.loans.open(marketId, {}, { txHash: '0x9f2c41d8b7e05a3164c2870fbd935e1a4c7802db6135ea9048f7c21b5d3ea41b' })
 ```
 
-### customers.identity - On-chain KYC
-
-All write operations require a configured relayer wallet on the instance. The relayer signs transactions against the IdentityRegistry contract (UUPS upgradeable, MiCA/eWpG compliant).
+What the SDK guarantees when it signs:
+
+- It reads the instance's chain from the API and refuses a signer connected to another chain before it sends any request.
+- It forwards `to`, `data`, `value`, `chainId` and the API's `gasLimit` exactly. Where the API sends no `gasLimit` and the signer can estimate, it sets the limit to 1.5 times the signer's own estimate. It adds nothing else.
+- It runs plan steps strictly in order. An optional trailing step, such as clearing a leftover allowance after a full repayment, never blocks the confirm; its outcome is reported in `transactions`.
+- A field that names the signing wallet (`payer`, `borrowerAddress`, `provider`, `holderAddress`, `signerAddress`, `fromAddress`, `bidder`) is filled from the signer when omitted and refused when it names another wallet.
+- Where a write needs a role or an owner the market can report (role changes, rate settings and extensions, bot connections, auction wiring, insurance withdrawals), it reads that authority for the signer first and refuses before signing when the signer lacks it. An authority it cannot read stops the write with a `503`, never a blind signature.
+- If a step fails after an earlier one went out, or the confirm cannot be recorded, it throws `ConfirmationError` with every hash sent, so you can finish with `{ txHash }`.
+- A repayment in `mode: 'batch'` is meant for a wallet that bundles calls (`wallet_sendCalls`); the SDK refuses it with a signer and returns the plan without one.
+
+The SDK broadcasts the calldata the API returned without decoding it. If your controls require it, prepare without a signer and validate `to` and `data` in your own pinned code before signing.
+
+## Lending
+
+`trusset.lending` mirrors the API Reference groups.
+
+| Namespace | Covers |
+|---|---|
+| `markets` | Market reads, deployment, setup and wiring, upgrades with their seven-day notice, risk configuration, identity gates, guardians, price halt, pause, borrow assets |
+| `operators` | The lender-of-record queue and adoption, nominations, roles, handover, admin handover plans |
+| `assetData` | Asset data preview, attestation and acknowledgement |
+| `accessLists` | Whitelists: creation, members, managers, ownership |
+| `rates` | Rate mode, loan terms, extensions, exit liquidity, reserve ratio |
+| `terms` | Terms of use |
+| `oracle` | Price status, signing, attestations, on-chain price updates |
+| `liquidity` | Direct liquidity and vault liquidity on a market |
+| `loans` | Borrowing, collateral, repayment (sequential, permit, batch), escrow and surplus, position reads |
+| `fees` | Fee split, cashflows, sweeps, operator wallet |
+| `insurance` | The insurance fund and its withdrawal notice |
+| `liquidations` | Liquidation, the atomic sale and router settlement |
+| `auctions` | The Dutch auction venue, bids and expiry |
+| `hooks` | Risk monitors and liquidation hooks |
+| `bots` | Liquidation bots |
+| `vaults` | Vault deposits, redemptions and distributor fees |
+| `pledges` | The pledge record of a market |
+| `documents` | Legal documents of a market and its loans on the document registry |
+
+A market needs an imported collateral token with a published profile. The journey below is the one the rig suite runs end to end.
 
 ```ts
-// Verify a single identity on-chain
-const result = await trusset.customers.identity.verify({
-  walletAddress: '0x...',
-  country: 'DE',
-  investorType: 'RETAIL',
-  softExpiryDays: 365,
-  hardExpiryDays: 730,
-})
-// result.txHash, result.gasUsed
-
-// Batch verify up to 500 identities in one transaction
-await trusset.customers.identity.batchVerify([
-  { walletAddress: '0xaaa...', country: 'DE' },
-  { walletAddress: '0xbbb...', country: 'FR', investorType: 'PROFESSIONAL' },
-])
-
-// Revoke
-await trusset.customers.identity.revoke('0x...')
-
-// Get combined on-chain + off-chain status
-const status = await trusset.customers.identity.getStatus('0x...')
-// status.onChain.isVerified, status.offChain.status
-
-// Compliance check before a token transfer
-const check = await trusset.customers.identity.canTransfer({
-  from: '0xaaa...',
-  to: '0xbbb...',
-  amount: '1000000000000000000',
-  fromBalance: '5000000000000000000',
-  toBalance: '0',
-})
-// check.allowed, check.reason, check.senderStatus, check.receiverStatus
+await trusset.tokens.import({ tokenAddress: collateral, assetType: 'BOND' })
+await trusset.tokens.setProfile(collateral, { description: 'Senior bond, series A', issuerName: 'Example Issuer AG' })
+
+const deployed = await trusset.lending.markets.deploy({
+  collateralTokenAddress: collateral,
+  mode: 'CUSTODY',
+  priceSource: 'NAV',
+  initialPrice: '1',
+  candidates: [await lender.getAddress()],
+}, { signer: deployer })
+const marketId = deployed.market.id
+const marketAddress = deployed.market.marketAddress!
+
+const assetData = await trusset.lending.assetData.get(marketAddress)
+await trusset.lending.operators.accept(marketAddress, {
+  admin: lenderAddress,
+  issuer: lenderAddress,
+  collateralAgent: lenderAddress,
+  saleRecipient: lenderAddress,
+  liquidationOperator: operatorAddress,
+  oracleOwner: lenderAddress,
+  priceSigner: lenderAddress,
+  realizationMode: 'ISSUER_REDEMPTION',
+  liquidator: keeperAddress,
+  assetDataHash: assetData.attested?.contentHash,
+}, { signer: lender })
+
+await trusset.lending.oracle.sync(marketId, { price: '1' }, { signer: lender })
+await trusset.lending.liquidity.add(marketId, { amount: '100000' }, { signer: lender })
+
+const loan = await trusset.lending.loans.open(marketId, { collateralAmount: '1000', borrowAmount: '500' }, { signer: borrower })
+await trusset.lending.loans.repay(marketId, { loanId: loan.loanId!, amount: '100' }, { signer: borrower })
+await trusset.lending.loans.repay(marketId, { loanId: loan.loanId!, all: true }, { signer: payer })
 ```
 
-### customers.idLinks - KYC verification links
+Amounts are always decimal strings in the asset's own units (`'100'`, `'12.5'`). The SDK refuses JavaScript numbers for token amounts. Addresses are checked like the backend checks them: 0x plus 40 hex characters, and a valid EIP-55 checksum when mixed case.
 
-Send Sumsub-powered KYC verification links to investors via email or SMS.
+Older markets run older contract implementations. Read what a market supports from the API (`markets.upgradeStatus`, `markets.config` and its `thresholdStep`, `markets.identityGates`, `payToSupported` on market reads) instead of assuming a feature.
 
-```ts
-const link = await trusset.customers.idLinks.create({
-  recipientEmail: 'investor@example.com',
-  investorType: 'RETAIL',
-  country: 'DE',
-  expiryDays: 30,
-  sendVia: ['email'],
-})
-// link.verificationUrl, link.token
+## Tokens
 
-const links = await trusset.customers.idLinks.list({ status: 'PENDING' })
-await trusset.customers.idLinks.revoke(link.id)
-await trusset.customers.idLinks.resend(link.id, ['email'])
+```ts
+const detected = await trusset.tokens.detect({ tokenAddress })
+await trusset.tokens.import({ tokenAddress, assetType: 'BOND' })
+await trusset.tokens.setProfile(tokenAddress, { description: 'Senior bond, series A' })
+await trusset.tokens.saveInstrument(tokenAddress, { instrument: { instrumentName: 'Senior bond, series A', jurisdiction: 'Germany' } }, { signer: tokenController })
 ```
 
-### customers.sync - Database synchronization
+`saveInstrument` with `{ signer }` requests the issuer approval message from the API and signs it with the token controller's wallet; without a signer you pass `issuerApproval` yourself or rely on the instance's verified wallets.
 
-The sync module is built for institutions migrating existing customer databases into Trusset. It handles batched upserts, conflict resolution, and optional on-chain verification in a single call.
+## Customers
 
 ```ts
-import { SyncRecord } from '@trusset/sdk'
-
-// Map your existing database rows to SyncRecord
-const records: SyncRecord[] = existingCustomers.map(row => ({
-  externalId: row.id,              // Your system's unique ID
-  name: row.fullName,
-  walletAddress: row.ethAddress,   // Optional
-  country: row.countryCode,
-  investorType: 'RETAIL',
-  metadata: { source: 'legacy-crm' },
-}))
-
-const result = await trusset.customers.sync.importRecords(records, {
-  batchSize: 50,
-  onConflict: 'update',           // 'skip' or 'update'
-  verifyOnChain: true,            // Also verify wallets on IdentityRegistry
-  verificationDefaults: {
-    softExpiryDays: 365,
-    hardExpiryDays: 730,
-  },
-  onProgress: (done, total) => {
-    console.log(`Synced ${done}/${total}`)
-  },
-})
+const customer = await trusset.customers.manage.create({ name: 'Acme GmbH', country: 'DEU', customerType: 'COMPANY' })
 
-// result.created, result.updated, result.skipped, result.errors
-
-// Export back to your system
-const exported = await trusset.customers.sync.exportRecords()
+const verified = await trusset.customers.identity.verify({
+  walletAddress: '0x7451D81d7C1639c14B041Ba65e11378146d19a86',
+  country: 'DEU',
+  investorType: 'PROFESSIONAL',
+  kycHash: manifest.kycHash,
+}, { signer: issuerWallet })
 ```
 
-## Error handling
+Identity writes follow the same three call shapes as lending writes, with the same signing guarantees. KYC hashing happens in the [trusset-kyc-zk-proofs](https://github.com/Trusset/trusset-kyc-zk-proofs) tool you run locally; only the root hash and the proof manifest reach Trusset. Pass the bundle's `manifest.sig` to `addClaimsFromProof` as its raw bytes (`readFileSync(path)`); the SDK sends them base64-encoded.
+
+On an instance bound to its own ERC-3643 register, an identity write is phased: an ONCHAINID deployment for a wallet without one, claim messages signed by a claim key of the register's trusted issuer, then the claim and registration transactions. With `{ signer }` the SDK runs every phase and confirms the registration; without one it returns the current phase, which carries no single `transaction`, so check `action` before broadcasting.
+
+## Errors and retries
 
-All errors extend `TrussetError` and carry machine-readable codes.
+Every error extends `TrussetError` and carries the API's `code`, `statusCode`, `requestId`, plus `details`, `data` (any other field the API sent) and `retryAfter`.
 
 ```ts
-import { TrussetError, AuthError, ValidationError, NetworkError } from '@trusset/sdk'
+import { TrussetError, ValidationError, AuthError, ConfirmationError } from '@trusset/sdk'
 
 try {
-  await trusset.customers.manage.get('0xinvalid')
+  await trusset.lending.loans.repay(marketId, { loanId, all: true }, { signer: payer })
 } catch (err) {
-  if (err instanceof AuthError) {
-    // API key invalid or expired
-  }
-  if (err instanceof ValidationError) {
-    // Bad input, check err.message
-  }
-  if (err instanceof TrussetError) {
-    // err.code, err.statusCode, err.requestId
+  if (err instanceof ConfirmationError) {
+    console.error(err.code, err.txHash, err.transactions)
+  } else if (err instanceof ValidationError) {
+    console.error(err.message)
+  } else if (err instanceof TrussetError && err.statusCode === 503) {
+    console.error('the chain could not be read; nothing was decided', err.code)
   }
 }
 ```
 
-The HTTP layer retries transient errors (408, 429, 5xx, network failures) with exponential backoff. Default: 3 retries, 30s timeout. Override via config:
-
-```ts
-new TrussetClient({
-  apiKey: '...',
-  timeoutMs: 60_000,
-  maxRetries: 5,
-})
-```
+- Reads (GET) retry 408, 429, 500, 502, 503, 504 and network errors with exponential backoff.
+- Builds are never retried, except after a 429, which the server answers before doing any work.
+- A 429 waits for the server's `Retry-After` (up to 60 seconds) before the next attempt. Writes share a limit of 10 per minute per API key.
+- Lending confirms retry 503, 502, 504, 408 and network errors, since the backend records one transaction once. Every confirm retries `TX_NOT_FOUND` three times (3, 6 and 12 seconds) when the backend's node has not seen a receipt yet. Liquidation bot deployment is the exception and is never retried; customer identity confirms otherwise keep the build rules.
+- A 503 means the chain or a record could not be read, never a verdict.
 
 ## Configuration
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `apiKey` | `string` | required | Instance API key from dashboard |
+| `apiKey` | `string` | required | Instance API key (`trusset_...`) |
 | `baseUrl` | `string` | `https://api.trusset.org` | API base URL |
-| `timeoutMs` | `number` | `30000` | Request timeout in ms |
-| `maxRetries` | `number` | `3` | Retries on transient failures |
-| `logger` | `Logger` | silent | Custom logger implementing `debug/info/warn/error` |
+| `timeoutMs` | `number` | `30000` | Request timeout; builds and confirms use at least 60 seconds, documents 120 seconds, proof claims 180 seconds |
+| `maxRetries` | `number` | `3` | Retries for the cases listed above |
+| `logger` | `Logger` | silent | Receives the request path on retries, never a body, a signature or the key |
+
+## Imports
+
+The root export holds everything. Each module also has its own entry point.
+
+```ts
+import { TrussetClient } from '@trusset/sdk'
+import type { PreparedRepay, RepayResult } from '@trusset/sdk/lending'
+import { Tokens } from '@trusset/sdk/tokens'
+```
 
 ## Architecture
 
 ```
 src/
-  index.ts              Public exports
-  client.ts             TrussetClient entry point
-  types/
-    common.ts           Shared types (config, API envelope, pagination)
-    customers.ts        All customer-related types and interfaces
+  client.ts              TrussetClient
+  index.ts               Public exports
+  version.ts             SDK version
   modules/
-    customers/
-      index.ts          Customers facade (combines sub-modules)
-      management.ts     CRUD, search, wallet linking
-      identity.ts       On-chain verification, compliance checks
-      id-links.ts       KYC verification link management
-      sync.ts           Bulk database import/export
+    customers/           Customer records, identity, links, profiles, sync
+    lending/             Lending facade and its 18 namespaces
+    tokens/              Token import, profile and instrument record
+  types/                 Request and response types per module
   utils/
-    http.ts             HTTP client with retries and error mapping
-    errors.ts           Error class hierarchy
-    validation.ts       Input validation helpers
+    http.ts              HTTP client, envelope handling, retry classes, Retry-After
+    flow.ts              Shared signing flow: plans, chain checks, typed data, confirms
+    register.ts          Phased identity plans of own ERC-3643 registers
+    chain.ts             The instance's chain id, read once per client
+    sign.ts              Signer checks
+    validation.ts        Input validation mirroring the backend
+    keccak.ts            Keccak-256 for EIP-55 checksums
+    errors.ts            Error classes
 ```
 
-The SDK is structured so additional product modules (tokenization, trading, lending) slot in as sibling directories under `modules/`. Each module receives the shared `HttpClient` instance and exposes a clean public API.
-
-## Compatibility
-
-- **TypeScript / ESM** - primary target, full type safety
-- **Node.js / CommonJS** - dual CJS/ESM build via tsup
-- **Java / Python** - the SDK calls a standard REST API with JSON over HTTPS. Any HTTP client in any language works. Typed wrappers for Java and Python are planned.
-
-## Build
+## Build and test
 
 ```bash
 npm install
-npm run build        # outputs to dist/
-npm run typecheck    # type validation
-npm run test         # vitest
+npm run build
+npm run typecheck
+npm run lint
+npm run test:unit
+npm test
+npm run test:rig
 ```
 
-## License
-
-MIT - Trusset UG
+- `test:unit` runs without a network. Its fixtures are responses recorded verbatim from the rig or from a live run, never hand-written. The customers signing tests build the later phases of a captured own-register plan with the contract encodings the backend uses.
+- `npm test` runs the integration suites against a DEVELOPMENT instance. They need `TRUSSET_TEST_API_KEY` (see `tests/integration/env.ts`). The lending suites call every read and every build leg and sign nothing; they pace themselves on the write limit and take about 20 minutes.
+- `test:rig` runs the full write lifecycle with zero broadcast against `tests/rig/server.mjs`. That server combines a scratch Postgres on 127.0.0.1:55432, an anvil fork of Sepolia on 127.0.0.1:8545 and the real backend routers from `RIG_BACKEND_DIR`. It refuses to start with Doppler configured, with any other database or with any other RPC, and it blanks every variable named in the backend's `.env` before importing it. Point `RIG_STATE` at the file the server writes. Reset the scratch database (`prisma db push --force-reset` against 127.0.0.1:55432) whenever you restart the fork: a fresh fork reuses contract addresses that the old records still claim. `tests/rig/capture.test.ts` stops the fork when it finishes, so run it last and on its own.
+- `TRUSSET_TEST_ONCHAIN=1` enables the Sepolia identity journey and spends Sepolia gas.
 
+## License
 
-For future modules (tokenization, trading, lending) we*ll go as siblings:
-└── modules/
-        ├── customers/
-        ├── tokenization/                 # next
-        ├── trading/                      # next
-        └── lending/                      # next
+MIT, Trusset UG

package/dist/base-BYEauvBZ.d.mts

@@ -0,0 +1,111 @@
+import { S as SignedStep, e as ChainSource, H as HttpClient, b as SignOptions, C as ConfirmOptions, f as PlanOptions } from './flow-Cz8A09rn.mjs';
+
+type Decimal = string;
+type RawAmount = string;
+type UnixSeconds = string;
+type IsoDate = string;
+interface LendingTransaction {
+    to: string;
+    data: string;
+    chainId?: number;
+    value?: string;
+    gasLimit?: string;
+}
+interface LendingConfirmWith {
+    endpoint: string;
+    field: 'txHash';
+    body?: Record<string, unknown>;
+}
+interface TransactionPayload<F extends string = string> {
+    action: 'SIGN_TRANSACTION';
+    transaction: LendingTransaction;
+    functionName: F;
+    description?: string;
+}
+interface TransactionStep<F extends string = string> {
+    action: 'SIGN_TRANSACTION';
+    transaction: LendingTransaction;
+    functionName: F;
+    description?: string;
+    optional?: true;
+}
+interface StepsPayload<S = TransactionStep> {
+    action: 'SIGN_TRANSACTIONS';
+    steps: S[];
+    confirmStepIndex?: number;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+interface TypedDataDomain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+}
+interface TypedData<M extends object = Record<string, unknown>> {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    message: M;
+}
+interface SignedPrice {
+    price: string;
+    timestamp: number;
+    validUntil: number;
+    signature: string;
+}
+interface SignerDisclosure {
+    requiredSigner?: string | null;
+    heldByThisInstance?: boolean | null;
+    signerAddress?: string | null;
+    note?: string | null;
+}
+type Signed<T> = T & {
+    transactions: SignedStep[];
+};
+interface SubmittedTransactions {
+    transactions: SignedStep[];
+}
+interface LendingDocument {
+    filename: string | null;
+    contentType: string;
+    bytes: Uint8Array;
+}
+interface ApprovalStep extends TransactionStep<'approve'> {
+    stepKind?: 'approve' | 'approveZeroFirst' | 'clearAllowance';
+    approval?: {
+        token: string;
+        spender: string;
+        amount: Decimal;
+        amountRaw: RawAmount;
+    };
+}
+
+declare class InstanceChain implements ChainSource {
+    readonly http: HttpClient;
+    private chain;
+    constructor(http: HttpClient);
+    instanceChainId(): Promise<number>;
+}
+
+declare class LendingContext extends InstanceChain implements ChainSource {
+}
+interface TwoLegSpec<P, R> {
+    build: () => Promise<P>;
+    confirm: (txHash: string, prepared: P | null) => Promise<R>;
+    check?: (prepared: P, signer: string) => Promise<void>;
+    plan?: PlanOptions;
+}
+declare abstract class LendingArea {
+    protected readonly ctx: LendingContext;
+    constructor(ctx: LendingContext);
+    protected get http(): HttpClient;
+    protected twoLeg<P, R>(options: SignOptions | ConfirmOptions | undefined, spec: TwoLegSpec<P, R>): Promise<P | R | Signed<R>>;
+    protected oneLeg<P>(options: SignOptions | undefined, build: () => Promise<P>, plan?: PlanOptions): Promise<P | SubmittedTransactions>;
+    protected assertSignerRoles(marketId: string, address: string, roles: string[]): Promise<void>;
+    protected assertSignerHoldsAny(marketId: string, address: string, roles: string[]): Promise<void>;
+}
+
+export { type ApprovalStep as A, type Decimal as D, type IsoDate as I, type LendingConfirmWith as L, type RawAmount as R, type Signed as S, type TransactionPayload as T, type UnixSeconds as U, type LendingDocument as a, type LendingTransaction as b, type SignedPrice as c, type SignerDisclosure as d, type StepsPayload as e, type SubmittedTransactions as f, type TransactionStep as g, type TypedData as h, type TypedDataDomain as i, type TypedDataField as j, LendingArea as k, LendingContext as l };

package/dist/base-zODt0Kf5.d.ts

@@ -0,0 +1,111 @@
+import { S as SignedStep, e as ChainSource, H as HttpClient, b as SignOptions, C as ConfirmOptions, f as PlanOptions } from './flow-Cz8A09rn.js';
+
+type Decimal = string;
+type RawAmount = string;
+type UnixSeconds = string;
+type IsoDate = string;
+interface LendingTransaction {
+    to: string;
+    data: string;
+    chainId?: number;
+    value?: string;
+    gasLimit?: string;
+}
+interface LendingConfirmWith {
+    endpoint: string;
+    field: 'txHash';
+    body?: Record<string, unknown>;
+}
+interface TransactionPayload<F extends string = string> {
+    action: 'SIGN_TRANSACTION';
+    transaction: LendingTransaction;
+    functionName: F;
+    description?: string;
+}
+interface TransactionStep<F extends string = string> {
+    action: 'SIGN_TRANSACTION';
+    transaction: LendingTransaction;
+    functionName: F;
+    description?: string;
+    optional?: true;
+}
+interface StepsPayload<S = TransactionStep> {
+    action: 'SIGN_TRANSACTIONS';
+    steps: S[];
+    confirmStepIndex?: number;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+interface TypedDataDomain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+}
+interface TypedData<M extends object = Record<string, unknown>> {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    message: M;
+}
+interface SignedPrice {
+    price: string;
+    timestamp: number;
+    validUntil: number;
+    signature: string;
+}
+interface SignerDisclosure {
+    requiredSigner?: string | null;
+    heldByThisInstance?: boolean | null;
+    signerAddress?: string | null;
+    note?: string | null;
+}
+type Signed<T> = T & {
+    transactions: SignedStep[];
+};
+interface SubmittedTransactions {
+    transactions: SignedStep[];
+}
+interface LendingDocument {
+    filename: string | null;
+    contentType: string;
+    bytes: Uint8Array;
+}
+interface ApprovalStep extends TransactionStep<'approve'> {
+    stepKind?: 'approve' | 'approveZeroFirst' | 'clearAllowance';
+    approval?: {
+        token: string;
+        spender: string;
+        amount: Decimal;
+        amountRaw: RawAmount;
+    };
+}
+
+declare class InstanceChain implements ChainSource {
+    readonly http: HttpClient;
+    private chain;
+    constructor(http: HttpClient);
+    instanceChainId(): Promise<number>;
+}
+
+declare class LendingContext extends InstanceChain implements ChainSource {
+}
+interface TwoLegSpec<P, R> {
+    build: () => Promise<P>;
+    confirm: (txHash: string, prepared: P | null) => Promise<R>;
+    check?: (prepared: P, signer: string) => Promise<void>;
+    plan?: PlanOptions;
+}
+declare abstract class LendingArea {
+    protected readonly ctx: LendingContext;
+    constructor(ctx: LendingContext);
+    protected get http(): HttpClient;
+    protected twoLeg<P, R>(options: SignOptions | ConfirmOptions | undefined, spec: TwoLegSpec<P, R>): Promise<P | R | Signed<R>>;
+    protected oneLeg<P>(options: SignOptions | undefined, build: () => Promise<P>, plan?: PlanOptions): Promise<P | SubmittedTransactions>;
+    protected assertSignerRoles(marketId: string, address: string, roles: string[]): Promise<void>;
+    protected assertSignerHoldsAny(marketId: string, address: string, roles: string[]): Promise<void>;
+}
+
+export { type ApprovalStep as A, type Decimal as D, type IsoDate as I, type LendingConfirmWith as L, type RawAmount as R, type Signed as S, type TransactionPayload as T, type UnixSeconds as U, type LendingDocument as a, type LendingTransaction as b, type SignedPrice as c, type SignerDisclosure as d, type StepsPayload as e, type SubmittedTransactions as f, type TransactionStep as g, type TypedData as h, type TypedDataDomain as i, type TypedDataField as j, LendingArea as k, LendingContext as l };