@parity/product-sdk-contracts 0.6.2 → 0.7.1

package/README.md

@@ -10,7 +10,7 @@ pnpm add @parity/product-sdk-contracts
 
 ## Quick start (with cdm.json)
 
-The `cdm.json` flow is the primary path. A `cdm.json` manifest in your project root pins each contract to an address + ABI per target chain; `ContractManager.fromClient(cdm, client, descriptor)` resolves them at runtime.
+The `cdm.json` flow is the primary path. A `cdm.json` manifest in your project root pins each installed contract to an address + ABI; `ContractManager.fromClient(cdm, client, descriptor)` resolves them at runtime.
 
 ```ts
 import { createChainClient } from "@parity/product-sdk-chain-client";
@@ -21,7 +21,6 @@ import cdmJson from "./cdm.json";
 
 const client = await createChainClient({
     chains: { assetHub: paseo_asset_hub },
-    rpcs: { assetHub: ["wss://paseo-asset-hub-next-rpc.polkadot.io"] },
 });
 
 const signerManager = new SignerManager();
@@ -55,7 +54,6 @@ Synchronous factory. Builds a `ContractRuntime` internally that wires the typed
 | `options.signerManager?` | `SignerManager` | Resolves signer + origin from the logged-in account |
 | `options.defaultOrigin?` | `SS58String` | Static fallback origin for queries |
 | `options.defaultSigner?` | `PolkadotSigner` | Static fallback signer for txs |
-| `options.targetHash?` | `string` | Pin to a specific target. Defaults to first target in the manifest. |
 
 ### `manager.getContract(library)`
 
@@ -75,7 +73,7 @@ await registry.publish.tx("domain", "ipfs://cid", 0);
 //                       ^ args typed
 ```
 
-Throws `ContractNotFoundError` if the library name isn't in the manifest for the active target.
+Throws `ContractNotFoundError` if the library name isn't in the manifest.
 
 ### `manager.getAddress(library)`
 
@@ -85,6 +83,25 @@ Returns the on-chain address. Useful for logging or display.
 
 Update `origin`, `signer`, or `signerManager` after construction. Only the fields you pass are updated.
 
+### `ContractManager.fromLive(cdmJson, runtime, options?)` / `fromLiveClient(cdmJson, client, descriptor, options?)`
+
+**Async** factories. Like `fromClient`, but before constructing the manager they resolve each installed contract's address from the **live CDM registry** instead of trusting the address baked into `cdm.json`. ABIs still come from the installed snapshot — only addresses are refreshed. Dependencies requested as `"latest"` resolve the registry's latest address; pinned numeric dependencies resolve `getAddressAtVersion(...)` so the live address stays aligned with the installed ABI/version.
+
+```ts
+const manager = await ContractManager.fromLiveClient(cdmJson, client.raw.assetHub, paseo_asset_hub, {
+    signerManager,
+    // registryAddress?: HexString  — defaults to cdmJson.registry
+    // libraries?: string[]         — subset to resolve; defaults to every contract
+    // registryOrigin?: SS58String  — origin for the registry dry-run; defaults to defaultOrigin
+});
+```
+
+This path is **strict**: if `cdmJson.registry` (or `registryAddress`) is missing, or a contract isn't registered on-chain, or the registry query fails, the promise rejects with `ContractLiveAddressResolutionError` — it never silently falls back to the snapshot address. Use `fromClient` for snapshot-only behavior.
+
+### `withLiveContractAddresses(cdmJson, runtime, options?)`
+
+Standalone helper behind `fromLive`. Returns a **cloned** `cdm.json` whose contract addresses have been replaced with live registry addresses (the input is never mutated). Useful when you want the resolved manifest without immediately building a manager. Takes the same `LiveContractResolutionOptions` as `fromLive`.
+
 ## Signer / origin resolution
 
 Order, highest wins:
@@ -185,30 +202,21 @@ Top-level shape:
 
 ```jsonc
 {
-  "targets": {
-    "<targetHash>": {
-      "asset-hub": "wss://paseo-asset-hub-next-rpc.polkadot.io",
-      "bulletin": "https://paseo-bulletin-next-ipfs.polkadot.io"
-    }
-  },
+  "registry": "0xf62c2ece29cd8df2e10040ecfa5a894a5c5d9cb0",
   "dependencies": {
-    "<targetHash>": {
-      "@org/contract-name": "latest"
-    }
+    "@org/contract-name": "latest"
   },
   "contracts": {
-    "<targetHash>": {
-      "@org/contract-name": {
-        "version": 6,
-        "address": "0x4A37B123b0BA2A894cA5953f472264921d44e298",
-        "abi": [ /* Solidity-compatible ABI entries */ ]
-      }
+    "@org/contract-name": {
+      "version": 6,
+      "address": "0x4A37B123b0BA2A894cA5953f472264921d44e298",
+      "abi": [ /* Solidity-compatible ABI entries */ ]
     }
   }
 }
 ```
 
