@parity/product-sdk-contracts 0.2.2 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # @parity/product-sdk-contracts
 
-Typed contract interactions on Polkadot Asset Hub. Resolve deployed contracts from a `cdm.json` manifest, get fully-typed handles for `query`, `tx`, and batched `prepare` calls — all backed by the ink SDK.
+Typed contract interactions on Polkadot Asset Hub. Resolve deployed contracts from a `cdm.json` manifest (or directly from `cargo pvm-contract build` artefacts), get fully-typed handles for `query`, `tx`, and batched `prepare` calls — backed by `pallet-revive` via PAPI typed APIs, with viem providing the Solidity ABI codec.
 
 ## Install
 
@@ -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, api)` resolves them at runtime.
+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.
 
 ```ts
 import { createChainClient } from "@parity/product-sdk-chain-client";
@@ -21,13 +21,13 @@ import cdmJson from "./cdm.json";
 
 const client = await createChainClient({
     chains: { assetHub: paseo_asset_hub },
-    rpcs: { assetHub: ["wss://asset-hub-paseo-rpc.n.dwellir.com"] },
+    rpcs: { assetHub: ["wss://paseo-asset-hub-next-rpc.polkadot.io"] },
 });
 
 const signerManager = new SignerManager();
 await signerManager.connect();
 
