@parity/product-sdk-contracts 0.0.0-dev.312.0

package/dist/index.js

@@ -0,0 +1,630 @@
+import { ok, err } from '@parity/result';
+import { isValidH160, ss58ToH160, isValidSs58 } from '@parity/product-sdk-address';
+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';
+
+// src/manager.ts
+var ContractError = class extends Error {
+  isSdkError = true;
+  source = "contracts";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ContractError";
+  }
+};
+var ContractSignerMissingError = class extends ContractError {
+  constructor() {
+    super(
+      "No signer available. Pass { signer } in call options, set defaultSigner, or provide a signerManager."
+    );
+    this.name = "ContractSignerMissingError";
+  }
+};
+var ContractNotFoundError = class extends ContractError {
+  library;
+  constructor(library) {
+    super(`Contract "${library}" not found in cdm.json`);
+    this.name = "ContractNotFoundError";
+    this.library = library;
+  }
+};
+var ContractInvalidOriginError = class extends ContractError {
+  /** The rejected origin value. */
+  origin;
+  constructor(origin) {
+    const h160Hint = isValidH160(origin) ? " (looks like an H160 \u2014 convert it with h160ToSs58 from @parity/product-sdk-address first)" : "";
+    super(`Contract call origin must be an SS58 address, got "${origin}"${h160Hint}`);
+    this.name = "ContractInvalidOriginError";
+    this.origin = origin;
+  }
+};
+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 {
+  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;
+  }
+};
+function stringifyArg(arg) {
+  if (typeof arg === "bigint") return arg.toString();
+  return JSON.stringify(arg, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+var ContractRevertedError = class extends ContractError {
+  methodName;
+  data;
+  reason;
+  decoded;
+  constructor(methodName, data, info) {
+    const suffix = info?.reason ?? (info?.decoded ? `${info.decoded.errorName}(${(info.decoded.args ?? []).map(stringifyArg).join(", ")})` : data);
+    super(
+      `Contract reverted in "${methodName}": ${suffix}. The transaction was not submitted.`
+    );
+    this.name = "ContractRevertedError";
+    this.methodName = methodName;
+    this.data = data;
+    this.reason = info?.reason;
+    this.decoded = info?.decoded;
+  }
+};
+var log = createLogger("contracts");
+function buildMethodArgMap(abi) {
+  const map = {};
+  for (const entry of abi) {
+    if (entry.type === "function" && entry.name) {
+      map[entry.name] = entry.inputs.map((p) => p.name);
+    }
+  }
+  return map;
+}
+function extractOverrides(argNames, args) {
+  if (args.length > argNames.length && args.length > 0) {
+    const last = args[args.length - 1];
+    if (last && typeof last === "object" && !Array.isArray(last)) {
+      return { positionalArgs: args.slice(0, -1), overrides: last };
+    }
+  }
+  return { positionalArgs: args };
+}
+var REVIVE_PALLET_ACCOUNT = new Uint8Array(32);
+REVIVE_PALLET_ACCOUNT.set(new TextEncoder().encode("modlpy/reviv"));
+var QUERY_FALLBACK_ORIGIN = ss58Address(REVIVE_PALLET_ACCOUNT);
+function resolveOrigin(defaults, override, forQuery) {
+  if (override) return override;
+  const sourceAddr = defaults.signerManager?.getState().selectedAccount?.address;
+  if (sourceAddr) return sourceAddr;
+  if (defaults.origin) return defaults.origin;
+  if (forQuery) {
+    log.warn("No origin configured \u2014 using pallet-revive account fallback for query dry-run");
+    return QUERY_FALLBACK_ORIGIN;
+  }
+  return void 0;
+}
+function resolveSigner(defaults, override) {
+  return override ?? defaults.signerManager?.getSigner() ?? defaults.signer;
+}
+function validateOrigin(origin) {
+  return isValidSs58(origin) ? null : new ContractInvalidOriginError(origin);
+}
+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;
+}
+var REVERT_FLAG = 1;
+var PANIC_REASONS = {
+  "0x01": "assertion failed",
+  "0x11": "arithmetic overflow",
+  "0x12": "division by zero",
+  "0x21": "invalid enum value",
+  "0x22": "improperly encoded storage byte array",
+  "0x31": "pop on empty array",
+  "0x32": "array index out of bounds",
+  "0x41": "memory allocation overflow",
+  "0x51": "call to uninitialized internal function"
+};
+function decodeRevert(abi, data) {
+  const hex = bytesToHex(data);
+  const info = {
+    type: "ContractRevertedWithPayload",
+    data: hex
+  };
+  if (data.byteLength === 0) return info;
+  try {
+    const decoded = decodeErrorResult({
+      abi,
+      data: hex
+    });
+    info.decoded = {
+      errorName: decoded.errorName,
+      args: decoded.args
+    };
+    if (decoded.errorName === "Error" && typeof decoded.args?.[0] === "string") {
+      info.reason = decoded.args[0];
+    } else if (decoded.errorName === "Panic" && typeof decoded.args?.[0] === "bigint") {
+      const code = `0x${decoded.args[0].toString(16).padStart(2, "0")}`;
+      info.reason = PANIC_REASONS[code] ? `Panic: ${PANIC_REASONS[code]}` : `Panic(${code})`;
+    }
+    return info;
+  } catch {
+    try {
+      info.reason = new TextDecoder("utf-8", { fatal: true }).decode(data);
+    } catch {
+    }
+    return info;
+  }
+}
+function encodeCalldata(abi, methodName, args) {
+  return encodeFunctionData({
+    abi,
+    functionName: methodName,
+    args
+  });
+}
+function decodeReturn(abi, methodName, returnData) {
+  if (returnData.byteLength === 0) return void 0;
+  const decoded = decodeFunctionResult({
+    abi,
+    functionName: methodName,
+    data: bytesToHex(returnData)
+  });
+  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,
+      overrides?.at !== void 0 ? { at: overrides.at } : void 0
+    );
+    if (!dryRun.result.success) {
+      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 });
+      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 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);
+  const dest = normalizeContractAddress(address);
+  return new Proxy({}, {
+    get(_, methodName) {
+      if (typeof methodName !== "string") return void 0;
+      const argNames = methodArgs[methodName];
+      if (!argNames) return void 0;
+      return {
+        query: async (...args) => {
+          const { positionalArgs, overrides } = extractOverrides(
+            argNames,
+            args
+          );
+          const origin = resolveOrigin(defaults, overrides?.origin, true);
+          const originError = validateOrigin(origin);
+          if (originError) throw originError;
+          const value = overrides?.value ?? 0n;
+          const calldata = hexToBytes(encodeCalldata(abi, methodName, positionalArgs));
+          const dryRun = await runtime.dryRunCall(
+            origin,
+            dest,
+            value,
+            void 0,
+            void 0,
+            calldata,
+            overrides?.at !== void 0 ? { at: overrides.at } : void 0
+          );
+          if (!dryRun.result.success) {
+            return {
+              success: false,
+              value: dryRun.result.value,
+              gasRequired: dryRun.weight_required
+            };
+          }
+          if ((dryRun.result.value.flags & REVERT_FLAG) !== 0) {
+            const info = decodeRevert(abi, dryRun.result.value.data);
+            log.debug("Contract reverted", {
+              methodName,
+              reason: info.reason,
+              errorName: info.decoded?.errorName
+            });
+            return {
+              success: false,
+              value: info,
+              gasRequired: dryRun.weight_required
+            };
+          }
+          const decoded = decodeReturn(abi, methodName, dryRun.result.value.data);
+          return {
+            success: true,
+            value: decoded,
+            gasRequired: dryRun.weight_required
+          };
+        },
+        tx: async (...args) => {
+          const { positionalArgs, overrides } = extractOverrides(
+            argNames,
+            args
+          );
+          const signer = resolveSigner(defaults, overrides?.signer);
+          if (!signer) {
+            return err(new ContractSignerMissingError());
+          }
+          const origin = resolveOrigin(defaults, overrides?.origin) ?? ss58Address(signer.publicKey);
+          const originError = validateOrigin(origin);
+          if (originError) return err(originError);
+          const built = await buildReviveCall(
+            runtime,
+            dest,
+            abi,
+            methodName,
+            positionalArgs,
+            origin,
+            overrides
+          );
+          if (!built.ok) return built;
+          return submitAndWatch(built.value, signer, {
+            waitFor: overrides?.waitFor,
+            timeoutMs: overrides?.timeoutMs,
+            mortalityPeriod: overrides?.mortalityPeriod,
+            onStatus: overrides?.onStatus
+          });
+        },
+        prepare: async (...args) => {
+          const { positionalArgs, overrides } = extractOverrides(
+            argNames,
+            args
+          );
+          const origin = resolveOrigin(defaults, overrides?.origin, true);
+          const originError = validateOrigin(origin);
+          if (originError) return err(originError);
+          return buildReviveCall(
+            runtime,
+            dest,
+            abi,
+            methodName,
+            positionalArgs,
+            origin,
+            overrides
+          );
+        }
+      };
+    }
+  });
+}
+function createContractRuntime(api, options) {
+  const defaultAt = options?.at ?? "best";
+  return {
+    api,
+    dryRunCall: (origin, dest, value, gas, deposit, data, callOpts) => api.apis.ReviveApi.call(origin, dest, value, gas, deposit, data, {
+      at: callOpts?.at ?? defaultAt
+    })
+  };
+}
+function createContractRuntimeFromClient(client, descriptor, options) {
+  const defaultAt = options?.at ?? "best";
+  const typed = client.getTypedApi(
+    descriptor
+  );
+  const unsafe = client.getUnsafeApi();
+  return {
+    api: typed,
+    dryRunCall: (origin, dest, value, gas, deposit, data, callOpts) => unsafe.apis.ReviveApi.call(origin, dest, value, gas, deposit, data, {
+      at: callOpts?.at ?? defaultAt
+    })
+  };
+}
+async function ensureContractAccountMapped(runtime, address, signer, options) {
+  const checker = {
+    addressIsMapped: async (addr) => {
+      const mapped = await isContractAccountMapped(runtime, addr);
+      if (!mapped.ok) throw mapped.error;
+      return mapped.value;
+    }
+  };
+  return ensureAccountMapped(address, signer, checker, runtime.api, options);
+}
+async function isContractAccountMapped(runtime, address) {
+  try {
+    const h160 = ss58ToH160(address);
+    const mapped = await runtime.api.query.Revive.OriginalAccount.getValue(h160) !== void 0;
+    return ok(mapped);
+  } catch (cause) {
+    return err(
+      new ContractError(`Failed to check pallet-revive mapping for ${address}`, { cause })
+    );
+  }
+}
+
+// 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) {
+  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 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 }
+      )
+    );
+  }
+}
+var ContractManager = class _ContractManager {
+  contracts;
+  runtime;
+  defaults;
+  constructor(cdmJson, runtime, options) {
+    this.runtime = runtime;
+    this.contracts = cdmJson.contracts;
+    this.defaults = {
+      signerManager: options?.signerManager,
+      origin: options?.defaultOrigin,
+      signer: options?.defaultSigner
+    };
+  }
+  /** Update the default origin, signer, or signerManager used by all contract handles. */
+  setDefaults(defaults) {
+    if (defaults.signerManager !== void 0)
+      this.defaults.signerManager = defaults.signerManager;
+    if (defaults.origin !== void 0) this.defaults.origin = defaults.origin;
+    if (defaults.signer !== void 0) this.defaults.signer = defaults.signer;
+  }
+  /**
+   * Create a `ContractManager` from a raw `PolkadotClient`.
+   *
+   * 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.
+   * @param descriptor - The chain descriptor used to derive the typed API.
+   * @param options - Optional configuration (signerManager, defaults).
+   */
+  static fromClient(cdmJson, client, descriptor, options) {
+    return new _ContractManager(
+      cdmJson,
+      createContractRuntimeFromClient(client, descriptor, options),
+      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
+    });
+    if (!resolved.ok) return resolved;
+    return ok(new _ContractManager(resolved.value, 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) {
+    if (!this.contracts || !(library in this.contracts)) {
+      throw new ContractNotFoundError(library);
+    }
+    return this.contracts[library];
+  }
+  getContract(library) {
+    const data = this.getContractData(library);
+    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(runtime, address, abi, options) {
+  const defaults = {
+    signerManager: options?.signerManager,
+    origin: options?.defaultOrigin,
+    signer: options?.defaultSigner
+  };
+  return wrapContract(runtime, address, abi, defaults);
+}
+function createContractFromClient(client, descriptor, address, abi, options) {
+  return createContract(
+    createContractRuntimeFromClient(client, descriptor, options),
+    address,
+    abi,
+    options
+  );
+}
+
+export { ContractDryRunFailedError, ContractError, ContractInvalidOriginError, ContractLiveAddressResolutionError, ContractManager, ContractNotFoundError, ContractRevertedError, ContractSignerMissingError, QUERY_FALLBACK_ORIGIN, createContract, createContractFromClient, createContractRuntime, createContractRuntimeFromClient, ensureContractAccountMapped, isContractAccountMapped, withLiveContractAddresses };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map