@parity/product-sdk-contracts 0.2.2 → 0.5.0

package/dist/index.js

@@ -1,8 +1,11 @@
-export { generateContractTypes } from './chunk-E7AP65D4.js';
-import { submitAndWatch } from '@parity/product-sdk-tx';
+import { encodeFunctionData, decodeFunctionResult } from 'viem';
+import { ensureAccountMapped, submitAndWatch } from '@parity/product-sdk-tx';
 import { seedToAccount } from '@parity/product-sdk-keys';
 import { createLogger } from '@parity/product-sdk-logger';
 import { DEV_PHRASE, ss58Address } from '@polkadot-labs/hdkd-helpers';
+import { ss58ToH160 } from '@parity/product-sdk-address';
+
+// src/wrap.ts
 
 // src/errors.ts
 var ContractError = class extends Error {
@@ -29,6 +32,18 @@ var ContractNotFoundError = class extends ContractError {
     this.targetHash = targetHash;
   }
 };
+var ContractDryRunFailedError = class extends ContractError {
+  methodName;
+  dispatchError;
+  constructor(methodName, dispatchError) {
+    super(
+      `Dry-run failed for "${methodName}": ${typeof dispatchError === "string" ? dispatchError : JSON.stringify(dispatchError)}. The transaction was not submitted.`
+    );
+    this.name = "ContractDryRunFailedError";
+    this.methodName = methodName;
+    this.dispatchError = dispatchError;
+  }
+};
 
 // src/wrap.ts
 var log = createLogger("contracts");
@@ -41,13 +56,6 @@ function buildMethodArgMap(abi) {
   }
   return map;
 }
