@dedot/contracts 0.17.0 → 0.17.1-next.db98ff20.1

package/utils/ensure.js

@@ -4,27 +4,35 @@ export const ensureStorageApiSupports = (version) => {
     const numberedVersion = typeof version === 'number' ? version : parseInt(version);
     assert(numberedVersion >= 5, `Contract Storage Api Only Available for metadata version >= 5, current version: ${version}`);
 };
-export function ensurePalletPresence(client, registry) {
-    if (registry.isRevive()) {
-        try {
-            !!client.call.reviveApi.call.meta && !!client.tx.revive.call.meta;
-        }
-        catch {
-            throw new DedotError('Pallet Revive is not available');
-        }
+function ensurePalletRevive(client) {
+    try {
+        !!client.call.reviveApi.call.meta && !!client.tx.revive.call.meta;
     }
-    else {
-        try {
-            !!client.call.contractsApi.call.meta && !!client.tx.contracts.call.meta;
-        }
-        catch {
-            throw new DedotError('Pallet Contracts is not available');
-        }
+    catch {
+        throw new DedotError('Pallet Revive is not available');
     }
 }
-export async function ensureContractPresence(client, registry, address) {
+function ensurePalletContracts(client) {
+    try {
+        !!client.call.contractsApi.call.meta && !!client.tx.contracts.call.meta;
+    }
+    catch {
+        throw new DedotError('Pallet Contracts is not available');
+    }
+}
+export function ensurePalletPresence(client, isRevive) {
+    isRevive ? ensurePalletRevive(client) : ensurePalletContracts(client);
+}
+export async function ensureContractPresence(client, isRevive, address, cache) {
+    // Check cache first if available
+    if (cache) {
+        const cached = cache.get(`${isRevive}::${address}`);
+        if (cached) {
+            return; // Contract presence was already verified
+        }
+    }
     const contractInfo = await (async () => {
-        if (registry.isRevive()) {
+        if (isRevive) {
             const accountInfo = await client.query.revive.accountInfoOf(address);
             if (accountInfo?.accountType && accountInfo?.accountType?.type === 'Contract') {
                 return accountInfo.accountType.value;
@@ -35,17 +43,25 @@ export async function ensureContractPresence(client, registry, address) {
         }
     })();
     ensurePresence(contractInfo, `Contract with address ${address} does not exist on chain!`);
+    // Cache successful presence check
+    if (cache) {
+        cache.set(`${isRevive}::${address}`, true);
+    }
 }
-export function ensureValidContractAddress(address, registry) {
-    if (registry.isRevive()) {
+export function ensureValidContractAddress(address, isRevive) {
+    if (isRevive) {
         assert(isEvmAddress(address), `Invalid contract address: ${address}. Expected an EVM 20-byte address as a hex string or a Uint8Array`);
     }
     else {
-        assert(hexToU8a(accountId32ToHex(address)).length === 32, `Invalid contract address: ${address}. Expected a Substrate 32-byte address as a hex string or a Uint8Array`);
+        ensureValidAccountId32Address(address, `Invalid contract address: ${address}. Expected a Substrate 32-byte address as a hex string or a Uint8Array`);
     }
 }
-export function ensureValidCodeHashOrCode(codeHashOrCode, registry) {
-    assert(toU8a(codeHashOrCode).length === 32 || (registry.isRevive() ? isPvm(codeHashOrCode) : isWasm(codeHashOrCode)), 'Invalid code hash or code: expected a hash of 32-byte or a valid PVM/WASM code as a hex string or a Uint8Array');
+export function ensureValidAccountId32Address(address, customErrorMessage) {
+    assert(hexToU8a(accountId32ToHex(address)).length === 32, customErrorMessage ||
+        `Invalid AccountId32 address: ${address}. Expected a Substrate 32-byte address as a hex string or a Uint8Array`);
+}
+export function ensureValidCodeHashOrCode(codeHashOrCode, isRevive) {
+    assert(toU8a(codeHashOrCode).length === 32 || (isRevive ? isPvm(codeHashOrCode) : isWasm(codeHashOrCode)), 'Invalid code hash or code: expected a hash of 32-byte or a valid PVM/WASM code as a hex string or a Uint8Array');
 }
 const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
 const SUPPORTED_VERSIONS = [6, 5, '4'];

package/utils/types.d.ts

@@ -1,5 +1,6 @@
-import { PortableType, TypeDef } from '@dedot/codecs';
-import { ContractMetadata, ContractTypeDef, ReturnFlags } from 'src/types';
+import { AccountId32, Bytes, H160, H256, PortableType, TypeDef } from '@dedot/codecs';
+import { IRuntimeEvent } from '@dedot/codecs/types';
+import { ContractMetadata, ContractTypeDef, ReturnFlags } from '../types/index.js';
 export declare const extractContractTypes: (contractMetadata: ContractMetadata) => PortableType[];
 export declare const normalizeContractTypeDef: (def: ContractTypeDef) => TypeDef;
 export declare function normalizeLabel(label?: string): string;
@@ -15,3 +16,20 @@ export declare enum KnownLazyType {
  * @param typePath
  */
 export declare function isLazyType(typePath?: string | string[] | undefined): KnownLazyType | undefined;
+export type KnownPallets = 'Contracts' | 'Revive';
+export interface ContractEmittedEvent<Pallet extends KnownPallets = 'Contracts'> extends IRuntimeEvent {
+    pallet: Pallet;
+    palletEvent: {
+        name: 'ContractEmitted';
+        data: Pallet extends 'Contracts' ? {
+            contract: AccountId32;
+            data: Bytes;
+        } : {
+            contract: H160;
+            data: Bytes;
+            topics: Array<H256>;
+        };
+    };
+}
+export declare function isInkAbi(metadata: any): boolean;
+export declare function isSolAbi(metadata: any): boolean;

package/utils/types.js

@@ -117,3 +117,21 @@ export function isLazyType(typePath) {
     if (typePath === KNOWN_LAZY_TYPES.STORAGE_VEC)
         return KnownLazyType.STORAGE_VEC;
 }
+// https://use.ink/docs/v6/basics/metadata/ink/
+export function isInkAbi(metadata) {
+    return (metadata !== null && // --
+        'source' in metadata &&
+        'contract' in metadata &&
+        'spec' in metadata);
+}
+// https://docs.soliditylang.org/en/latest/abi-spec.html#json
+export function isSolAbi(metadata) {
+    return (Array.isArray(metadata) &&
+        metadata.length > 0 &&
+        metadata.some((item) => item.type === 'function' ||
+            item.type === 'constructor' ||
+            item.type === 'event' ||
+            item.type === 'error' ||
+            item.type === 'fallback' ||
+            item.type === 'receive'));
+}