-`<targetHash>` is a 16-character hex string identifying a chain runtime + Bulletin gateway pairing. A manifest can declare multiple targets; `ContractManager` defaults to the first, or pin one via `options.targetHash`.
+`registry` is used by `ContractManager.fromLive(...)` / `withLiveContractAddresses(...)` to resolve current contract addresses from the live CDM registry. `ContractManager.fromClient(...)` uses the installed `contracts` snapshot directly.
 
 A real-world example: [`paritytech/playground-cli/cdm.json`](https://github.com/paritytech/playground-cli/blob/main/cdm.json).
 
@@ -237,8 +245,9 @@ Without codegen, `getContract()` still works — methods are accessible but unty
 
 | Error | When |
 | --- | --- |
-| `ContractNotFoundError` | `getContract(name)` and `name` isn't in the manifest for the active target |
+| `ContractNotFoundError` | `getContract(name)` and `name` isn't in the manifest |
 | `ContractSignerMissingError` | `.tx()` called with no signer + no signerManager + no defaultSigner |
+| `ContractLiveAddressResolutionError` | `fromLive(...)` / `withLiveContractAddresses(...)` couldn't resolve an address from the live CDM registry (no `registry` set, contract unregistered, or the registry query failed) |
 | `ContractDryRunFailedError` | `.tx()` pre-flight `ReviveApi.call` reported failure — `dispatchError` carries the chain's encoded error (e.g. `ContractReverted`, `OutOfGas`, `AccountNotMapped`) |
 | Generic | viem ABI decode failures, RPC errors, weight/storage-limit estimation failures — surface from the underlying PAPI typed API |
 
@@ -252,10 +261,12 @@ export {
     createContractFromClient,
     createContractRuntime,
     createContractRuntimeFromClient,
+    withLiveContractAddresses,
     ensureContractAccountMapped,
     ContractError,
     ContractSignerMissingError,
     ContractNotFoundError,
+    ContractLiveAddressResolutionError,
     ContractDryRunFailedError,
 };
 export type {
@@ -264,8 +275,8 @@ export type {
     ReviveDryRunResult,
     ReviveDryRunCall,
     CdmJson,
-    CdmJsonTarget,
     CdmJsonContract,
+    CdmJsonDependencyVersion,
     AbiParam,
     AbiEntry,
     Contract,
@@ -280,6 +291,7 @@ export type {
     ContractDefaults,
     ContractManagerOptions,
     ContractOptions,
+    LiveContractResolutionOptions,
 };
 
 // `@parity/product-sdk-contracts/codegen` (Node-only — build tooling)

package/dist/codegen.d.ts

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

package/dist/index.d.ts

@@ -1,9 +1,18 @@
 import { PolkadotClient, HexString } from 'polkadot-api';
-import { C as CdmJson, a as ContractRuntime, b as ContractManagerOptions, c as ContractDefaults, d as ContractRuntimeOptions, e as Contracts, f as Contract, g as ContractDef, A as AbiEntry, h as ContractOptions } from './types-DzYW54TT.js';
-export { i as AbiParam, j as CdmJsonContract, k as CdmJsonTarget, 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-DzYW54TT.js';
+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';
 export { BatchableCall, TxResult } from '@parity/product-sdk-tx';
 import '@parity/product-sdk-signer';
 
+/**
+ * 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
+ * `ContractManager.fromClient(...)` directly for snapshot-only behavior.
+ */
+declare function withLiveContractAddresses(cdmJson: CdmJson, runtime: ContractRuntime, options?: LiveContractResolutionOptions): Promise<CdmJson>;
 /**
  * Manages typed contract interactions backed by a `cdm.json` manifest.
  *
@@ -20,7 +29,6 @@ import '@parity/product-sdk-signer';
  *
  * const client = await createChainClient({
  *     chains: { assetHub: paseo_asset_hub },
- *     rpcs: { assetHub: ["wss://paseo-asset-hub-next-rpc.polkadot.io"] },
  * });
  * const runtime = createContractRuntime(client.assetHub);
  * const manager = new ContractManager(cdmJson, runtime, {
@@ -33,8 +41,7 @@ import '@parity/product-sdk-signer';
  * ```
  */
 declare class ContractManager {
-    private cdmJson;
-    private targetHash;
+    private contracts;
     private runtime;
     private defaults;
     constructor(cdmJson: CdmJson, runtime: ContractRuntime, options?: ContractManagerOptions);
@@ -54,6 +61,16 @@ declare class ContractManager {
      * @param options - Optional configuration (signerManager, defaults).
      */
     static fromClient<TDescriptor>(cdmJson: CdmJson, client: PolkadotClient, descriptor: TDescriptor, options?: ContractManagerOptions & ContractRuntimeOptions): 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>;
+    /**
+     * 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>;
     private getContractData;
     /**
      * Get a typed contract handle.
@@ -117,8 +134,17 @@ declare class ContractSignerMissingError extends ContractError {
 /** A contract was not found in the cdm.json manifest. */
 declare class ContractNotFoundError extends ContractError {
     readonly library: string;
-    readonly targetHash: string;
-    constructor(library: string, targetHash: 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()`
@@ -163,4 +189,4 @@ declare class ContractRevertedError extends ContractError {
     });
 }
 
-export { AbiEntry, CdmJson, Contract, ContractDef, ContractDefaults, ContractDryRunFailedError, ContractError, ContractManager, ContractManagerOptions, ContractNotFoundError, ContractOptions, type ContractRevertInfo, ContractRevertedError, ContractRuntime, ContractRuntimeOptions, ContractSignerMissingError, Contracts, type DecodedContractRevert, createContract, createContractFromClient };
+export { AbiEntry, CdmJson, Contract, ContractDef, ContractDefaults, ContractDryRunFailedError, ContractError, ContractLiveAddressResolutionError, ContractManager, ContractManagerOptions, ContractNotFoundError, ContractOptions, type ContractRevertInfo, ContractRevertedError, ContractRuntime, ContractRuntimeOptions, ContractSignerMissingError, Contracts, type DecodedContractRevert, LiveContractResolutionOptions, createContract, createContractFromClient, withLiveContractAddresses };

package/dist/index.js

@@ -23,12 +23,20 @@ var ContractSignerMissingError = class extends ContractError {
 };
 var ContractNotFoundError = class extends ContractError {
   library;
-  targetHash;
-  constructor(library, targetHash) {
-    super(`Contract "${library}" not found in cdm.json for target ${targetHash}`);
+  constructor(library) {
+    super(`Contract "${library}" not found in cdm.json`);
     this.name = "ContractNotFoundError";
     this.library = library;
-    this.targetHash = targetHash;
+  }
+};
+var ContractLiveAddressResolutionError = class extends ContractError {
+  library;
+  detail;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "ContractLiveAddressResolutionError";
+    this.library = options?.library;
+    this.detail = options?.detail;
   }
 };
 var ContractDryRunFailedError = class extends ContractError {
@@ -351,21 +359,132 @@ async function ensureContractAccountMapped(runtime, address, signer, options) {
 }
 
 // src/manager.ts
+var CDM_REGISTRY_ABI = [
+  {
+    type: "function",
+    name: "getAddress",
+    inputs: [{ name: "contract_name", type: "string" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "isSome", type: "bool" },
+          { name: "value", type: "address" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAddressAtVersion",
+    inputs: [
+      { name: "contract_name", type: "string" },
+      { name: "version", type: "uint32" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "isSome", type: "bool" },
+          { name: "value", type: "address" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+function cloneCdmJson(cdmJson) {
+  const cloneContractMap = (contracts) => Object.fromEntries(
+    Object.entries(contracts).map(([library, contract]) => [library, { ...contract }])
+  );
+  return {
+    ...cdmJson,
+    dependencies: { ...cdmJson.dependencies },
+    contracts: cdmJson.contracts ? cloneContractMap(cdmJson.contracts) : void 0
+  };
+}
+function resolveRegistryAddress(cdmJson, override) {
+  if (override) return override;
+  if (cdmJson.registry) return cdmJson.registry;
+  throw new ContractLiveAddressResolutionError(
+    "CDM registry address is required for live contract address resolution. Pass registryAddress or set cdm.json registry."
+  );
+}
+function patchContractAddress(cdmJson, library, address) {
+  const contract = cdmJson.contracts?.[library];
+  if (!contract) {
+    throw new ContractNotFoundError(library);
+  }
+  contract.address = address;
+}
+function resolveLiveVersionSpec(cdmJson, library, contract) {
+  const requested = cdmJson.dependencies[library];
+  if (typeof requested === "number" && Number.isInteger(requested) && requested >= 0) {
+    return requested;
+  }
+  if (typeof requested === "string") {
+    if (requested === "latest") return "latest";
+    const parsed = Number(requested);
+    if (Number.isInteger(parsed) && parsed >= 0) return parsed;
+  }
+  return contract.version;
+}
+async function queryLiveAddress(registry, library, version) {
+  const result = version === "latest" ? await registry.getAddress.query(library) : await registry.getAddressAtVersion.query(library, version);
+  if (!result.success) {
+    throw new ContractLiveAddressResolutionError(
+      version === "latest" ? `Failed to resolve live address for "${library}" from the CDM registry` : `Failed to resolve live address for "${library}" version ${version} from the CDM registry`,
+      { library, detail: result.value }
+    );
+  }
+  const value = result.value;
+  if (!value?.isSome) {
+    throw new ContractLiveAddressResolutionError(
+      version === "latest" ? `Contract "${library}" is not registered in the CDM registry` : `Contract "${library}" version ${version} is not registered in the CDM registry`,
+      { library, detail: result.value }
+    );
+  }
+  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."
+    );
+  }
+  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 resolved = cloneCdmJson(cdmJson);
+  for (const [library, address] of liveAddresses) {
+    patchContractAddress(resolved, library, address);
+  }
+  return resolved;
+}
 var ContractManager = class _ContractManager {
-  cdmJson;
-  targetHash;
+  contracts;
   runtime;
   defaults;
   constructor(cdmJson, runtime, options) {
-    this.cdmJson = cdmJson;
     this.runtime = runtime;
-    if (options?.targetHash) {
-      this.targetHash = options.targetHash;
-    } else {
-      const targets = Object.keys(cdmJson.targets);
-      if (targets.length === 0) throw new Error("No targets found in cdm.json");
-      this.targetHash = targets[0];
-    }
+    this.contracts = cdmJson.contracts;
     this.defaults = {
       signerManager: options?.signerManager,
       origin: options?.defaultOrigin,
@@ -399,12 +518,30 @@ var ContractManager = class _ContractManager {
       options
     );
   }
+  /**
+   * Create a manager after strictly resolving installed contract addresses
+   * from the live CDM registry. ABIs still come from the installed manifest.
+   */
+  static async fromLive(cdmJson, runtime, options) {
+    const resolved = await withLiveContractAddresses(cdmJson, runtime, {
+      ...options,
+      registryOrigin: options?.registryOrigin ?? options?.defaultOrigin
+    });
+    return new _ContractManager(resolved, runtime, options);
+  }
+  /**
+   * Convenience factory for {@link fromLive} when the caller has a raw
+   * `PolkadotClient` and descriptor.
+   */
+  static async fromLiveClient(cdmJson, client, descriptor, options) {
+    const runtime = createContractRuntimeFromClient(client, descriptor, options);
+    return _ContractManager.fromLive(cdmJson, runtime, options);
+  }
   getContractData(library) {
-    const contractsForTarget = this.cdmJson.contracts?.[this.targetHash];
-    if (!contractsForTarget || !(library in contractsForTarget)) {
-      throw new ContractNotFoundError(library, this.targetHash);
+    if (!this.contracts || !(library in this.contracts)) {
+      throw new ContractNotFoundError(library);
     }
-    return contractsForTarget[library];
+    return this.contracts[library];
   }
   getContract(library) {
     const data = this.getContractData(library);
@@ -443,6 +580,6 @@ function createContractFromClient(client, descriptor, address, abi, options) {
   );
 }
 
-export { ContractDryRunFailedError, ContractError, ContractManager, ContractNotFoundError, ContractRevertedError, ContractSignerMissingError, createContract, createContractFromClient, createContractRuntime, createContractRuntimeFromClient, ensureContractAccountMapped };
+export { ContractDryRunFailedError, ContractError, ContractLiveAddressResolutionError, ContractManager, ContractNotFoundError, ContractRevertedError, ContractSignerMissingError, createContract, createContractFromClient, createContractRuntime, createContractRuntimeFromClient, ensureContractAccountMapped, withLiveContractAddresses };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map