@parity/product-sdk-contracts 0.5.0 → 0.6.0

package/dist/pvm.d.ts

@@ -1,4 +1,4 @@
-import { A as AbiEntry } from './types-BdHp-xWt.js';
+import { A as AbiEntry } from './types-Bh0tqK9s.js';
 import 'polkadot-api';
 import '@parity/product-sdk-tx';
 import '@parity/product-sdk-signer';

package/dist/types-Bh0tqK9s.d.ts

@@ -0,0 +1,435 @@
+import { HexString, SS58String, PolkadotClient, PolkadotSigner } from 'polkadot-api';
+import { Weight, SubmittableTransaction, TxResult, SubmitOptions, BatchableCall } from '@parity/product-sdk-tx';
+import { SignerManager } from '@parity/product-sdk-signer';
+
+/**
+ * Result of a `Revive.call` extrinsic — present on the typed API as
+ * `api.tx.Revive.call(args)`. Returned object is a PAPI submittable that
+ * `submitAndWatch` consumes natively.
+ *
+ * `dest` is an H160 hex string and `data` is a raw `Uint8Array`: this matches
+ * what `polkadot-api` ≥2.0 codecs accept and produce. The class-based
+ * `Binary` / `FixedSizeBinary` wrappers from `@polkadot-api/substrate-bindings`
+ * 0.12 are *not* accepted by PAPI 2.x's compatibility check.
+ */
+type ReviveCallTx = (args: {
+    dest: HexString;
+    value: bigint;
+    weight_limit: Weight;
+    storage_deposit_limit: bigint;
+    data: Uint8Array;
+}) => SubmittableTransaction;
+/**
+ * Dry-run result returned by `ReviveApi.call`. Mirrors the shape exposed by
+ * descriptors (`paseo-asset-hub`, `polkadot-asset-hub`, `kusama-asset-hub`).
+ *
+ * `data` is a raw `Uint8Array` because PAPI ≥2.0 dropped the `Binary` class
+ * wrapper for `Vec<u8>` codecs.
+ */
+interface ReviveDryRunResult {
+    weight_consumed: Weight;
+    weight_required: Weight;
+    storage_deposit: {
+        type: "Refund" | "Charge";
+        value: bigint;
+    };
+    max_storage_deposit: {
+        type: "Refund" | "Charge";
+        value: bigint;
+    };
+    gas_consumed: bigint;
+    /**
+     * `success: true` carries `{ flags, data }`; `success: false` carries the
+     * dispatch error as the chain encoded it.
+     */
+    result: {
+        success: true;
+        value: {
+            flags: number;
+            data: Uint8Array;
+        };
+    } | {
+        success: false;
+        value: unknown;
+    };
+}
+/**
+ * Block reference used to target `ReviveApi.call` dry-runs. Matches PAPI's
+ * runtime-call `at` option: `"best"`, `"finalized"`, or a block hash.
+ */
+type ContractDryRunAt = "best" | "finalized" | HexString;
+/**
+ * Per-call options accepted by {@link ReviveDryRunCall}.
+ *
+ * Note on the trailing `options` arg: pallet-revive's Rust runtime API
+ * `ReviveApi::call` only takes the 6 positional args (origin, dest, value,
+ * gas_limit, storage_deposit_limit, input_data). This 7th `options` object
+ * is **injected by PAPI** on every `api.apis.X.Y` runtime-API call via its
+ * `WithCallOptions` type wrapper (see
+ * `polkadot-api/packages/client/src/viewFns.ts:9-11` upstream — defined
+ * as `WithCallOptions$2` in the bundled `.d.ts` due to TS bundler suffixing).
+ * It never reaches the Rust side — PAPI's `viewFns.ts:38-41` consumes it in
+ * JS, reads `options.at`, resolves it to a concrete block hash via the
+ * chain-head's runtime context, and uses that hash on the JSON-RPC
+ * `state_call` invocation. The 6-arg payload sent over the wire is
+ * unchanged.
+ */
+interface ReviveDryRunCallOptions {
+    at?: ContractDryRunAt;
+}
+/** Structural shape consumed by `ContractManager` / `createContract`. */
+interface ReviveTypedApi {
+    tx: {
+        Revive: {
+            call: ReviveCallTx;
+            map_account(): SubmittableTransaction;
+        };
+    };
+    query: {
+        Revive: {
+            OriginalAccount: {
+                getValue(address: HexString): Promise<SS58String | undefined>;
+            };
+        };
+    };
+    apis: {
+        ReviveApi: {
+            call(origin: SS58String, dest: HexString, value: bigint, gas_limit: Weight | undefined, storage_deposit_limit: bigint | undefined, input_data: Uint8Array, options?: ReviveDryRunCallOptions): Promise<ReviveDryRunResult>;
+        };
+    };
+}
+/**
+ * Signature of a `ReviveApi.call` dry-run, used by the wrapped contract layer
+ * to estimate weight + storage deposit and surface revert / OOG /
+ * `AccountNotMapped` failures before a tx is signed.
+ *
+ * Identical to `ReviveTypedApi.apis.ReviveApi.call`, but extracted so the
+ * runtime can route this single hot call through PAPI's *unsafe* API
+ * (skipping compatibility-token checks) on production runtimes whose
+ * descriptors lag a chain upgrade — every other surface still uses the
+ * compat-checked typed API.
+ */
+type ReviveDryRunCall = (origin: SS58String, dest: HexString, value: bigint, gas_limit: Weight | undefined, storage_deposit_limit: bigint | undefined, input_data: Uint8Array, options?: ReviveDryRunCallOptions) => Promise<ReviveDryRunResult>;
+/**
+ * Runtime handle that drives queries and transactions against a
+ * pallet-revive-capable chain.
+ *
+ * @example
+ * ```ts
+ * import { createChainClient } from "@parity/product-sdk-chain-client";
+ * import { paseo_asset_hub } from "@parity/product-sdk-descriptors/paseo-asset-hub";
+ * import { createContractRuntimeFromClient } from "@parity/product-sdk-contracts";
+ *
+ * const client = await createChainClient({
+ *     chains: { assetHub: paseo_asset_hub },
+ *     rpcs: { assetHub: ["wss://paseo-asset-hub-next-rpc.polkadot.io"] },
+ * });
+ * const runtime = createContractRuntimeFromClient(client.raw.assetHub, paseo_asset_hub);
+ * ```
+ */
+interface ContractRuntime {
+    readonly api: ReviveTypedApi;
+    /**
+     * Dry-run entry point. Production factories route this through the
+     * *unsafe* API to avoid compatibility-token failures when the descriptor
+     * trails a runtime upgrade. The {@link createContractRuntime} test factory
+     * delegates to `api.apis.ReviveApi.call`.
+     *
+     * The runtime default `at` (set via {@link ContractRuntimeOptions.at} on
+     * the factory) is applied when the caller does not pass an explicit
+     * `options.at`. `.query()` per-call overrides flow through this argument.
+     */
+    readonly dryRunCall: ReviveDryRunCall;
+}
+/** Options for {@link createContractRuntime} / {@link createContractRuntimeFromClient}. */
+interface ContractRuntimeOptions {
+    /**
+     * Block to target for `ReviveApi.call` dry-runs. Defaults to `"best"`
+     * so contract `.query()` reads observe the same state as transactions
+     * resolved at best-block (the product-sdk `.tx()` default). Set to
+     * `"finalized"` to read the canonical, lagged state, or to a specific
+     * block hash to pin reads to a historical block. Can be overridden per
+     * call via `QueryOptions.at`.
+     */
+    at?: ContractDryRunAt;
+}
+/**
+ * Wrap a typed PAPI API as a `ContractRuntime`. Intended for tests and
+ * advanced setups where the caller already holds a typed API. Routes the
+ * dry-run through the typed (compatibility-token-checked) `ReviveApi.call`
+ * — fine for mocks but susceptible to `Incompatible runtime entry` errors
+ * on a live chain whose descriptor lags. Prefer
+ * {@link createContractRuntimeFromClient} for production use.
+ */
+declare function createContractRuntime(api: ReviveTypedApi, options?: ContractRuntimeOptions): ContractRuntime;
+/**
+ * Build a `ContractRuntime` from a raw `PolkadotClient` plus its descriptor.
+ *
+ * The typed API powers `tx.Revive.call`, `tx.Revive.map_account`, and
+ * `query.Revive.OriginalAccount` (extrinsics + storage are tolerant of
+ * descriptor drift). The runtime-API dry-run, which is *not* tolerant of
+ * descriptor drift on PAPI's compat-token path, is routed through
+ * `client.getUnsafeApi()` — bypassing the compat check while preserving
+ * argument and return shapes.
+ *
+ * Use this on every production code path that calls a contract's `.tx()` or
+ * `.query()` against a live chain.
+ *
+ * @example
+ * ```ts
+ * import { paseo_asset_hub } from "@parity/product-sdk-descriptors/paseo-asset-hub";
+ * import { createContractRuntimeFromClient } from "@parity/product-sdk-contracts";
+ *
+ * const runtime = createContractRuntimeFromClient(rawClient, paseo_asset_hub);
+ * ```
+ */
+declare function createContractRuntimeFromClient<TDescriptor>(client: PolkadotClient, descriptor: TDescriptor, options?: ContractRuntimeOptions): ContractRuntime;
+/**
+ * Ensure the SS58 account is mapped to its derived H160 on `pallet-revive`.
+ *
+ * `pallet-revive` requires every signing account to have a registered
+ * `OriginalAccount` mapping before the runtime accepts its `Revive.call`
+ * extrinsics. The mapping is one-time and cheap. This helper:
+ *
+ *   1. Reads `Revive.OriginalAccount` for the H160 derived from `address`.
+ *   2. Returns `null` if already mapped (idempotent fast-path).
+ *   3. Otherwise submits `Revive.map_account()` and waits for inclusion.
+ *
+ * Call this once per signing account at app startup — after that, every
+ * subsequent `contract.<method>.tx({ signer })` against the same chain will
+ * succeed without further mapping work.
+ *
+ * @param runtime - The contract runtime (typically `createContractRuntime(...)`).
+ * @param address - The SS58 address of the account to map.
+ * @param signer - A signer matching `address`.
+ * @param options - Optional timeout / status callback (forwarded to the underlying tx).
+ * @returns The `TxResult` from the mapping extrinsic, or `null` if already mapped.
+ *
+ * @example
+ * ```ts
+ * import { createContractRuntime, ensureContractAccountMapped } from "@parity/product-sdk-contracts";
+ *
+ * const runtime = createContractRuntime(client.getTypedApi(paseo_asset_hub));
+ * await ensureContractAccountMapped(runtime, signerManager.getState().selectedAccount!.address, signer);
+ * // now safe to call contract.<method>.tx({ signer })
+ * ```
+ */
+declare function ensureContractAccountMapped(runtime: ContractRuntime, address: SS58String, signer: PolkadotSigner, options?: {
+    timeoutMs?: number;
+    onStatus?: (s: string) => void;
+}): Promise<TxResult | null>;
+
+/** Pins a target to specific asset-hub and Bulletin chain hashes in `cdm.json`. */
+interface CdmJsonTarget {
+    "asset-hub": string;
+    bulletin: string;
+}
+/**
+ * A deployed contract's on-chain address, ABI, and optional metadata CID.
+ *
+ * `metadataCid` is optional because real-world cdm.json files (e.g.
+ * `paritytech/playground-cli/cdm.json`) don't always include it — only
+ * `version`, `address`, and `abi` are load-bearing for `getContract()`.
+ */
+interface CdmJsonContract {
+    version: number;
+    address: HexString;
+    abi: AbiEntry[];
+    metadataCid?: string;
+}
+/** A project's `cdm.json` manifest: declared targets, runtime dependencies, and per-target contract deployments. */
+interface CdmJson {
+    targets: Record<string, CdmJsonTarget>;
+    dependencies: Record<string, Record<string, number | string>>;
+    contracts?: Record<string, Record<string, CdmJsonContract>>;
+}
+/** An ABI parameter or return value, with support for nested tuple and struct types. */
+interface AbiParam {
+    name: string;
+    type: string;
+    components?: AbiParam[];
+}
+/** One function, constructor, or event in a contract's ABI. */
+interface AbiEntry {
+    type: string;
+    name?: string;
+    inputs: AbiParam[];
+    outputs?: AbiParam[];
+    stateMutability?: string;
+}
+/** Per-contract definition shape — generated into `.cdm/contracts.d.ts` via module augmentation. */
+interface ContractDef {
+    methods: Record<string, {
+        args: any[];
+        response: any;
+    }>;
+}
+/**
+ * Augmentable interface extended by codegen with per-contract method types.
+ *
+ * After running `cdm install`, a generated `.d.ts` file augments this
+ * interface so that `ContractManager.getContract()` returns fully-typed
+ * contract handles.
+ */
+interface Contracts {
+}
+/**
+ * Result from a read-only contract query.
+ *
+ * On success, `value` is the decoded response and `gasRequired` is the
+ * `Weight` consumed by `ReviveApi.call`'s dry-run — consumable directly by
+ * `Revive.call`'s `weight_limit` parameter.
+ *
+ * On failure, `value` carries the raw dispatch-error payload the runtime
+ * returned (typically a tagged enum like `{ type: "Module", value: ... }`,
+ * `{ type: "ContractReverted" }`, or `{ type: "AccountNotMapped" }` — see the
+ * `Revive` pallet error variants). Surfacing it lets callers narrow on shape
+ * to diagnose silent failures instead of seeing `undefined` and being unable
+ * to tell whether the contract reverted, gas estimation failed, or the
+ * dry-run never ran. `gasRequired` is still populated when the runtime
+ * reported a weight even though the call ultimately failed (e.g. a revert
+ * after partial execution); it's optional because some failure modes don't
+ * carry one.
+ */
+type QueryResult<T> = {
+    success: true;
+    value: T;
+    gasRequired: Weight;
+} | {
+    success: false;
+    value: unknown;
+    gasRequired?: Weight;
+};
+/** Options for query calls — passed as the last argument after positional args. */
+interface QueryOptions {
+    origin?: SS58String;
+    value?: bigint;
+    /**
+     * Override the block targeted by this dry-run. Accepts `"best"`,
+     * `"finalized"`, or a block hash. Defaults to the runtime's configured
+     * `at` (see `createContractRuntimeFromClient({ at })`), which is `"best"`
+     * unless overridden — chosen so `.query()` observes the same state as
+     * `.tx()` resolved at best-block.
+     */
+    at?: ContractDryRunAt;
+}
+/** Options for transaction calls — passed as the last argument after positional args. */
+interface TxOptions extends SubmitOptions {
+    signer?: PolkadotSigner;
+    origin?: SS58String;
+    value?: bigint;
+    gasLimit?: Weight;
+    storageDepositLimit?: bigint;
+    /**
+     * Override the block targeted by the sizing dry-run that `.tx()` runs
+     * before submission. Accepts `"best"`, `"finalized"`, or a block hash.
+     * Defaults to the runtime's configured `at` (see
+     * `createContractRuntimeFromClient({ at })`), which is `"best"` unless
+     * overridden. No-op when both `gasLimit` and `storageDepositLimit` are
+     * passed — the dry-run is skipped entirely in that case.
+     */
+    at?: ContractDryRunAt;
+}
+/**
+ * Options for `.prepare()` — subset of {@link TxOptions}.
+ *
+ * Signer and submission lifecycle options (`signer`, `waitFor`, `timeoutMs`,
+ * `mortalityPeriod`, `onStatus`) are intentionally absent — those belong to
+ * the batch submission, not the individual prepared call.
+ */
+interface PrepareOptions {
+    origin?: SS58String;
+    value?: bigint;
+    gasLimit?: Weight;
+    storageDepositLimit?: bigint;
+    /**
+     * Override the block targeted by the sizing dry-run. See
+     * {@link TxOptions.at}.
+     */
+    at?: ContractDryRunAt;
+}
+/** Mutable defaults shared across all contract handles from a manager. */
+interface ContractDefaults {
+    origin?: SS58String;
+    signer?: PolkadotSigner;
+    signerManager?: SignerManager;
+}
+/**
+ * Options for {@link createContract} and base for {@link ContractManagerOptions}.
+ *
+ * Signer resolution order (highest wins):
+ * 1. Explicit override in call options
+ * 2. `signerManager` (current logged-in account)
+ * 3. Static `defaultSigner` / `defaultOrigin`
+ */
+interface ContractOptions {
+    /**
+     * Signer manager from `@parity/product-sdk-signer`. When provided, the
+     * currently selected account is used as the default signer and origin
+     * for all contract interactions. Resolved at call time so account
+     * switches are reflected immediately.
+     */
+    signerManager?: SignerManager;
+    /** Static fallback caller address for queries. */
+    defaultOrigin?: SS58String;
+    /** Static fallback signer for transactions. */
+    defaultSigner?: PolkadotSigner;
+}
+/** Options for {@link ContractManager} construction. */
+interface ContractManagerOptions extends ContractOptions {
+    /** Explicit target hash to select from cdm.json. Defaults to the first target. */
+    targetHash?: string;
+}
+/**
+ * A typed contract handle where each ABI method exposes `.query()` and `.tx()`.
+ *
+ * Both accept the method's positional arguments followed by an optional
+ * options object as the last argument.
+ */
+type Contract<C extends ContractDef> = {
+    [K in keyof C["methods"]]: {
+        /**
+         * Dry-run the method (read-only). Does not submit a transaction or
+         * cost gas. Returns the decoded response and estimated gas required.
+         *
+         * Origin is resolved from: explicit `{ origin }` option → signerManager →
+         * defaultOrigin → dev fallback (Alice).
+         */
+        query: (...args: [...C["methods"][K]["args"], opts?: QueryOptions]) => Promise<QueryResult<C["methods"][K]["response"]>>;
+        /**
+         * Sign, submit, and watch the method as an on-chain transaction.
+         * Resolves at best-block by default (configurable via `waitFor`).
+         *
+         * Signer is resolved from: explicit `{ signer }` option → signerManager →
+         * defaultSigner. Throws {@link ContractSignerMissingError} if none available.
+         */
+        tx: (...args: [...C["methods"][K]["args"], opts?: TxOptions]) => Promise<TxResult>;
+        /**
+         * Prepare the method as a {@link BatchableCall} — returns the same
+         * submittable that `.tx()` would build, but without signing or
+         * submitting. Consumable directly by `batchSubmitAndWatch` from
+         * `@parity/product-sdk-tx`:
+         *
+         * ```ts
+         * import { batchSubmitAndWatch } from "@parity/product-sdk-tx";
+         *
+         * const a = contract.transfer.prepare(addr1, 100n);
+         * const b = contract.transfer.prepare(addr2, 200n);
+         * await batchSubmitAndWatch([a, b], api, signer);
+         * ```
+         *
+         * Sizing: when either `gasLimit` or `storageDepositLimit` is
+         * omitted, `.prepare()` runs a `ReviveApi.call` dry-run (same as
+         * `.tx()`) against the dev fallback origin to fill the missing
+         * field(s) — pass both to skip the dry-run entirely. A failing
+         * dry-run throws {@link ContractDryRunFailedError} before the
+         * call is constructed.
+         *
+         * `.prepare()` does not require a signer; the batch's signer
+         * replaces the dispatched origin at submission.
+         */
+        prepare: (...args: [...C["methods"][K]["args"], opts?: PrepareOptions]) => Promise<BatchableCall>;
+    };
+};
+
+export { type AbiEntry as A, type CdmJson as C, type PrepareOptions as P, type QueryOptions as Q, type ReviveDryRunCall as R, type TxOptions as T, type ContractRuntime as a, type ContractManagerOptions as b, type ContractDefaults as c, type ContractRuntimeOptions as d, type Contracts as e, type Contract as f, type ContractDef as g, type ContractOptions as h, type AbiParam as i, type CdmJsonContract as j, type CdmJsonTarget as k, type ContractDryRunAt as l, type QueryResult as m, type ReviveDryRunCallOptions as n, type ReviveDryRunResult as o, type ReviveTypedApi as p, createContractRuntime as q, createContractRuntimeFromClient as r, ensureContractAccountMapped as s };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@parity/product-sdk-contracts",
   "description": "Typed contract interactions on Polkadot Asset Hub",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,10 +31,10 @@
     "polkadot-api": "^2.1.2",
     "viem": "^2.46.2",
     "@parity/product-sdk-address": "0.1.1",