-const manager = await ContractManager.fromClient(cdmJson, client.raw.assetHub, {
+const manager = ContractManager.fromClient(cdmJson, client.raw.assetHub, paseo_asset_hub, {
     signerManager,
 });
 
@@ -43,14 +43,15 @@ await registry.publish.tx("my-app00", "ipfs://...", 0);
 
 ## `ContractManager` API
 
-### `ContractManager.fromClient(cdmJson, client, options?)`
+### `ContractManager.fromClient(cdmJson, client, descriptor, options?)`
 
-Async factory. Lazy-imports `@polkadot-api/sdk-ink` (~4 MB) only when called, so the install footprint stays small for callers who never resolve contracts.
+Synchronous factory. Builds a `ContractRuntime` internally that wires the typed API (for extrinsics + storage) and the unsafe API (for the `ReviveApi.call` dry-run, sidesteps compat-token drift when the descriptor lags a runtime upgrade) on the same `PolkadotClient`.
 
 | Param | Type | Notes |
 | --- | --- | --- |
 | `cdmJson` | `CdmJson` | Imported `cdm.json` |
 | `client` | `PolkadotClient` | E.g. `client.raw.assetHub` |
+| `descriptor` | `ChainDefinition` | E.g. `paseo_asset_hub` from `@parity/product-sdk-descriptors` |
 | `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 |
@@ -95,6 +96,23 @@ Order, highest wins:
 
 Throws `ContractSignerMissingError` from `.tx()` if no signer is available. `.query()` and `.prepare()` never need a signer.
 
+## Account mapping (`pallet-revive` prerequisite)
+
+`pallet-revive` requires every signing SS58 account to have a registered `OriginalAccount` mapping to its derived H160 before `Revive.call` extrinsics from it are accepted. Call `ensureContractAccountMapped(runtime, address, signer)` once at app boot per signing account — it's idempotent (reads `Revive.OriginalAccount` first, short-circuits with `null` if already mapped) so the worst case is one extra storage read on every boot.
+
+```ts
+import { ensureContractAccountMapped } from "@parity/product-sdk-contracts";
+
+await ensureContractAccountMapped(manager.getRuntime(), address, signer);
+// safe to call manager.getContract(...).<method>.tx({ signer }) from here
+```
+
+Without this, every fresh-account `.tx()` fails the pre-flight dry-run with `AccountNotMapped` before signing.
+
+## Dry-run preflight
+
+Every `.tx()` runs a `ReviveApi.call` dry-run first to size `weight_limit` / `storage_deposit_limit` and to fail fast on revert, OOG, or `AccountNotMapped` before any signing happens. Throws `ContractDryRunFailedError` (with the chain's `dispatchError`) when the dry-run reports failure — caller pays no gas on a tx the chain already rejected. Pass both `gasLimit` and `storageDepositLimit` overrides on `TxOptions` to skip the dry-run entirely.
+
 ## Batching with `.prepare()`
 
 Use `.prepare()` to build `BatchableCall` handles consumable by `batchSubmitAndWatch` from `@parity/product-sdk-tx`. Combine multiple contract calls — or contract calls mixed with other Asset Hub transactions — into a single atomic `Utility.batch_all` extrinsic.
@@ -118,9 +136,11 @@ If you don't have a `cdm.json` (or want to test against a contract not yet in yo
 
 ```ts
 import { createContractFromClient } from "@parity/product-sdk-contracts";
+import { paseo_asset_hub } from "@parity/product-sdk-descriptors/paseo-asset-hub";
 
-const counter = await createContractFromClient(
+const counter = createContractFromClient(
     client.raw.assetHub,
+    paseo_asset_hub,
     "0xC472...",
     counterAbi,
     { signerManager },
@@ -130,7 +150,9 @@ const { value } = await counter.getCount.query();
 await counter.increment.tx();
 ```
 
-`createContract` is the same but takes a pre-created `InkSdk` if you want to control when `@polkadot-api/sdk-ink` loads.
+`createContract` is the same but takes a pre-built `ContractRuntime` (from `createContractRuntime` / `createContractRuntimeFromClient`) instead of a raw `PolkadotClient` + descriptor. Use it when you want to share a single runtime across multiple contract handles or wire your own dry-run path.
+
+For projects that build with `cargo pvm-contract` and don't want to maintain a `cdm.json`, the `@parity/product-sdk-contracts/pvm` subpath exports `parsePvmContractAbi`, `loadPvmContractAbi`, `loadPvmContractCode`, and `loadPvmContractArtifacts` — load the ABI (and bytecode for deployment) directly from the toolchain's `<name>.release.abi.json` / `<name>.release.polkavm` output.
 
 ## cdm.json schema
 
@@ -140,8 +162,8 @@ Top-level shape:
 {
   "targets": {
     "<targetHash>": {
-      "asset-hub": "wss://asset-hub-paseo-rpc.n.dwellir.com",
-      "bulletin": "https://paseo-ipfs.polkadot.io/ipfs"
+      "asset-hub": "wss://paseo-asset-hub-next-rpc.polkadot.io",
+      "bulletin": "https://paseo-bulletin-next-ipfs.polkadot.io"
     }
   },
   "dependencies": {
@@ -170,11 +192,15 @@ A real-world example: [`paritytech/playground-cli/cdm.json`](https://github.com/
 `generateContractTypes(...)` (from `@parity/product-sdk-contracts/codegen`) emits a `.d.ts` that augments the package's `Contracts` interface so `manager.getContract("@org/name")` returns a fully-typed handle:
 
 ```ts
-import { generateContractTypes } from "@parity/product-sdk-contracts/codegen";
-import cdm from "./cdm.json";
+import { generateContractTypes, resolveContractTypeInputs } from "@parity/product-sdk-contracts/codegen";
 import { writeFileSync } from "node:fs";
 
-const src = generateContractTypes(cdm);
+// Mix inline ABIs (from your cdm.json) and cargo-pvm-contract build artefacts.
+const resolved = await resolveContractTypeInputs([
+    { library: "@example/counter", abiPath: "./target/counter.release.abi.json" },
+    { library: "@example/inline", abi: inlineAbi },
+]);
+const src = generateContractTypes(resolved);
 writeFileSync(".cdm/contracts.d.ts", src);
 ```
 
@@ -188,21 +214,30 @@ Without codegen, `getContract()` still works — methods are accessible but unty
 | --- | --- |
 | `ContractNotFoundError` | `getContract(name)` and `name` isn't in the manifest for the active target |
 | `ContractSignerMissingError` | `.tx()` called with no signer + no signerManager + no defaultSigner |
-| Generic | ABI decode failures, RPC errors, gas estimation failures — surface from the underlying ink SDK |
+| `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 |
 
 ## Public API
 
 ```ts
+// `@parity/product-sdk-contracts` (browser-safe runtime entry)
 export {
     ContractManager,
     createContract,
     createContractFromClient,
-    generateContractTypes,
+    createContractRuntime,
+    createContractRuntimeFromClient,
+    ensureContractAccountMapped,
     ContractError,
     ContractSignerMissingError,
     ContractNotFoundError,
+    ContractDryRunFailedError,
 };
 export type {
+    ContractRuntime,
+    ReviveTypedApi,
+    ReviveDryRunResult,
+    ReviveDryRunCall,
     CdmJson,
     CdmJsonTarget,
     CdmJsonContract,
@@ -221,4 +256,17 @@ export type {
     ContractManagerOptions,
     ContractOptions,
 };
+
+// `@parity/product-sdk-contracts/codegen` (Node-only — build tooling)
+export { generateContractTypes, resolveContractTypeInputs };
+export type { ContractTypeInput };
+
+// `@parity/product-sdk-contracts/pvm` (Node-only — cargo-pvm-contract artefact loaders)
+export {
+    parsePvmContractAbi,
+    loadPvmContractAbi,
+    loadPvmContractCode,
+    loadPvmContractArtifacts,
+};
+export type { PvmContractArtifacts };
 ```

package/dist/chunk-YZ3YBERU.js

@@ -0,0 +1,53 @@
+// src/pvm.ts
+function parsePvmContractAbi(source) {
+  let value = source;
+  if (value instanceof Uint8Array) {
+    value = new TextDecoder().decode(value);
+  }
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch (cause) {
+      throw new Error("Invalid PVM ABI: not valid JSON", { cause });
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value) && "abi" in value) {
+    value = value.abi;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid PVM ABI: expected an array of ABI entries");
+  }
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || typeof entry.type !== "string") {
+      throw new Error(
+        "Invalid PVM ABI: every entry must have a string `type` (function/event/constructor/...)"
+      );
+    }
+    const inputs = entry.inputs;
+    if (inputs !== void 0 && !Array.isArray(inputs)) {
+      throw new Error("Invalid PVM ABI: `inputs` must be an array when present");
+    }
+  }
+  return value;
+}
+async function loadPvmContractAbi(path) {
+  const { readFile } = await import('fs/promises');
+  const buf = await readFile(path);
+  return parsePvmContractAbi(buf);
+}
+async function loadPvmContractCode(path) {
+  const { readFile } = await import('fs/promises');
+  const buf = await readFile(path);
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+async function loadPvmContractArtifacts(basePath) {
+  const [abi, bytecode] = await Promise.all([
+    loadPvmContractAbi(`${basePath}.abi.json`),
+    loadPvmContractCode(`${basePath}.polkavm`)
+  ]);
+  return { abi, bytecode };
+}
+
+export { loadPvmContractAbi, loadPvmContractArtifacts, loadPvmContractCode, parsePvmContractAbi };
+//# sourceMappingURL=chunk-YZ3YBERU.js.map
+//# sourceMappingURL=chunk-YZ3YBERU.js.map

package/dist/chunk-YZ3YBERU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pvm.ts"],"names":[],"mappings":";AAmBO,SAAS,oBAAoB,MAAA,EAA6B;AAC7D,EAAA,IAAI,KAAA,GAAiB,MAAA;AAErB,EAAA,IAAI,iBAAiB,UAAA,EAAY;AAC7B,IAAA,KAAA,GAAQ,IAAI,WAAA,EAAY,CAAE,MAAA,CAAO,KAAK,CAAA;AAAA,EAC1C;AACA,EAAA,IAAI,OAAO,UAAU,QAAA,EAAU;AAC3B,IAAA,IAAI;AACA,MAAA,KAAA,GAAQ,IAAA,CAAK,MAAM,KAAK,CAAA;AAAA,IAC5B,SAAS,KAAA,EAAO;AACZ,MAAA,MAAM,IAAI,KAAA,CAAM,iCAAA,EAAmC,EAAE,OAAO,CAAA;AAAA,IAChE;AAAA,EACJ;AACA,EAAA,IAAI,KAAA,IAAS,OAAO,KAAA,KAAU,QAAA,IAAY,CAAC,MAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,KAAA,IAAS,KAAA,EAAO;AAC/E,IAAA,KAAA,GAAS,KAAA,CAA2B,GAAA;AAAA,EACxC;AACA,EAAA,IAAI,CAAC,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACvB,IAAA,MAAM,IAAI,MAAM,mDAAmD,CAAA;AAAA,EACvE;AACA,EAAA,KAAA,MAAW,SAAS,KAAA,EAAO;AACvB,IAAA,IAAI,CAAC,SAAS,OAAO,KAAA,KAAU,YAAY,OAAQ,KAAA,CAAmB,SAAS,QAAA,EAAU;AACrF,MAAA,MAAM,IAAI,KAAA;AAAA,QACN;AAAA,OACJ;AAAA,IACJ;AACA,IAAA,MAAM,SAAU,KAAA,CAAmB,MAAA;AACnC,IAAA,IAAI,WAAW,MAAA,IAAa,CAAC,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,EAAG;AAChD,MAAA,MAAM,IAAI,MAAM,yDAAyD,CAAA;AAAA,IAC7E;AAAA,EACJ;AACA,EAAA,OAAO,KAAA;AACX;AAOA,eAAsB,mBAAmB,IAAA,EAAmC;AACxE,EAAA,MAAM,EAAE,QAAA,EAAS,GAAI,MAAM,OAAO,aAAkB,CAAA;AACpD,EAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,IAAI,CAAA;AAC/B,EAAA,OAAO,oBAAoB,GAAG,CAAA;AAClC;AAYA,eAAsB,oBAAoB,IAAA,EAAmC;AACzE,EAAA,MAAM,EAAE,QAAA,EAAS,GAAI,MAAM,OAAO,aAAkB,CAAA;AACpD,EAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,IAAI,CAAA;AAC/B,EAAA,OAAO,IAAI,UAAA,CAAW,GAAA,CAAI,QAAQ,GAAA,CAAI,UAAA,EAAY,IAAI,UAAU,CAAA;AACpE;AAYA,eAAsB,yBAAyB,QAAA,EAAiD;AAC5F,EAAA,MAAM,CAAC,GAAA,EAAK,QAAQ,CAAA,GAAI,MAAM,QAAQ,GAAA,CAAI;AAAA,IACtC,kBAAA,CAAmB,CAAA,EAAG,QAAQ,CAAA,SAAA,CAAW,CAAA;AAAA,IACzC,mBAAA,CAAoB,CAAA,EAAG,QAAQ,CAAA,QAAA,CAAU;AAAA,GAC5C,CAAA;AACD,EAAA,OAAO,EAAE,KAAK,QAAA,EAAS;AAC3B","file":"chunk-YZ3YBERU.js","sourcesContent":["import type { AbiEntry } from \"./types.js\";\n\n/** ABI + PolkaVM bytecode pair emitted by `cargo pvm-contract build`. */\nexport interface PvmContractArtifacts {\n    abi: AbiEntry[];\n    bytecode: Uint8Array;\n}\n\n/**\n * Parse an in-memory cargo-pvm-contract ABI artifact.\n *\n * Accepts the shapes the toolchain may produce or that products may pass:\n * - parsed JSON array — `AbiEntry[]`\n * - parsed JSON object with an `abi` property — `{ abi: AbiEntry[] }`\n * - JSON string of either of the above\n * - `Uint8Array` containing UTF-8 JSON of either of the above\n *\n * @throws if the input cannot be coerced to a non-empty `AbiEntry[]`.\n */\nexport function parsePvmContractAbi(source: unknown): AbiEntry[] {\n    let value: unknown = source;\n\n    if (value instanceof Uint8Array) {\n        value = new TextDecoder().decode(value);\n    }\n    if (typeof value === \"string\") {\n        try {\n            value = JSON.parse(value);\n        } catch (cause) {\n            throw new Error(\"Invalid PVM ABI: not valid JSON\", { cause });\n        }\n    }\n    if (value && typeof value === \"object\" && !Array.isArray(value) && \"abi\" in value) {\n        value = (value as { abi: unknown }).abi;\n    }\n    if (!Array.isArray(value)) {\n        throw new Error(\"Invalid PVM ABI: expected an array of ABI entries\");\n    }\n    for (const entry of value) {\n        if (!entry || typeof entry !== \"object\" || typeof (entry as AbiEntry).type !== \"string\") {\n            throw new Error(\n                \"Invalid PVM ABI: every entry must have a string `type` (function/event/constructor/...)\",\n            );\n        }\n        const inputs = (entry as AbiEntry).inputs;\n        if (inputs !== undefined && !Array.isArray(inputs)) {\n            throw new Error(\"Invalid PVM ABI: `inputs` must be an array when present\");\n        }\n    }\n    return value as AbiEntry[];\n}\n\n/**\n * Read a cargo-pvm-contract ABI file from disk and parse it.\n *\n * Node-only. For browser/in-memory inputs use {@link parsePvmContractAbi}.\n */\nexport async function loadPvmContractAbi(path: string): Promise<AbiEntry[]> {\n    const { readFile } = await import(\"node:fs/promises\");\n    const buf = await readFile(path);\n    return parsePvmContractAbi(buf);\n}\n\n/**\n * Read the `.polkavm` bytecode artifact produced by `cargo pvm-contract build`.\n *\n * Returned bytes are ready to hand to `Revive.instantiate_with_code` (or to\n * any future deploy helper layered on top of it). Use this when you already\n * have an ABI in hand (e.g. inline or fetched separately) and only need the\n * PolkaVM blob — otherwise prefer {@link loadPvmContractArtifacts}.\n *\n * Node-only.\n */\nexport async function loadPvmContractCode(path: string): Promise<Uint8Array> {\n    const { readFile } = await import(\"node:fs/promises\");\n    const buf = await readFile(path);\n    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);\n}\n\n/**\n * Read both the `.abi.json` and `.polkavm` artifacts produced by\n * `cargo pvm-contract build` for a given base path.\n *\n * `basePath` is the path prefix shared by both files — typically\n * `target/<name>.release`. The function reads `${basePath}.abi.json` and\n * `${basePath}.polkavm`.\n *\n * Node-only.\n */\nexport async function loadPvmContractArtifacts(basePath: string): Promise<PvmContractArtifacts> {\n    const [abi, bytecode] = await Promise.all([\n        loadPvmContractAbi(`${basePath}.abi.json`),\n        loadPvmContractCode(`${basePath}.polkavm`),\n    ]);\n    return { abi, bytecode };\n}\n\nif (import.meta.vitest) {\n    const { test, expect, describe, beforeAll, afterAll } = import.meta.vitest;\n\n    const sampleAbi: AbiEntry[] = [\n        { type: \"constructor\", inputs: [], stateMutability: \"nonpayable\" },\n        {\n            type: \"function\",\n            name: \"increment\",\n            inputs: [],\n            outputs: [],\n            stateMutability: \"nonpayable\",\n        },\n        {\n            type: \"function\",\n            name: \"get\",\n            inputs: [],\n            outputs: [{ name: \"\", type: \"uint32\" }],\n            stateMutability: \"view\",\n        },\n    ];\n\n    describe(\"parsePvmContractAbi\", () => {\n        test(\"accepts a parsed AbiEntry[] array directly\", () => {\n            expect(parsePvmContractAbi(sampleAbi)).toEqual(sampleAbi);\n        });\n\n        test(\"accepts a wrapped { abi } object\", () => {\n            expect(parsePvmContractAbi({ abi: sampleAbi })).toEqual(sampleAbi);\n        });\n\n        test(\"accepts a JSON string of an array\", () => {\n            expect(parsePvmContractAbi(JSON.stringify(sampleAbi))).toEqual(sampleAbi);\n        });\n\n        test(\"accepts a JSON string of a wrapped object\", () => {\n            expect(parsePvmContractAbi(JSON.stringify({ abi: sampleAbi }))).toEqual(sampleAbi);\n        });\n\n        test(\"accepts a UTF-8 Uint8Array\", () => {\n            const bytes = new TextEncoder().encode(JSON.stringify(sampleAbi));\n            expect(parsePvmContractAbi(bytes)).toEqual(sampleAbi);\n        });\n\n        test(\"throws on invalid JSON string\", () => {\n            expect(() => parsePvmContractAbi(\"{not json\")).toThrow(/not valid JSON/);\n        });\n\n        test(\"throws when input is not an array\", () => {\n            expect(() => parsePvmContractAbi(42)).toThrow(/expected an array/);\n            expect(() => parsePvmContractAbi({ foo: \"bar\" })).toThrow(/expected an array/);\n        });\n\n        test(\"throws when an entry is missing `type`\", () => {\n            expect(() => parsePvmContractAbi([{ name: \"noType\" }])).toThrow(/string `type`/);\n        });\n\n        test(\"throws when `inputs` is not an array\", () => {\n            expect(() =>\n                parsePvmContractAbi([{ type: \"function\", inputs: \"not an array\" }]),\n            ).toThrow(/`inputs` must be an array/);\n        });\n\n        test(\"treats null as invalid\", () => {\n            expect(() => parsePvmContractAbi(null)).toThrow();\n        });\n    });\n\n    describe(\"loadPvmContractAbi / loadPvmContractArtifacts\", () => {\n        // Cover the Node-only filesystem helpers via a real tmpdir round-trip.\n        // The cargo-pvm-contract toolchain emits files at\n        //   target/<name>.release.abi.json\n        //   target/<name>.release.polkavm\n        // — we recreate that layout here.\n        let dir = \"\";\n        let base = \"\";\n        let lonely = \"\";\n        let badAbi = \"\";\n        // Minimal PolkaVM magic (`PVM\\0`) is enough to exercise the path —\n        // we don't validate bytecode contents in the loader.\n        const fakeBytecode = new Uint8Array([0x50, 0x56, 0x4d, 0x00, 0x01, 0x02, 0x03]);\n\n        beforeAll(async () => {\n            const { mkdtempSync, writeFileSync } = await import(\"node:fs\");\n            const { tmpdir } = await import(\"node:os\");\n            const { join } = await import(\"node:path\");\n            dir = mkdtempSync(join(tmpdir(), \"pvm-loader-test-\"));\n            base = join(dir, \"counter.release\");\n            lonely = join(dir, \"lonely.release\");\n            badAbi = join(dir, \"bad.release\");\n            writeFileSync(`${base}.abi.json`, JSON.stringify(sampleAbi));\n            writeFileSync(`${base}.polkavm`, fakeBytecode);\n            writeFileSync(`${lonely}.abi.json`, JSON.stringify(sampleAbi));\n            writeFileSync(`${badAbi}.abi.json`, \"{not valid json\");\n        });\n\n        afterAll(async () => {\n            const { rmSync } = await import(\"node:fs\");\n            try {\n                rmSync(dir, { recursive: true, force: true });\n            } catch {\n                /* ignore */\n            }\n        });\n\n        test(\"loadPvmContractAbi parses a JSON file from disk\", async () => {\n            const abi = await loadPvmContractAbi(`${base}.abi.json`);\n            expect(abi).toEqual(sampleAbi);\n        });\n\n        test(\"loadPvmContractArtifacts reads abi + bytecode pair\", async () => {\n            const out = await loadPvmContractArtifacts(base);\n            expect(out.abi).toEqual(sampleAbi);\n            expect(out.bytecode).toBeInstanceOf(Uint8Array);\n            expect(Array.from(out.bytecode)).toEqual(Array.from(fakeBytecode));\n        });\n\n        test(\"loadPvmContractCode reads only the .polkavm blob\", async () => {\n            const code = await loadPvmContractCode(`${base}.polkavm`);\n            expect(code).toBeInstanceOf(Uint8Array);\n            expect(Array.from(code)).toEqual(Array.from(fakeBytecode));\n        });\n\n        test(\"loadPvmContractAbi rejects a missing file\", async () => {\n            await expect(loadPvmContractAbi(`${base}.does-not-exist`)).rejects.toThrow();\n        });\n\n        test(\"loadPvmContractArtifacts rejects when bytecode is missing\", async () => {\n            // Only `${lonely}.abi.json` exists — `.polkavm` is absent.\n            await expect(loadPvmContractArtifacts(lonely)).rejects.toThrow();\n        });\n\n        test(\"loadPvmContractAbi propagates parse errors with helpful message\", async () => {\n            await expect(loadPvmContractAbi(`${badAbi}.abi.json`)).rejects.toThrow(\n                /not valid JSON/,\n            );\n        });\n    });\n}\n"]}

