@parity/product-sdk-contracts 0.8.2 → 0.9.0

package/dist/codegen.d.ts

@@ -1,7 +1,9 @@
-import { A as AbiEntry } from './types-pkS1R9Bk.js';
-import 'polkadot-api';
-import '@parity/product-sdk-tx';
+import { A as AbiEntry } from './types-BKcrGoiN.js';
+import '@parity/result';
 import '@parity/product-sdk-signer';
+import '@parity/product-sdk-tx';
+import 'polkadot-api';
+import '@parity/product-sdk-errors';
 
 /** A contract input to {@link generateContractTypes}: either an inline ABI or a `cargo-pvm-contract` artefact path. */
 type ContractTypeInput = {

package/dist/index.d.ts

@@ -1,18 +1,25 @@
+import { Result } from '@parity/result';
 import { PolkadotClient, HexString, SS58String } from 'polkadot-api';
-import { C as CdmJson, a as ContractRuntime, b as ContractManagerOptions, c as ContractDefaults, d as ContractRuntimeOptions, L as LiveContractResolutionOptions, e as Contracts, f as Contract, g as ContractDef, A as AbiEntry, h as ContractOptions } from './types-pkS1R9Bk.js';
-export { i as AbiParam, j as CdmJsonContract, k as CdmJsonDependencyVersion, l as ContractDryRunAt, P as PrepareOptions, Q as QueryOptions, m as QueryResult, R as ReviveDryRunCall, n as ReviveDryRunCallOptions, o as ReviveDryRunResult, p as ReviveTypedApi, T as TxOptions, q as createContractRuntime, r as createContractRuntimeFromClient, s as ensureContractAccountMapped } from './types-pkS1R9Bk.js';
+import { C as CdmJson, a as ContractRuntime, b as ContractManagerOptions, c as ContractDefaults, d as ContractRuntimeOptions, L as LiveContractResolutionOptions, e as ContractError, f as Contracts, g as Contract, h as ContractDef, A as AbiEntry, i as ContractOptions } from './types-BKcrGoiN.js';
+export { j as AbiParam, k as CdmJsonContract, l as CdmJsonDependencyVersion, m as ContractDryRunAt, n as ContractDryRunFailedError, o as ContractLiveAddressResolutionError, p as ContractNotFoundError, q as ContractRevertInfo, r as ContractRevertedError, s as ContractSignerMissingError, D as DecodedContractRevert, P as PrepareOptions, Q as QueryOptions, t as QueryResult, R as ReviveDryRunCall, u as ReviveDryRunCallOptions, v as ReviveDryRunResult, w as ReviveTypedApi, T as TxOptions, x as createContractRuntime, y as createContractRuntimeFromClient, z as ensureContractAccountMapped } from './types-BKcrGoiN.js';
 export { BatchableCall, TxResult } from '@parity/product-sdk-tx';
 import '@parity/product-sdk-signer';
+import '@parity/product-sdk-errors';
 
 /**
  * Return a cloned manifest whose installed contract addresses have been
  * replaced by live addresses from the CDM registry.
  *
- * This is intentionally strict: if a requested library cannot be resolved
- * from the registry, the promise rejects. Use `new ContractManager(...)` or
+ * This is intentionally strict: if a requested library cannot be resolved from
+ * the registry, the result is `err`. Use `new ContractManager(...)` or
  * `ContractManager.fromClient(...)` directly for snapshot-only behavior.
+ *
+ * @returns A {@link Result}: `ok(CdmJson)` with live addresses patched in, or
+ *   `err(ContractError)` — a `ContractLiveAddressResolutionError` (missing
+ *   contracts, no registry, or a lookup that failed / returned nothing) or a
+ *   `ContractNotFoundError` (a requested library isn't installed).
  */
-declare function withLiveContractAddresses(cdmJson: CdmJson, runtime: ContractRuntime, options?: LiveContractResolutionOptions): Promise<CdmJson>;
+declare function withLiveContractAddresses(cdmJson: CdmJson, runtime: ContractRuntime, options?: LiveContractResolutionOptions): Promise<Result<CdmJson, ContractError>>;
 /**
  * Manages typed contract interactions backed by a `cdm.json` manifest.
  *
@@ -65,12 +72,12 @@ declare class ContractManager {
      * Create a manager after strictly resolving installed contract addresses
      * from the live CDM registry. ABIs still come from the installed manifest.
      */
-    static fromLive(cdmJson: CdmJson, runtime: ContractRuntime, options?: ContractManagerOptions & LiveContractResolutionOptions): Promise<ContractManager>;
+    static fromLive(cdmJson: CdmJson, runtime: ContractRuntime, options?: ContractManagerOptions & LiveContractResolutionOptions): Promise<Result<ContractManager, ContractError>>;
     /**
      * Convenience factory for {@link fromLive} when the caller has a raw
      * `PolkadotClient` and descriptor.
      */
-    static fromLiveClient<TDescriptor>(cdmJson: CdmJson, client: PolkadotClient, descriptor: TDescriptor, options?: ContractManagerOptions & ContractRuntimeOptions & LiveContractResolutionOptions): Promise<ContractManager>;
+    static fromLiveClient<TDescriptor>(cdmJson: CdmJson, client: PolkadotClient, descriptor: TDescriptor, options?: ContractManagerOptions & ContractRuntimeOptions & LiveContractResolutionOptions): Promise<Result<ContractManager, ContractError>>;
     private getContractData;
     /**
      * Get a typed contract handle.
@@ -125,70 +132,4 @@ declare function createContractFromClient<TDescriptor>(client: PolkadotClient, d
 
 declare const QUERY_FALLBACK_ORIGIN: SS58String;
 
-/** Base class for all contract errors. Use `instanceof ContractError` to catch any contract-related error. */
-declare class ContractError extends Error {
-    constructor(message: string, options?: ErrorOptions);
-}
-/** No signer was available for a transaction call. */
-declare class ContractSignerMissingError extends ContractError {
-    constructor();
-}
-/** A contract was not found in the cdm.json manifest. */
-declare class ContractNotFoundError extends ContractError {
-    readonly library: string;
-    constructor(library: string);
-}
-/** Live CDM registry address resolution failed. */
-declare class ContractLiveAddressResolutionError extends ContractError {
-    readonly library: string | undefined;
-    readonly detail: unknown;
-    constructor(message: string, options?: {
-        library?: string;
-        detail?: unknown;
-        cause?: unknown;
-    });
-}
-/**
- * A pre-flight `ReviveApi.call` dry-run reported failure. Thrown from the `.tx()`
- * path before the extrinsic is built — prevents callers from paying gas on a
- * transaction the chain already told us would revert.
- *
- * `dispatchError` carries the chain's encoded error (typically `ModuleError`,
- * `ContractReverted`, `OutOfGas`, or `AccountNotMapped` — see the `Revive`
- * pallet error variants).
- */
-declare class ContractDryRunFailedError extends ContractError {
-    readonly methodName: string;
-    readonly dispatchError: unknown;
-    constructor(methodName: string, dispatchError: unknown);
-}
-/** viem-decoded standard or ABI-defined contract error. */
-interface DecodedContractRevert {
-    errorName: string;
-    args: readonly unknown[] | undefined;
-}
-/**
- * Tagged-enum value surfaced on `QueryResult.value` when a contract reverts
- * via the REVERT flag. The discriminant is intentionally distinct from
- * `pallet-revive`'s bare `{ type: "ContractReverted" }` dispatch-error variant,
- * which is the other path that can populate `QueryResult.value` on failure.
- */
-interface ContractRevertInfo {
-    type: "ContractRevertedWithPayload";
-    data: HexString;
-    reason?: string;
-    decoded?: DecodedContractRevert;
-}
-/** A contract call returned with the `REVERT` flag set on a dispatched-OK call. */
-declare class ContractRevertedError extends ContractError {
-    readonly methodName: string;
-    readonly data: HexString;
-    readonly reason?: string;
-    readonly decoded?: DecodedContractRevert;
-    constructor(methodName: string, data: HexString, info?: {
-        reason?: string;
-        decoded?: DecodedContractRevert;
-    });
-}
-
-export { AbiEntry, CdmJson, Contract, ContractDef, ContractDefaults, ContractDryRunFailedError, ContractError, ContractLiveAddressResolutionError, ContractManager, ContractManagerOptions, ContractNotFoundError, ContractOptions, type ContractRevertInfo, ContractRevertedError, ContractRuntime, ContractRuntimeOptions, ContractSignerMissingError, Contracts, type DecodedContractRevert, LiveContractResolutionOptions, QUERY_FALLBACK_ORIGIN, createContract, createContractFromClient, withLiveContractAddresses };
+export { AbiEntry, CdmJson, Contract, ContractDef, ContractDefaults, ContractError, ContractManager, ContractManagerOptions, ContractOptions, ContractRuntime, ContractRuntimeOptions, Contracts, LiveContractResolutionOptions, QUERY_FALLBACK_ORIGIN, createContract, createContractFromClient, withLiveContractAddresses };

package/dist/index.js

@@ -1,13 +1,16 @@
-import { encodeFunctionData, bytesToHex, decodeErrorResult, decodeFunctionResult } from 'viem';
-import { ensureAccountMapped, submitAndWatch } from '@parity/product-sdk-tx';
+import { ok, err } from '@parity/result';
 import { createLogger } from '@parity/product-sdk-logger';
+import { ensureAccountMapped, submitAndWatch } from '@parity/product-sdk-tx';
 import { ss58Address } from '@polkadot-labs/hdkd-helpers';
+import { encodeFunctionData, bytesToHex, decodeErrorResult, decodeFunctionResult } from 'viem';
 import { ss58ToH160 } from '@parity/product-sdk-address';
 
-// src/wrap.ts
+// src/manager.ts
 
 // src/errors.ts
 var ContractError = class extends Error {
+  isSdkError = true;
+  source = "contracts";
   constructor(message, options) {
     super(message, options);
     this.name = "ContractError";
@@ -72,8 +75,6 @@ var ContractRevertedError = class extends ContractError {
     this.decoded = info?.decoded;
   }
 };
-
-// src/wrap.ts
 var log = createLogger("contracts");
 function buildMethodArgMap(abi) {
   const map = {};
@@ -207,25 +208,27 @@ async function buildReviveCall(runtime, dest, abi, methodName, positionalArgs, o
       overrides?.at !== void 0 ? { at: overrides.at } : void 0
     );
     if (!dryRun.result.success) {
-      throw new ContractDryRunFailedError(methodName, dryRun.result.value);
+      return err(new ContractDryRunFailedError(methodName, dryRun.result.value));
     }
     if ((dryRun.result.value.flags & REVERT_FLAG) !== 0) {
       const { data, reason, decoded } = decodeRevert(abi, dryRun.result.value.data);
       log.debug("Contract reverted", { methodName, reason, errorName: decoded?.errorName });
-      throw new ContractRevertedError(methodName, data, { reason, decoded });
+      return err(new ContractRevertedError(methodName, data, { reason, decoded }));
     }
     weightLimit = weightLimit ?? dryRun.weight_required;
     if (storageDepositLimit === void 0) {
       storageDepositLimit = dryRun.storage_deposit.type === "Charge" ? dryRun.storage_deposit.value : 0n;
     }
   }
-  return runtime.api.tx.Revive.call({
-    dest,
-    value,
-    weight_limit: weightLimit,
-    storage_deposit_limit: storageDepositLimit,
-    data: calldata
-  });
+  return ok(
+    runtime.api.tx.Revive.call({
+      dest,
+      value,
+      weight_limit: weightLimit,
+      storage_deposit_limit: storageDepositLimit,
+      data: calldata
+    })
+  );
 }
 function wrapContract(runtime, address, abi, defaults) {
   const methodArgs = buildMethodArgMap(abi);
@@ -287,10 +290,10 @@ function wrapContract(runtime, address, abi, defaults) {
           );
           const signer = resolveSigner(defaults, overrides?.signer);
           if (!signer) {
-            throw new ContractSignerMissingError();
+            return err(new ContractSignerMissingError());
           }
           const origin = resolveOrigin(defaults, overrides?.origin) ?? ss58Address(signer.publicKey);
-          const tx = await buildReviveCall(
+          const built = await buildReviveCall(
             runtime,
             dest,
             abi,
@@ -299,7 +302,8 @@ function wrapContract(runtime, address, abi, defaults) {
             origin,
             overrides
           );
-          return submitAndWatch(tx, signer, {
+          if (!built.ok) return built;
+          return submitAndWatch(built.value, signer, {
             waitFor: overrides?.waitFor,
             timeoutMs: overrides?.timeoutMs,
             mortalityPeriod: overrides?.mortalityPeriod,
@@ -450,33 +454,44 @@ async function queryLiveAddress(registry, library, version) {
   return value.value;
 }
 async function withLiveContractAddresses(cdmJson, runtime, options) {
-  const contracts = cdmJson.contracts;
-  if (!contracts || Object.keys(contracts).length === 0) {
-    throw new ContractLiveAddressResolutionError(
-      "No installed contracts found in cdm.json for live address resolution."
+  try {
+    const contracts = cdmJson.contracts;
+    if (!contracts || Object.keys(contracts).length === 0) {
+      throw new ContractLiveAddressResolutionError(
+        "No installed contracts found in cdm.json for live address resolution."
+      );
+    }
+    const libraries = options?.libraries ?? Object.keys(contracts);
+    for (const library of libraries) {
+      if (!(library in contracts)) {
+        throw new ContractNotFoundError(library);
+      }
+    }
+    const registryAddress = resolveRegistryAddress(cdmJson, options?.registryAddress);
+    const registry = createContract(runtime, registryAddress, CDM_REGISTRY_ABI, {
+      defaultOrigin: options?.registryOrigin
+    });
+    const liveAddresses = await Promise.all(
+      libraries.map(async (library) => {
+        const version = resolveLiveVersionSpec(cdmJson, library, contracts[library]);
+        return [library, await queryLiveAddress(registry, library, version)];
+      })
     );
-  }
-  const libraries = options?.libraries ?? Object.keys(contracts);
-  for (const library of libraries) {
-    if (!(library in contracts)) {
-      throw new ContractNotFoundError(library);
+    const resolved = cloneCdmJson(cdmJson);
+    for (const [library, address] of liveAddresses) {
+      patchContractAddress(resolved, library, address);
     }
+    return ok(resolved);
+  } catch (cause) {
+    if (cause instanceof ContractError) return err(cause);
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return err(
+      new ContractLiveAddressResolutionError(
+        `Live contract address resolution failed: ${message}`,
+        { cause }
+      )
+    );
   }
-  const registryAddress = resolveRegistryAddress(cdmJson, options?.registryAddress);
-  const registry = createContract(runtime, registryAddress, CDM_REGISTRY_ABI, {
-    defaultOrigin: options?.registryOrigin
-  });
-  const liveAddresses = await Promise.all(
-    libraries.map(async (library) => {
-      const version = resolveLiveVersionSpec(cdmJson, library, contracts[library]);
-      return [library, await queryLiveAddress(registry, library, version)];
-    })
-  );
-  const resolved = cloneCdmJson(cdmJson);
-  for (const [library, address] of liveAddresses) {
-    patchContractAddress(resolved, library, address);
-  }
-  return resolved;
 }
 var ContractManager = class _ContractManager {
   contracts;
@@ -527,7 +542,8 @@ var ContractManager = class _ContractManager {
       ...options,
       registryOrigin: options?.registryOrigin ?? options?.defaultOrigin
     });
-    return new _ContractManager(resolved, runtime, options);
+    if (!resolved.ok) return resolved;
+    return ok(new _ContractManager(resolved.value, runtime, options));
   }
   /**
    * Convenience factory for {@link fromLive} when the caller has a raw