-    "@parity/product-sdk-keys": "0.2.3",
+    "@parity/product-sdk-keys": "0.3.1",
     "@parity/product-sdk-logger": "0.1.1",
-    "@parity/product-sdk-signer": "0.2.4",
-    "@parity/product-sdk-tx": "0.2.3"
+    "@parity/product-sdk-signer": "0.4.0",
+    "@parity/product-sdk-tx": "0.2.5"
   },
   "devDependencies": {
     "tsup": "^8.4.0",

package/dist/types-BdHp-xWt.d.ts

@@ -1,196 +0,0 @@
-import { HexString, SS58String, PolkadotSigner } from 'polkadot-api';
-import { Weight, SubmitOptions, TxResult, BatchableCall } from '@parity/product-sdk-tx';
-import { SignerManager } from '@parity/product-sdk-signer';
-
-/** Pins a target to specific asset-hub and Bulletin chain hashes in `cdm.json`. */
-interface CdmJsonTarget {
-    "asset-hub": string;
-    bulletin: string;
-}
-/**
- * A deployed contract's on-chain address, ABI, and optional metadata CID.
- *
- * `metadataCid` is optional because real-world cdm.json files (e.g.
- * `paritytech/playground-cli/cdm.json`) don't always include it — only
- * `version`, `address`, and `abi` are load-bearing for `getContract()`.
- */
-interface CdmJsonContract {
-    version: number;
-    address: HexString;
-    abi: AbiEntry[];
-    metadataCid?: string;
-}
-/** A project's `cdm.json` manifest: declared targets, runtime dependencies, and per-target contract deployments. */
-interface CdmJson {
-    targets: Record<string, CdmJsonTarget>;
-    dependencies: Record<string, Record<string, number | string>>;
-    contracts?: Record<string, Record<string, CdmJsonContract>>;
-}
-/** An ABI parameter or return value, with support for nested tuple and struct types. */
-interface AbiParam {
-    name: string;
-    type: string;
-    components?: AbiParam[];
-}
-/** One function, constructor, or event in a contract's ABI. */
-interface AbiEntry {
-    type: string;
-    name?: string;
-    inputs: AbiParam[];
-    outputs?: AbiParam[];
-    stateMutability?: string;
-}
-/** Per-contract definition shape — generated into `.cdm/contracts.d.ts` via module augmentation. */
-interface ContractDef {
-    methods: Record<string, {
-        args: any[];
-        response: any;
-    }>;
-}
-/**
- * Augmentable interface extended by codegen with per-contract method types.
- *
- * After running `cdm install`, a generated `.d.ts` file augments this
- * interface so that `ContractManager.getContract()` returns fully-typed
- * contract handles.
- */
-interface Contracts {
-}
-/**
- * Result from a read-only contract query.
- *
- * On success, `value` is the decoded response and `gasRequired` is the
- * `Weight` consumed by `ReviveApi.call`'s dry-run — consumable directly by
- * `Revive.call`'s `weight_limit` parameter.
- *
- * On failure, `value` carries the raw dispatch-error payload the runtime
- * returned (typically a tagged enum like `{ type: "Module", value: ... }`,
- * `{ type: "ContractReverted" }`, or `{ type: "AccountNotMapped" }` — see the
- * `Revive` pallet error variants). Surfacing it lets callers narrow on shape
- * to diagnose silent failures instead of seeing `undefined` and being unable
- * to tell whether the contract reverted, gas estimation failed, or the
- * dry-run never ran. `gasRequired` is still populated when the runtime
- * reported a weight even though the call ultimately failed (e.g. a revert
- * after partial execution); it's optional because some failure modes don't
- * carry one.
- */
-type QueryResult<T> = {
-    success: true;
-    value: T;
-    gasRequired: Weight;
-} | {
-    success: false;
-    value: unknown;
-    gasRequired?: Weight;
-};
-/** Options for query calls — passed as the last argument after positional args. */
-interface QueryOptions {
-    origin?: SS58String;
-    value?: bigint;
-}
-/** Options for transaction calls — passed as the last argument after positional args. */
-interface TxOptions extends SubmitOptions {
-    signer?: PolkadotSigner;
-    origin?: SS58String;
-    value?: bigint;
-    gasLimit?: Weight;
-    storageDepositLimit?: bigint;
-}
-/**
- * Options for `.prepare()` — subset of {@link TxOptions}.
- *
- * Signer and submission lifecycle options (`signer`, `waitFor`, `timeoutMs`,
- * `mortalityPeriod`, `onStatus`) are intentionally absent — those belong to
- * the batch submission, not the individual prepared call.
- */
-interface PrepareOptions {
-    origin?: SS58String;
-    value?: bigint;
-    gasLimit?: Weight;
-    storageDepositLimit?: bigint;
-}
-/** Mutable defaults shared across all contract handles from a manager. */
-interface ContractDefaults {
-    origin?: SS58String;
-    signer?: PolkadotSigner;
-    signerManager?: SignerManager;
-}
-/**
- * Options for {@link createContract} and base for {@link ContractManagerOptions}.
- *
- * Signer resolution order (highest wins):
- * 1. Explicit override in call options
- * 2. `signerManager` (current logged-in account)
- * 3. Static `defaultSigner` / `defaultOrigin`
- */
-interface ContractOptions {
-    /**
-     * Signer manager from `@parity/product-sdk-signer`. When provided, the
-     * currently selected account is used as the default signer and origin
-     * for all contract interactions. Resolved at call time so account
-     * switches are reflected immediately.
-     */
-    signerManager?: SignerManager;
-    /** Static fallback caller address for queries. */
-    defaultOrigin?: SS58String;
-    /** Static fallback signer for transactions. */
-    defaultSigner?: PolkadotSigner;
-}
-/** Options for {@link ContractManager} construction. */
-interface ContractManagerOptions extends ContractOptions {
-    /** Explicit target hash to select from cdm.json. Defaults to the first target. */
-    targetHash?: string;
-}
-/**
- * A typed contract handle where each ABI method exposes `.query()` and `.tx()`.
- *
- * Both accept the method's positional arguments followed by an optional
- * options object as the last argument.
- */
-type Contract<C extends ContractDef> = {
-    [K in keyof C["methods"]]: {
-        /**
-         * Dry-run the method (read-only). Does not submit a transaction or
-         * cost gas. Returns the decoded response and estimated gas required.
-         *
-         * Origin is resolved from: explicit `{ origin }` option → signerManager →
-         * defaultOrigin → dev fallback (Alice).
-         */
-        query: (...args: [...C["methods"][K]["args"], opts?: QueryOptions]) => Promise<QueryResult<C["methods"][K]["response"]>>;
-        /**
-         * Sign, submit, and watch the method as an on-chain transaction.
-         * Resolves at best-block by default (configurable via `waitFor`).
-         *
-         * Signer is resolved from: explicit `{ signer }` option → signerManager →
-         * defaultSigner. Throws {@link ContractSignerMissingError} if none available.
-         */
-        tx: (...args: [...C["methods"][K]["args"], opts?: TxOptions]) => Promise<TxResult>;
-        /**
-         * Prepare the method as a {@link BatchableCall} — returns the same
-         * submittable that `.tx()` would build, but without signing or
-         * submitting. Consumable directly by `batchSubmitAndWatch` from
-         * `@parity/product-sdk-tx`:
-         *
-         * ```ts
-         * import { batchSubmitAndWatch } from "@parity/product-sdk-tx";
-         *
-         * const a = contract.transfer.prepare(addr1, 100n);
-         * const b = contract.transfer.prepare(addr2, 200n);
-         * await batchSubmitAndWatch([a, b], api, signer);
-         * ```
-         *
-         * Sizing: when either `gasLimit` or `storageDepositLimit` is
-         * omitted, `.prepare()` runs a `ReviveApi.call` dry-run (same as
-         * `.tx()`) against the dev fallback origin to fill the missing
-         * field(s) — pass both to skip the dry-run entirely. A failing
-         * dry-run throws {@link ContractDryRunFailedError} before the
-         * call is constructed.
-         *
-         * `.prepare()` does not require a signer; the batch's signer
-         * replaces the dispatched origin at submission.
-         */
-        prepare: (...args: [...C["methods"][K]["args"], opts?: PrepareOptions]) => Promise<BatchableCall>;
-    };
-};
-
-export type { AbiEntry as A, CdmJson as C, PrepareOptions as P, QueryOptions as Q, TxOptions as T, ContractManagerOptions as a, ContractDefaults as b, Contracts as c, Contract as d, ContractDef as e, ContractOptions as f, AbiParam as g, CdmJsonContract as h, CdmJsonTarget as i, QueryResult as j };