package/dist/codegen.d.ts

@@ -1,4 +1,65 @@
-export { k as generateContractTypes } from './codegen-BPDBGrJC.js';
+import { A as AbiEntry } from './types-BdHp-xWt.js';
 import 'polkadot-api';
 import '@parity/product-sdk-tx';
 import '@parity/product-sdk-signer';
+
+/** A contract input to {@link generateContractTypes}: either an inline ABI or a `cargo-pvm-contract` artefact path. */
+type ContractTypeInput = {
+    library: string;
+    abi: AbiEntry[];
+} | {
+    library: string;
+    abiPath: string;
+};
+/**
+ * Resolve a heterogeneous list of {@link ContractTypeInput} entries into the
+ * `{ library, abi }` shape consumed by {@link generateContractTypes}. Reads any
+ * `abiPath` entries off disk via {@link loadPvmContractAbi} (Node only).
+ *
+ * @example
+ * ```ts
+ * const resolved = await resolveContractTypeInputs([
+ *     { library: "@example/counter", abiPath: "./target/counter.release.abi.json" },
+ *     { library: "@example/inline", abi: counterAbi },
+ * ]);
+ * const src = generateContractTypes(resolved);
+ * ```
+ */
+declare function resolveContractTypeInputs(inputs: readonly ContractTypeInput[]): Promise<{
+    library: string;
+    abi: AbiEntry[];
+}[]>;
+/**
+ * Generate a TypeScript module augmentation that extends the
+ * {@link Contracts} interface with typed method signatures for each
+ * installed contract.
+ *
+ * The output is written to `.cdm/contracts.d.ts` (or equivalent) and
+ * augments `"@parity/product-sdk-contracts"` so that
+ * `ContractManager.getContract()` returns fully-typed handles.
+ *
+ * Accepts `{ library, abi }` directly. To pull ABIs from
+ * `cargo-pvm-contract` build artefacts on disk, use
+ * {@link resolveContractTypeInputs} first.
+ *
+ * @example
+ * ```ts
+ * // Inline ABIs
+ * const src = generateContractTypes([
+ *     { library: "@example/counter", abi },
+ * ]);
+ * writeFileSync(".cdm/contracts.d.ts", src);
+ *
+ * // From cargo-pvm-contract artefacts
+ * const resolved = await resolveContractTypeInputs([
+ *     { library: "@example/counter", abiPath: "./target/counter.release.abi.json" },
+ * ]);
+ * writeFileSync(".cdm/contracts.d.ts", generateContractTypes(resolved));
+ * ```
+ */
+declare function generateContractTypes(contracts: {
+    library: string;
+    abi: AbiEntry[];
+}[]): string;
+
+export { type ContractTypeInput, generateContractTypes, resolveContractTypeInputs };