-function positionalToNamed(argNames, values) {
-  const data = {};
-  for (let i = 0; i < argNames.length; i++) {
-    data[argNames[i]] = values[i];
-  }
-  return data;
-}
 function extractOverrides(argNames, args) {
   if (args.length > argNames.length && args.length > 0) {
     const last = args[args.length - 1];
@@ -72,8 +80,81 @@ function resolveOrigin(defaults, override, forQuery) {
 function resolveSigner(defaults, override) {
   return override ?? defaults.signerManager?.getSigner() ?? defaults.signer;
 }
-function wrapContract(inkContract, abi, defaults) {
+function normalizeContractAddress(address) {
+  const hex = address.startsWith("0x") ? address.slice(2) : address;
+  if (hex.length !== 40) {
+    throw new Error(`Expected 20-byte H160 contract address, got ${hex.length / 2} bytes`);
+  }
+  return `0x${hex.toLowerCase()}`;
+}
+function hexToBytes(hex) {
+  const stripped = hex.slice(2);
+  const out = new Uint8Array(stripped.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(stripped.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function encodeCalldata(abi, methodName, args) {
+  return encodeFunctionData({
+    abi,
+    functionName: methodName,
+    args
+  });
+}
+function decodeReturn(abi, methodName, returnData) {
+  if (returnData.byteLength === 0) return void 0;
+  let hex = "0x";
+  for (let i = 0; i < returnData.byteLength; i++) {
+    hex += returnData[i].toString(16).padStart(2, "0");
+  }
+  const decoded = decodeFunctionResult({
+    abi,
+    functionName: methodName,
+    data: hex
+  });
+  const entry = abi.find((e) => e.type === "function" && e.name === methodName);
+  const outputs = entry?.outputs ?? [];
+  if (outputs.length <= 1 || !Array.isArray(decoded)) return decoded;
+  const obj = {};
+  for (let i = 0; i < outputs.length; i++) {
+    obj[outputs[i].name || `_${i}`] = decoded[i];
+  }
+  return obj;
+}
+async function buildReviveCall(runtime, dest, abi, methodName, positionalArgs, origin, overrides) {
+  const value = overrides?.value ?? 0n;
+  const calldata = hexToBytes(encodeCalldata(abi, methodName, positionalArgs));
+  let weightLimit = overrides?.gasLimit;
+  let storageDepositLimit = overrides?.storageDepositLimit;
+  if (weightLimit === void 0 || storageDepositLimit === void 0) {
+    const dryRun = await runtime.dryRunCall(
+      origin,
+      dest,
+      value,
+      void 0,
+      void 0,
+      calldata
+    );
+    if (!dryRun.result.success) {
+      throw new ContractDryRunFailedError(methodName, dryRun.result.value);
+    }
+    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
+  });
+}
+function wrapContract(runtime, address, abi, defaults) {
   const methodArgs = buildMethodArgMap(abi);
+  const dest = normalizeContractAddress(address);
   return new Proxy({}, {
     get(_, methodName) {
       if (typeof methodName !== "string") return void 0;
@@ -85,17 +166,29 @@ function wrapContract(inkContract, abi, defaults) {
             argNames,
             args
           );
-          const data = positionalToNamed(argNames, positionalArgs);
           const origin = resolveOrigin(defaults, overrides?.origin, true);
-          const result = await inkContract.query(methodName, {
+          const value = overrides?.value ?? 0n;
+          const calldata = hexToBytes(encodeCalldata(abi, methodName, positionalArgs));
+          const dryRun = await runtime.dryRunCall(
             origin,
-            data,
-            ...overrides?.value !== void 0 && { value: overrides.value }
-          });
+            dest,
+            value,
+            void 0,
+            void 0,
+            calldata
+          );
+          if (!dryRun.result.success) {
+            return {
+              success: false,
+              value: dryRun.result.value,
+              gasRequired: dryRun.weight_required
+            };
+          }
+          const decoded = decodeReturn(abi, methodName, dryRun.result.value.data);
           return {
-            success: result.success,
-            value: result.success ? result.value.response : void 0,
-            gasRequired: result.value?.gasRequired
+            success: true,
+            value: decoded,
+            gasRequired: dryRun.weight_required
           };
         },
         tx: async (...args) => {
@@ -103,59 +196,82 @@ function wrapContract(inkContract, abi, defaults) {
             argNames,
             args
           );
-          const data = positionalToNamed(argNames, positionalArgs);
           const signer = resolveSigner(defaults, overrides?.signer);
           if (!signer) {
             throw new ContractSignerMissingError();
           }
           const origin = resolveOrigin(defaults, overrides?.origin) ?? ss58Address(signer.publicKey);
-          const inkTx = inkContract.send(methodName, {
-            data,
+          const tx = await buildReviveCall(
+            runtime,
+            dest,
+            abi,
+            methodName,
+            positionalArgs,
             origin,
-            ...overrides?.value !== void 0 && { value: overrides.value },
-            ...overrides?.gasLimit && { gasLimit: overrides.gasLimit },
-            ...overrides?.storageDepositLimit !== void 0 && {
-              storageDepositLimit: overrides.storageDepositLimit
-            }
-          });
-          return submitAndWatch(inkTx, signer, {
+            overrides
+          );
+          return submitAndWatch(tx, signer, {
             waitFor: overrides?.waitFor,
             timeoutMs: overrides?.timeoutMs,
             mortalityPeriod: overrides?.mortalityPeriod,
             onStatus: overrides?.onStatus
           });
         },
-        prepare: (...args) => {
+        prepare: async (...args) => {
           const { positionalArgs, overrides } = extractOverrides(
             argNames,
             args
           );
-          const data = positionalToNamed(argNames, positionalArgs);
           const origin = resolveOrigin(defaults, overrides?.origin, true);
-          return inkContract.send(methodName, {
-            data,
+          return buildReviveCall(
+            runtime,
+            dest,
+            abi,
+            methodName,
+            positionalArgs,
             origin,
-            ...overrides?.value !== void 0 && { value: overrides.value },
-            ...overrides?.gasLimit && { gasLimit: overrides.gasLimit },
-            ...overrides?.storageDepositLimit !== void 0 && {
-              storageDepositLimit: overrides.storageDepositLimit
-            }
-          });
+            overrides
+          );
         }
       };
     }
   });
 }
+function createContractRuntime(api) {
+  return {
+    api,
+    dryRunCall: (origin, dest, value, gas, deposit, data) => api.apis.ReviveApi.call(origin, dest, value, gas, deposit, data)
+  };
+}
+function createContractRuntimeFromClient(client, descriptor) {
+  const typed = client.getTypedApi(
+    descriptor
+  );
+  const unsafe = client.getUnsafeApi();
+  return {
+    api: typed,
+    dryRunCall: (origin, dest, value, gas, deposit, data) => unsafe.apis.ReviveApi.call(origin, dest, value, gas, deposit, data)
+  };
+}
+async function ensureContractAccountMapped(runtime, address, signer, options) {
+  const checker = {
+    addressIsMapped: async (addr) => {
+      const h160 = ss58ToH160(addr);
+      return await runtime.api.query.Revive.OriginalAccount.getValue(h160) !== void 0;
+    }
+  };
+  return ensureAccountMapped(address, signer, checker, runtime.api, options);
+}
 
 // src/manager.ts
 var ContractManager = class _ContractManager {
   cdmJson;
   targetHash;
-  inkSdk;
+  runtime;
   defaults;
-  constructor(cdmJson, inkSdk, options) {
+  constructor(cdmJson, runtime, options) {
     this.cdmJson = cdmJson;
-    this.inkSdk = inkSdk;
+    this.runtime = runtime;
     if (options?.targetHash) {
       this.targetHash = options.targetHash;
     } else {
@@ -177,38 +293,24 @@ var ContractManager = class _ContractManager {
     if (defaults.signer !== void 0) this.defaults.signer = defaults.signer;
   }
   /**
-   * Create a ContractManager from a raw `PolkadotClient`.
+   * Create a `ContractManager` from a raw `PolkadotClient`.
    *
-   * Convenience factory that creates the InkSdk internally via dynamic import
-   * of `@polkadot-api/sdk-ink`. The ~4 MB sdk-ink metadata is loaded lazily
-   * only when this method is called.
-   *
-   * For size-sensitive apps, prefer the constructor with a pre-created `InkSdk`
-   * to control exactly when `@polkadot-api/sdk-ink` is loaded.
+   * Convenience factory: builds a `ContractRuntime` internally from the
+   * client's typed API. Requires that the chain's typed API exposes the
+   * `Revive` pallet and `ReviveApi` runtime API (Asset Hub Paseo /
+   * Polkadot / Kusama).
    *
    * @param cdmJson - The CDM manifest.
-   * @param client - A `PolkadotClient` for the chain where contracts are deployed (e.g., `client.raw.assetHub`).
+   * @param client - A `PolkadotClient` for the chain where contracts are deployed.
+   * @param descriptor - The chain descriptor used to derive the typed API.
    * @param options - Optional configuration (signerManager, defaults).
-   *
-   * @example
-   * ```ts
-   * import { createChainClient } from "@parity/product-sdk-chain-client";
-   * import { paseo_asset_hub } from "@parity/product-sdk-descriptors/paseo-asset-hub";
-   * import { ContractManager } from "@parity/product-sdk-contracts";
-   *
-   * const client = await createChainClient({
-   *     chains: { assetHub: paseo_asset_hub },
-   *     rpcs: { assetHub: ["wss://sys.ibp.network/asset-hub-paseo"] },
-   * });
-   * const manager = await ContractManager.fromClient(cdmJson, client.raw.assetHub, {
-   *     signerManager,
-   * });
-   * ```
    */
-  static async fromClient(cdmJson, client, options) {
-    const { createInkSdk } = await import('@polkadot-api/sdk-ink');
-    const inkSdk = createInkSdk(client, { atBest: true });
-    return new _ContractManager(cdmJson, inkSdk, options);
+  static fromClient(cdmJson, client, descriptor, options) {
+    return new _ContractManager(
+      cdmJson,
+      createContractRuntimeFromClient(client, descriptor),
+      options
+    );
   }
   getContractData(library) {
     const contractsForTarget = this.cdmJson.contracts?.[this.targetHash];
@@ -219,30 +321,41 @@ var ContractManager = class _ContractManager {
   }
   getContract(library) {
     const data = this.getContractData(library);
-    const descriptor = { abi: data.abi };
-    const inkContract = this.inkSdk.getContract(descriptor, data.address);
-    return wrapContract(inkContract, data.abi, this.defaults);
+    return wrapContract(this.runtime, data.address, data.abi, this.defaults);
   }
   /** Get the on-chain address of an installed contract. */
   getAddress(library) {
     return this.getContractData(library).address;
   }
+  /**
+   * Get the underlying {@link ContractRuntime} backing this manager.
+   *
+   * Useful when a consumer needs to call helpers that take a runtime
+   * directly — most commonly {@link ensureContractAccountMapped} at app
+   * boot. Avoids the alternative of building a second runtime against the
+   * same client and descriptor.
+   */
+  getRuntime() {
+    return this.runtime;
+  }
 };
-function createContract(inkSdk, address, abi, options) {
-  const inkContract = inkSdk.getContract({ abi }, address);
+function createContract(runtime, address, abi, options) {
   const defaults = {
     signerManager: options?.signerManager,
     origin: options?.defaultOrigin,
     signer: options?.defaultSigner
   };
-  return wrapContract(inkContract, abi, defaults);
+  return wrapContract(runtime, address, abi, defaults);
 }
-async function createContractFromClient(client, address, abi, options) {
-  const { createInkSdk } = await import('@polkadot-api/sdk-ink');
-  const inkSdk = createInkSdk(client, { atBest: true });
-  return createContract(inkSdk, address, abi, options);
+function createContractFromClient(client, descriptor, address, abi, options) {
+  return createContract(
+    createContractRuntimeFromClient(client, descriptor),
+    address,
+    abi,
+    options
+  );
 }
 
-export { ContractError, ContractManager, ContractNotFoundError, ContractSignerMissingError, createContract, createContractFromClient };
+export { ContractDryRunFailedError, ContractError, ContractManager, ContractNotFoundError, ContractSignerMissingError, createContract, createContractFromClient, createContractRuntime, createContractRuntimeFromClient, ensureContractAccountMapped };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map