package/dist/codegen.js

@@ -1,3 +1,83 @@
-export { generateContractTypes } from './chunk-E7AP65D4.js';
+import { loadPvmContractAbi } from './chunk-YZ3YBERU.js';
+
+// src/codegen.ts
+async function resolveContractTypeInputs(inputs) {
+  return Promise.all(
+    inputs.map(async (input) => {
+      if ("abi" in input) return { library: input.library, abi: input.abi };
+      return { library: input.library, abi: await loadPvmContractAbi(input.abiPath) };
+    })
+  );
+}
+function mapSolidityType(param) {
+  const t = param.type;
+  if (t.endsWith("[]")) {
+    const inner = { ...param, type: t.slice(0, -2) };
+    return `${mapSolidityType(inner)}[]`;
+  }
+  const fixedArrayMatch = t.match(/^(.+)\[(\d+)\]$/);
+  if (fixedArrayMatch) {
+    const inner = { ...param, type: fixedArrayMatch[1] };
+    return `${mapSolidityType(inner)}[]`;
+  }
+  if (t === "tuple" && param.components) {
+    const fields = param.components.map((c) => `${c.name}: ${mapSolidityType(c)}`);
+    return `{ ${fields.join("; ")} }`;
+  }
+  if (/^uint(8|16|32)$/.test(t)) return "number";
+  if (/^uint\d*$/.test(t)) return "bigint";
+  if (/^int(8|16|32)$/.test(t)) return "number";
+  if (/^int\d*$/.test(t)) return "bigint";
+  if (t === "address") return "HexString";
+  if (t === "bytes") return "HexString";
+  const bytesMatch = t.match(/^bytes(\d+)$/);
+  if (bytesMatch) return `SizedHex<${bytesMatch[1]}>`;
+  if (t === "bool") return "boolean";
+  if (t === "string") return "string";
+  return "unknown";
+}
+function generateMethodArgsType(inputs) {
+  if (inputs.length === 0) return "[]";
+  const parts = inputs.map((p) => `${p.name}: ${mapSolidityType(p)}`);
+  return `[${parts.join(", ")}]`;
+}
+function generateMethodResponseType(outputs) {
+  if (!outputs || outputs.length === 0) return "undefined";
+  if (outputs.length === 1) return mapSolidityType(outputs[0]);
+  const fields = outputs.map((o, i) => {
+    const name = o.name || `_${i}`;
+    return `${name}: ${mapSolidityType(o)}`;
+  });
+  return `{ ${fields.join("; ")} }`;
+}
+function generateContractTypes(contracts) {
+  const lines = [
+    "// Auto-generated by cdm install \u2014 do not edit",
+    'import type { HexString, SizedHex } from "polkadot-api";',
+    "",
+    'declare module "@parity/product-sdk-contracts" {',
+    "    interface Contracts {"
+  ];
+  for (const contract of contracts) {
+    const methods = contract.abi.filter((e) => e.type === "function" && e.name);
+    lines.push(`        "${contract.library}": {`);
+    lines.push("            methods: {");
+    for (const method of methods) {
+      const args = generateMethodArgsType(method.inputs);
+      const response = generateMethodResponseType(method.outputs);
+      lines.push(
+        `                ${method.name}: { args: ${args}; response: ${response} };`
+      );
+    }
+    lines.push("            };");
+    lines.push("        };");
+  }
+  lines.push("    }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+export { generateContractTypes, resolveContractTypeInputs };
 //# sourceMappingURL=codegen.js.map
 //# sourceMappingURL=codegen.js.map

package/dist/codegen.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"codegen.js"}
+{"version":3,"sources":["../src/codegen.ts"],"names":[],"mappings":"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","file":"codegen.js","sourcesContent":["import type { AbiEntry, AbiParam } from \"./types.js\";\nimport { loadPvmContractAbi } from \"./pvm.js\";\n\n/** A contract input to {@link generateContractTypes}: either an inline ABI or a `cargo-pvm-contract` artefact path. */\nexport type ContractTypeInput =\n    | { library: string; abi: AbiEntry[] }\n    | { library: string; abiPath: string };\n\n/**\n * Resolve a heterogeneous list of {@link ContractTypeInput} entries into the\n * `{ library, abi }` shape consumed by {@link generateContractTypes}. Reads any\n * `abiPath` entries off disk via {@link loadPvmContractAbi} (Node only).\n *\n * @example\n * ```ts\n * const resolved = await resolveContractTypeInputs([\n *     { library: \"@example/counter\", abiPath: \"./target/counter.release.abi.json\" },\n *     { library: \"@example/inline\", abi: counterAbi },\n * ]);\n * const src = generateContractTypes(resolved);\n * ```\n */\nexport async function resolveContractTypeInputs(\n    inputs: readonly ContractTypeInput[],\n): Promise<{ library: string; abi: AbiEntry[] }[]> {\n    return Promise.all(\n        inputs.map(async (input) => {\n            if (\"abi\" in input) return { library: input.library, abi: input.abi };\n            return { library: input.library, abi: await loadPvmContractAbi(input.abiPath) };\n        }),\n    );\n}\n\n/** Map a Solidity ABI type to its TypeScript equivalent. */\nfunction mapSolidityType(param: AbiParam): string {\n    const t = param.type;\n\n    // Dynamic arrays — e.g. uint256[]\n    if (t.endsWith(\"[]\")) {\n        const inner = { ...param, type: t.slice(0, -2) };\n        return `${mapSolidityType(inner)}[]`;\n    }\n\n    // Fixed-size arrays — e.g. uint256[3]\n    const fixedArrayMatch = t.match(/^(.+)\\[(\\d+)\\]$/);\n    if (fixedArrayMatch) {\n        const inner = { ...param, type: fixedArrayMatch[1] };\n        return `${mapSolidityType(inner)}[]`;\n    }\n\n    // Tuple\n    if (t === \"tuple\" && param.components) {\n        const fields = param.components.map((c) => `${c.name}: ${mapSolidityType(c)}`);\n        return `{ ${fields.join(\"; \")} }`;\n    }\n\n    // Unsigned integers — uint8/16/32 fit in JS number\n    if (/^uint(8|16|32)$/.test(t)) return \"number\";\n    if (/^uint\\d*$/.test(t)) return \"bigint\";\n\n    // Signed integers\n    if (/^int(8|16|32)$/.test(t)) return \"number\";\n    if (/^int\\d*$/.test(t)) return \"bigint\";\n\n    // Address\n    if (t === \"address\") return \"HexString\";\n\n    // Bytes — viem's ABI codec accepts hex strings (`0x…`) for both\n    // variable-length `bytes` and fixed-length `bytesN`. We surface\n    // `SizedHex<N>` for the latter so consumers see the byte width at\n    // compile time, even though the runtime check is just on the prefix.\n    if (t === \"bytes\") return \"HexString\";\n    const bytesMatch = t.match(/^bytes(\\d+)$/);\n    if (bytesMatch) return `SizedHex<${bytesMatch[1]}>`;\n\n    // Primitives\n    if (t === \"bool\") return \"boolean\";\n    if (t === \"string\") return \"string\";\n\n    return \"unknown\";\n}\n\nfunction generateMethodArgsType(inputs: AbiParam[]): string {\n    if (inputs.length === 0) return \"[]\";\n    const parts = inputs.map((p) => `${p.name}: ${mapSolidityType(p)}`);\n    return `[${parts.join(\", \")}]`;\n}\n\nfunction generateMethodResponseType(outputs: AbiParam[] | undefined): string {\n    if (!outputs || outputs.length === 0) return \"undefined\";\n    if (outputs.length === 1) return mapSolidityType(outputs[0]);\n    const fields = outputs.map((o, i) => {\n        const name = o.name || `_${i}`;\n        return `${name}: ${mapSolidityType(o)}`;\n    });\n    return `{ ${fields.join(\"; \")} }`;\n}\n\n/**\n * Generate a TypeScript module augmentation that extends the\n * {@link Contracts} interface with typed method signatures for each\n * installed contract.\n *\n * The output is written to `.cdm/contracts.d.ts` (or equivalent) and\n * augments `\"@parity/product-sdk-contracts\"` so that\n * `ContractManager.getContract()` returns fully-typed handles.\n *\n * Accepts `{ library, abi }` directly. To pull ABIs from\n * `cargo-pvm-contract` build artefacts on disk, use\n * {@link resolveContractTypeInputs} first.\n *\n * @example\n * ```ts\n * // Inline ABIs\n * const src = generateContractTypes([\n *     { library: \"@example/counter\", abi },\n * ]);\n * writeFileSync(\".cdm/contracts.d.ts\", src);\n *\n * // From cargo-pvm-contract artefacts\n * const resolved = await resolveContractTypeInputs([\n *     { library: \"@example/counter\", abiPath: \"./target/counter.release.abi.json\" },\n * ]);\n * writeFileSync(\".cdm/contracts.d.ts\", generateContractTypes(resolved));\n * ```\n */\nexport function generateContractTypes(contracts: { library: string; abi: AbiEntry[] }[]): string {\n    const lines: string[] = [\n        \"// Auto-generated by cdm install — do not edit\",\n        'import type { HexString, SizedHex } from \"polkadot-api\";',\n        \"\",\n        'declare module \"@parity/product-sdk-contracts\" {',\n        \"    interface Contracts {\",\n    ];\n\n    for (const contract of contracts) {\n        const methods = contract.abi.filter((e) => e.type === \"function\" && e.name);\n        lines.push(`        \"${contract.library}\": {`);\n        lines.push(\"            methods: {\");\n        for (const method of methods) {\n            const args = generateMethodArgsType(method.inputs);\n            const response = generateMethodResponseType(method.outputs);\n            lines.push(\n                `                ${method.name!}: { args: ${args}; response: ${response} };`,\n            );\n        }\n        lines.push(\"            };\");\n        lines.push(\"        };\");\n    }\n\n    lines.push(\"    }\");\n    lines.push(\"}\");\n    lines.push(\"\");\n\n    return lines.join(\"\\n\");\n}\n\nif (import.meta.vitest) {\n    const { test, expect, describe } = import.meta.vitest;\n\n    describe(\"mapSolidityType\", () => {\n        const cases: [AbiParam, string][] = [\n            [{ name: \"x\", type: \"uint8\" }, \"number\"],\n            [{ name: \"x\", type: \"uint16\" }, \"number\"],\n            [{ name: \"x\", type: \"uint32\" }, \"number\"],\n            [{ name: \"x\", type: \"uint64\" }, \"bigint\"],\n            [{ name: \"x\", type: \"uint128\" }, \"bigint\"],\n            [{ name: \"x\", type: \"uint256\" }, \"bigint\"],\n            [{ name: \"x\", type: \"int8\" }, \"number\"],\n            [{ name: \"x\", type: \"int32\" }, \"number\"],\n            [{ name: \"x\", type: \"int64\" }, \"bigint\"],\n            [{ name: \"x\", type: \"int256\" }, \"bigint\"],\n            [{ name: \"x\", type: \"address\" }, \"HexString\"],\n            [{ name: \"x\", type: \"bool\" }, \"boolean\"],\n            [{ name: \"x\", type: \"string\" }, \"string\"],\n            [{ name: \"x\", type: \"bytes\" }, \"HexString\"],\n            [{ name: \"x\", type: \"bytes32\" }, \"SizedHex<32>\"],\n            [{ name: \"x\", type: \"bytes4\" }, \"SizedHex<4>\"],\n            [{ name: \"x\", type: \"uint256[]\" }, \"bigint[]\"],\n            [{ name: \"x\", type: \"address[]\" }, \"HexString[]\"],\n            [{ name: \"x\", type: \"uint256[3]\" }, \"bigint[]\"],\n            [{ name: \"x\", type: \"somethingWeird\" }, \"unknown\"],\n        ];\n\n        for (const [param, expected] of cases) {\n            test(`${param.type} → ${expected}`, () => {\n                expect(mapSolidityType(param)).toBe(expected);\n            });\n        }\n\n        test(\"tuple with components\", () => {\n            const param: AbiParam = {\n                name: \"info\",\n                type: \"tuple\",\n                components: [\n                    { name: \"addr\", type: \"address\" },\n                    { name: \"amount\", type: \"uint256\" },\n                ],\n            };\n            expect(mapSolidityType(param)).toBe(\"{ addr: HexString; amount: bigint }\");\n        });\n\n        test(\"nested array of tuples\", () => {\n            const param: AbiParam = {\n                name: \"items\",\n                type: \"tuple[]\",\n                components: [\n                    { name: \"id\", type: \"uint32\" },\n                    { name: \"name\", type: \"string\" },\n                ],\n            };\n            expect(mapSolidityType(param)).toBe(\"{ id: number; name: string }[]\");\n        });\n    });\n\n    describe(\"generateMethodArgsType\", () => {\n        test(\"empty inputs\", () => {\n            expect(generateMethodArgsType([])).toBe(\"[]\");\n        });\n\n        test(\"single input\", () => {\n            expect(generateMethodArgsType([{ name: \"to\", type: \"address\" }])).toBe(\n                \"[to: HexString]\",\n            );\n        });\n\n        test(\"multiple inputs\", () => {\n            const result = generateMethodArgsType([\n                { name: \"to\", type: \"address\" },\n                { name: \"amount\", type: \"uint256\" },\n            ]);\n            expect(result).toBe(\"[to: HexString, amount: bigint]\");\n        });\n    });\n\n    describe(\"generateMethodResponseType\", () => {\n        test(\"no outputs\", () => {\n            expect(generateMethodResponseType(undefined)).toBe(\"undefined\");\n            expect(generateMethodResponseType([])).toBe(\"undefined\");\n        });\n\n        test(\"single output\", () => {\n            expect(generateMethodResponseType([{ name: \"\", type: \"uint32\" }])).toBe(\"number\");\n        });\n\n        test(\"multiple outputs\", () => {\n            const result = generateMethodResponseType([\n                { name: \"balance\", type: \"uint256\" },\n                { name: \"nonce\", type: \"uint32\" },\n            ]);\n            expect(result).toBe(\"{ balance: bigint; nonce: number }\");\n        });\n\n        test(\"unnamed outputs get positional names\", () => {\n            const result = generateMethodResponseType([\n                { name: \"\", type: \"bool\" },\n                { name: \"\", type: \"uint256\" },\n            ]);\n            expect(result).toBe(\"{ _0: boolean; _1: bigint }\");\n        });\n    });\n\n    describe(\"generateContractTypes\", () => {\n        test(\"generates valid module augmentation\", () => {\n            const result = generateContractTypes([\n                {\n                    library: \"@example/counter\",\n                    abi: [\n                        {\n                            type: \"constructor\",\n                            inputs: [],\n                            stateMutability: \"nonpayable\",\n                        },\n                        {\n                            type: \"function\",\n                            name: \"getCount\",\n                            inputs: [],\n                            outputs: [{ name: \"\", type: \"uint32\" }],\n                            stateMutability: \"view\",\n                        },\n                        {\n                            type: \"function\",\n                            name: \"increment\",\n                            inputs: [],\n                            outputs: [],\n                            stateMutability: \"nonpayable\",\n                        },\n                    ],\n                },\n            ]);\n\n            expect(result).toContain('declare module \"@parity/product-sdk-contracts\"');\n            expect(result).toContain(\"interface Contracts\");\n            expect(result).toContain('\"@example/counter\"');\n            expect(result).toContain(\"getCount: { args: []; response: number };\");\n            expect(result).toContain(\"increment: { args: []; response: undefined };\");\n            // Should not include constructor\n            expect(result).not.toContain(\"constructor\");\n        });\n\n        test(\"handles multiple contracts\", () => {\n            const result = generateContractTypes([\n                {\n                    library: \"@a/one\",\n                    abi: [\n                        {\n                            type: \"function\",\n                            name: \"foo\",\n                            inputs: [{ name: \"x\", type: \"uint256\" }],\n                            outputs: [{ name: \"\", type: \"bool\" }],\n                        },\n                    ],\n                },\n                {\n                    library: \"@b/two\",\n                    abi: [\n                        {\n                            type: \"function\",\n                            name: \"bar\",\n                            inputs: [],\n                            outputs: [{ name: \"\", type: \"address\" }],\n                        },\n                    ],\n                },\n            ]);\n\n            expect(result).toContain('\"@a/one\"');\n            expect(result).toContain('\"@b/two\"');\n            expect(result).toContain(\"foo: { args: [x: bigint]; response: boolean };\");\n            expect(result).toContain(\"bar: { args: []; response: HexString };\");\n        });\n\n        test(\"empty contracts list\", () => {\n            const result = generateContractTypes([]);\n            expect(result).toContain(\"interface Contracts {\");\n            expect(result).toContain(\"}\");\n        });\n\n        test(\"includes polkadot-api type imports\", () => {\n            const result = generateContractTypes([]);\n            expect(result).toContain(\"import type { HexString, SizedHex }\");\n            expect(result).toContain('from \"polkadot-api\"');\n        });\n    });\n\n    describe(\"resolveContractTypeInputs\", () => {\n        test(\"passes inline { library, abi } through unchanged\", async () => {\n            const abi: AbiEntry[] = [\n                {\n                    type: \"function\",\n                    name: \"foo\",\n                    inputs: [],\n                    outputs: [{ name: \"\", type: \"bool\" }],\n                },\n            ];\n            const out = await resolveContractTypeInputs([{ library: \"@x/foo\", abi }]);\n            expect(out).toEqual([{ library: \"@x/foo\", abi }]);\n        });\n\n        test(\"loads ABI from { abiPath } on disk\", async () => {\n            const fs = await import(\"node:fs/promises\");\n            const path = await import(\"node:path\");\n            const os = await import(\"node:os\");\n            const tmp = await fs.mkdtemp(path.join(os.tmpdir(), \"codegen-\"));\n            const abi: AbiEntry[] = [\n                {\n                    type: \"function\",\n                    name: \"ping\",\n                    inputs: [],\n                    outputs: [{ name: \"\", type: \"bool\" }],\n                },\n            ];\n            const file = path.join(tmp, \"ping.release.abi.json\");\n            await fs.writeFile(file, JSON.stringify(abi), \"utf8\");\n            try {\n                const out = await resolveContractTypeInputs([\n                    { library: \"@x/ping\", abiPath: file },\n                ]);\n                expect(out).toEqual([{ library: \"@x/ping\", abi }]);\n\n                // And it composes with generateContractTypes end-to-end:\n                const src = generateContractTypes(out);\n                expect(src).toContain('\"@x/ping\"');\n                expect(src).toContain(\"ping: { args: []; response: boolean };\");\n            } finally {\n                await fs.rm(tmp, { recursive: true, force: true });\n            }\n        });\n    });\n}\n"]}