@pezkuwi/api 16.5.8 → 16.5.10

package/build/base/Init.js

@@ -1,400 +0,0 @@
-import { firstValueFrom, map, of, switchMap } from 'rxjs';
-import { Metadata, TypeRegistry } from '@pezkuwi/types';
-import { LATEST_EXTRINSIC_VERSION } from '@pezkuwi/types/extrinsic/constants';
-import { getSpecAlias, getSpecExtensions, getSpecHasher, getSpecRpc, getSpecTypes, getUpgradeVersion } from '@pezkuwi/types-known';
-import { assertReturn, BN_ZERO, isUndefined, logger, noop, objectSpread, u8aEq, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { blake2AsHex, cryptoWaitReady } from '@pezkuwi/util-crypto';
-import { Decorate } from './Decorate.js';
-const KEEPALIVE_INTERVAL = 10000;
-const WITH_VERSION_SHORTCUT = false;
-const SUPPORTED_METADATA_VERSIONS = [16, 15, 14];
-const l = logger('api/init');
-function textToString(t) {
-    return t.toString();
-}
-export class Init extends Decorate {
-    #atLast = null;
-    #healthTimer = null;
-    #registries = [];
-    #updateSub = null;
-    #waitingRegistries = {};
-    constructor(options, type, decorateMethod) {
-        super(options, type, decorateMethod);
-        // all injected types added to the registry for overrides
-        this.registry.setKnownTypes(options);
-        // We only register the types (global) if this is not a cloned instance.
-        // Do right up-front, so we get in the user types before we are actually
-        // doing anything on-chain, this ensures we have the overrides in-place
-        if (!options.source) {
-            this.registerTypes(options.types);
-        }
-        else {
-            this.#registries = options.source.#registries;
-        }
-        this._rpc = this._decorateRpc(this._rpcCore, this._decorateMethod);
-        this._rx.rpc = this._decorateRpc(this._rpcCore, this._rxDecorateMethod);
-        if (this.supportMulti) {
-            this._queryMulti = this._decorateMulti(this._decorateMethod);
-            this._rx.queryMulti = this._decorateMulti(this._rxDecorateMethod);
-        }
-        this._rx.signer = options.signer;
-        this._rpcCore.setRegistrySwap((blockHash) => this.getBlockRegistry(blockHash));
-        this._rpcCore.setResolveBlockHash((blockNumber) => firstValueFrom(this._rpcCore.chain.getBlockHash(blockNumber)));
-        if (this.hasSubscriptions) {
-            this._rpcCore.provider.on('disconnected', () => this.#onProviderDisconnect());
-            this._rpcCore.provider.on('error', (e) => this.#onProviderError(e));
-            this._rpcCore.provider.on('connected', () => this.#onProviderConnect());
-        }
-        else if (!this._options.noInitWarn) {
-            l.warn('Api will be available in a limited mode since the provider does not support subscriptions');
-        }
-        // If the provider was instantiated earlier, and has already emitted a
-        // 'connected' event, then the `on('connected')` won't fire anymore. To
-        // cater for this case, we call manually `this._onProviderConnect`.
-        if (this._rpcCore.provider.isConnected) {
-            this.#onProviderConnect().catch(noop);
-        }
-    }
-    /**
-     * @description Decorates a registry based on the runtime version
-     */
-    _initRegistry(registry, chain, version, metadata, chainProps) {
-        registry.clearCache();
-        registry.setChainProperties(chainProps || this.registry.getChainProperties());
-        registry.setKnownTypes(this._options);
-        registry.register(getSpecTypes(registry, chain, version.specName, version.specVersion));
-        registry.setHasher(getSpecHasher(registry, chain, version.specName));
-        // for bundled types, pull through the aliases defined
-        if (registry.knownTypes.typesBundle) {
-            registry.knownTypes.typesAlias = getSpecAlias(registry, chain, version.specName);
-        }
-        registry.setMetadata(metadata, undefined, objectSpread({}, getSpecExtensions(registry, chain, version.specName), this._options.signedExtensions), this._options.noInitWarn);
-    }
-    /**
-     * @description Returns the default versioned registry
-     */
-    _getDefaultRegistry() {
-        return assertReturn(this.#registries.find(({ isDefault }) => isDefault), 'Initialization error, cannot find the default registry');
-    }
-    /**
-     * @description Returns a decorated API instance at a specific point in time
-     */
-    async at(blockHash, knownVersion) {
-        const u8aHash = u8aToU8a(blockHash);
-        const u8aHex = u8aToHex(u8aHash);
-        const registry = await this.getBlockRegistry(u8aHash, knownVersion);
-        if (!this.#atLast || this.#atLast[0] !== u8aHex) {
-            // always create a new decoration - since we are pointing to a specific hash, this
-            // means that all queries needs to use that hash (not a previous one already existing)
-            this.#atLast = [u8aHex, this._createDecorated(registry, true, null, u8aHash).decoratedApi];
-        }
-        return this.#atLast[1];
-    }
-    async _createBlockRegistry(blockHash, header, version) {
-        const registry = new TypeRegistry(blockHash);
-        const metadata = await this._retrieveMetadata(version.apis, header.parentHash, registry);
-        const runtimeChain = this._runtimeChain;
-        if (!runtimeChain) {
-            throw new Error('Invalid initializion order, runtimeChain is not available');
-        }
-        this._initRegistry(registry, runtimeChain, version, metadata);
-        // add our new registry
-        const result = { counter: 0, lastBlockHash: blockHash, metadata, registry, runtimeVersion: version };
-        this.#registries.push(result);
-        return result;
-    }
-    _cacheBlockRegistryProgress(key, creator) {
-        // look for waiting resolves
-        let waiting = this.#waitingRegistries[key];
-        if (isUndefined(waiting)) {
-            // nothing waiting, construct new
-            waiting = this.#waitingRegistries[key] = new Promise((resolve, reject) => {
-                creator()
-                    .then((registry) => {
-                    delete this.#waitingRegistries[key];
-                    resolve(registry);
-                })
-                    .catch((error) => {
-                    delete this.#waitingRegistries[key];
-                    reject(error);
-                });
-            });
-        }
-        return waiting;
-    }
-    _getBlockRegistryViaVersion(blockHash, version) {
-        if (version) {
-            // check for pre-existing registries. We also check specName, e.g. it
-            // could be changed like in Westmint with upgrade from shell -> westmint
-            const existingViaVersion = this.#registries.find(({ runtimeVersion: { specName, specVersion } }) => specName.eq(version.specName) &&
-                specVersion.eq(version.specVersion));
-            if (existingViaVersion) {
-                existingViaVersion.counter++;
-                existingViaVersion.lastBlockHash = blockHash;
-                return existingViaVersion;
-            }
-        }
-        return null;
-    }
-    async _getBlockRegistryViaHash(blockHash) {
-        // ensure we have everything required
-        if (!this._genesisHash || !this._runtimeVersion) {
-            throw new Error('Cannot retrieve data on an uninitialized chain');
-        }
-        // We have to assume that on the RPC layer the calls used here does not call back into
-        // the registry swap, so getHeader & getRuntimeVersion should not be historic
-        const header = this.registry.createType('HeaderPartial', this._genesisHash.eq(blockHash)
-            ? { number: BN_ZERO, parentHash: this._genesisHash }
-            : await firstValueFrom(this._rpcCore.chain.getHeader.raw(blockHash)));
-        if (header.parentHash.isEmpty) {
-            l.warn(`Unable to retrieve header ${blockHash.toString()} and parent ${header.parentHash.toString()} from supplied hash`);
-            throw new Error('Unable to retrieve header and parent from supplied hash');
-        }
-        // get the runtime version, either on-chain or via an known upgrade history
-        const [firstVersion, lastVersion] = getUpgradeVersion(this._genesisHash, header.number);
-        const version = this.registry.createType('RuntimeVersionPartial', WITH_VERSION_SHORTCUT && (firstVersion && (lastVersion ||
-            firstVersion.specVersion.eq(this._runtimeVersion.specVersion)))
-            ? { apis: firstVersion.apis, specName: this._runtimeVersion.specName, specVersion: firstVersion.specVersion }
-            : await firstValueFrom(this._rpcCore.state.getRuntimeVersion.raw(header.parentHash)));
-        return (
-        // try to find via version
-        this._getBlockRegistryViaVersion(blockHash, version) ||
-            // return new or in-flight result
-            await this._cacheBlockRegistryProgress(version.toHex(), () => this._createBlockRegistry(blockHash, header, version)));
-    }
-    /**
-     * @description Sets up a registry based on the block hash defined
-     */
-    async getBlockRegistry(blockHash, knownVersion) {
-        return (
-        // try to find via blockHash
-        this.#registries.find(({ lastBlockHash }) => lastBlockHash && u8aEq(lastBlockHash, blockHash)) ||
-            // try to find via version
-            this._getBlockRegistryViaVersion(blockHash, knownVersion) ||
-            // return new or in-flight result
-            await this._cacheBlockRegistryProgress(u8aToHex(blockHash), () => this._getBlockRegistryViaHash(blockHash)));
-    }
-    async _loadMeta() {
-        // on re-connection to the same chain, we don't want to re-do everything from chain again
-        if (this._isReady) {
-            // on re-connection only re-subscribe to chain updates if we are not a clone
-            if (!this._options.source) {
-                this._subscribeUpdates();
-            }
-            return true;
-        }
-        this._unsubscribeUpdates();
-        // only load from on-chain if we are not a clone (default path), alternatively
-        // just use the values from the source instance provided
-        [this._genesisHash, this._runtimeMetadata] = this._options.source?._isReady
-            ? await this._metaFromSource(this._options.source)
-            : await this._metaFromChain(this._options.metadata);
-        return this._initFromMeta(this._runtimeMetadata);
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async _metaFromSource(source) {
-        this._extrinsicType = source.extrinsicVersion;
-        this._runtimeChain = source.runtimeChain;
-        this._runtimeVersion = source.runtimeVersion;
-        // manually build a list of all available methods in this RPC, we are
-        // going to filter on it to align the cloned RPC without making a call
-        const sections = Object.keys(source.rpc);
-        const rpcs = [];
-        for (let s = 0, scount = sections.length; s < scount; s++) {
-            const section = sections[s];
-            const methods = Object.keys(source.rpc[section]);
-            for (let m = 0, mcount = methods.length; m < mcount; m++) {
-                rpcs.push(`${section}_${methods[m]}`);
-            }
-        }
-        this._filterRpc(rpcs, getSpecRpc(this.registry, source.runtimeChain, source.runtimeVersion.specName));
-        return [source.genesisHash, source.runtimeMetadata];
-    }
-    // subscribe to metadata updates, inject the types on changes
-    _subscribeUpdates() {
-        if (this.#updateSub || !this.hasSubscriptions) {
-            return;
-        }
-        this.#updateSub = this._rpcCore.state.subscribeRuntimeVersion().pipe(switchMap((version) => 
-        // only retrieve the metadata when the on-chain version has been changed
-        this._runtimeVersion?.specVersion.eq(version.specVersion)
-            ? of(false)
-            : this._rpcCore.state.getMetadata().pipe(map((metadata) => {
-                l.log(`Runtime version updated to spec=${version.specVersion.toString()}, tx=${version.transactionVersion.toString()}`);
-                this._runtimeMetadata = metadata;
-                this._runtimeVersion = version;
-                this._rx.runtimeVersion = version;
-                // update the default registry version
-                const thisRegistry = this._getDefaultRegistry();
-                const runtimeChain = this._runtimeChain;
-                if (!runtimeChain) {
-                    throw new Error('Invalid initializion order, runtimeChain is not available');
-                }
-                // setup the data as per the current versions
-                thisRegistry.metadata = metadata;
-                thisRegistry.runtimeVersion = version;
-                this._initRegistry(this.registry, runtimeChain, version, metadata);
-                this._injectMetadata(thisRegistry, true);
-                return true;
-            })))).subscribe();
-    }
-    async _metaFromChain(optMetadata) {
-        const [genesisHash, runtimeVersion, chain, chainProps, rpcMethods] = await Promise.all([
-            firstValueFrom(this._rpcCore.chain.getBlockHash(0)),
-            firstValueFrom(this._rpcCore.state.getRuntimeVersion()),
-            firstValueFrom(this._rpcCore.system.chain()),
-            firstValueFrom(this._rpcCore.system.properties()),
-            firstValueFrom(this._rpcCore.rpc.methods())
-        ]);
-        // set our chain version & genesisHash as returned
-        this._runtimeChain = chain;
-        this._runtimeVersion = runtimeVersion;
-        this._rx.runtimeVersion = runtimeVersion;
-        // retrieve metadata, either from chain  or as pass-in via options
-        const metadataKey = `${genesisHash.toHex() || '0x'}-${runtimeVersion.specVersion.toString()}`;
-        const metadata = optMetadata?.[metadataKey]
-            ? new Metadata(this.registry, optMetadata[metadataKey])
-            : await this._retrieveMetadata(runtimeVersion.apis);
-        // initializes the registry & RPC
-        this._initRegistry(this.registry, chain, runtimeVersion, metadata, chainProps);
-        this._filterRpc(rpcMethods.methods.map(textToString), getSpecRpc(this.registry, chain, runtimeVersion.specName));
-        this._subscribeUpdates();
-        // setup the initial registry, when we have none
-        if (!this.#registries.length) {
-            this.#registries.push({ counter: 0, isDefault: true, metadata, registry: this.registry, runtimeVersion });
-        }
-        // get unique types & validate
-        metadata.getUniqTypes(this._options.throwOnUnknown || false);
-        return [genesisHash, metadata];
-    }
-    _initFromMeta(metadata) {
-        const runtimeVersion = this._runtimeVersion;
-        if (!runtimeVersion) {
-            throw new Error('Invalid initializion order, runtimeVersion is not available');
-        }
-        // ExtrinsicV5 is not fully supported yet, for that reason we default to version 4
-        this._extrinsicType = metadata.asLatest.extrinsic.versions.at(0) || LATEST_EXTRINSIC_VERSION;
-        this._rx.extrinsicType = this._extrinsicType;
-        this._rx.genesisHash = this._genesisHash;
-        this._rx.runtimeVersion = runtimeVersion;
-        // inject metadata and adjust the types as detected
-        this._injectMetadata(this._getDefaultRegistry(), true);
-        // derive is last, since it uses the decorated rx
-        this._rx.derive = this._decorateDeriveRx(this._rxDecorateMethod);
-        this._derive = this._decorateDerive(this._decorateMethod);
-        return true;
-    }
-    /**
-     * @internal
-     *
-     * Tries to use runtime api calls to retrieve metadata. This ensures the api initializes with the latest metadata.
-     * If the runtime call is not there it will use the rpc method.
-     */
-    async _retrieveMetadata(apis, at, registry) {
-        let metadataVersion = null;
-        const metadataApi = apis.find(([a]) => a.eq(blake2AsHex('Metadata', 64)));
-        const typeRegistry = registry || this.registry;
-        // This chain does not have support for the metadataApi, or does not have the required version.
-        if (!metadataApi || metadataApi[1].toNumber() < 2) {
-            l.warn('MetadataApi not available, rpc::state::get_metadata will be used.');
-            return at
-                ? new Metadata(typeRegistry, await firstValueFrom(this._rpcCore.state.getMetadata.raw(at)))
-                : await firstValueFrom(this._rpcCore.state.getMetadata());
-        }
-        try {
-            const metadataVersionsAsBytes = at
-                ? await firstValueFrom(this._rpcCore.state.call.raw('Metadata_metadata_versions', '0x', at))
-                : await firstValueFrom(this._rpcCore.state.call('Metadata_metadata_versions', '0x'));
-            const versions = typeRegistry.createType('Vec<u32>', metadataVersionsAsBytes);
-            // For unstable versions of the metadata the last value is set to u32 MAX in the runtime. This ensures only supported stable versions are used.
-            metadataVersion = versions.filter((ver) => SUPPORTED_METADATA_VERSIONS.includes(ver.toNumber())).reduce((largest, current) => current.gt(largest) ? current : largest);
-        }
-        catch (e) {
-            l.debug(e.message);
-            l.warn('error with state_call::Metadata_metadata_versions, rpc::state::get_metadata will be used');
-        }
-        // When the metadata version does not align with the latest supported versions we ensure not to call the metadata runtime call.
-        // I noticed on some previous runtimes that have support for `Metadata_metadata_at_version` that very irregular versions were being returned.
-        // This was evident with runtime 1000000 - it return a very large number. This ensures we always stick within what is supported.
-        if (metadataVersion && !SUPPORTED_METADATA_VERSIONS.includes(metadataVersion.toNumber())) {
-            metadataVersion = null;
-        }
-        if (metadataVersion) {
-            try {
-                const metadataBytes = at
-                    ? await firstValueFrom(this._rpcCore.state.call.raw('Metadata_metadata_at_version', u8aToHex(metadataVersion.toU8a()), at))
-                    : await firstValueFrom(this._rpcCore.state.call('Metadata_metadata_at_version', u8aToHex(metadataVersion.toU8a())));
-                // When the metadata is called with `at` it is required to use `.raw`. Therefore since the length prefix is not present the
-                // need to create a `Raw` type is necessary before creating the `OpaqueMetadata` type or else there will be a magic number
-                // mismatch
-                const rawMeta = at
-                    ? typeRegistry.createType('Raw', metadataBytes).toU8a()
-                    : metadataBytes;
-                const opaqueMetadata = typeRegistry.createType('Option<OpaqueMetadata>', rawMeta).unwrapOr(null);
-                if (opaqueMetadata) {
-                    return new Metadata(typeRegistry, opaqueMetadata.toHex());
-                }
-            }
-            catch (e) {
-                l.debug(e.message);
-                l.warn('error with state_call::Metadata_metadata_at_version, rpc::state::get_metadata will be used');
-            }
-        }
-        return at
-            ? new Metadata(typeRegistry, await firstValueFrom(this._rpcCore.state.getMetadata.raw(at)))
-            : await firstValueFrom(this._rpcCore.state.getMetadata());
-    }
-    _subscribeHealth() {
-        this._unsubscribeHealth();
-        // Only enable the health keepalive on WS, not needed on HTTP
-        this.#healthTimer = this.hasSubscriptions
-            ? setInterval(() => {
-                firstValueFrom(this._rpcCore.system.health.raw()).catch(noop);
-            }, KEEPALIVE_INTERVAL)
-            : null;
-    }
-    _unsubscribeHealth() {
-        if (this.#healthTimer) {
-            clearInterval(this.#healthTimer);
-            this.#healthTimer = null;
-        }
-    }
-    _unsubscribeUpdates() {
-        if (this.#updateSub) {
-            this.#updateSub.unsubscribe();
-            this.#updateSub = null;
-        }
-    }
-    _unsubscribe() {
-        this._unsubscribeHealth();
-        this._unsubscribeUpdates();
-    }
-    async #onProviderConnect() {
-        this._isConnected.next(true);
-        this.emit('connected');
-        try {
-            const cryptoReady = this._options.initWasm === false
-                ? true
-                : await cryptoWaitReady();
-            const hasMeta = await this._loadMeta();
-            this._subscribeHealth();
-            if (hasMeta && !this._isReady && cryptoReady) {
-                this._isReady = true;
-                this.emit('ready', this);
-            }
-        }
-        catch (_error) {
-            const error = new Error(`FATAL: Unable to initialize the API: ${_error.message}`);
-            l.error(error);
-            this.emit('error', error);
-        }
-    }
-    #onProviderDisconnect() {
-        this._isConnected.next(false);
-        this._unsubscribe();
-        this.emit('disconnected');
-    }
-    #onProviderError(error) {
-        this.emit('error', error);
-    }
-}

package/build/base/find.d.ts

@@ -1,3 +0,0 @@
-import type { CallFunction, Registry, RegistryError } from '@pezkuwi/types/types';
-export declare function findCall(registry: Registry, callIndex: Uint8Array | string): CallFunction;
-export declare function findError(registry: Registry, errorIndex: Uint8Array | string): RegistryError;

package/build/base/find.js

@@ -1,7 +0,0 @@
-import { u8aToU8a } from '@pezkuwi/util';
-export function findCall(registry, callIndex) {
-    return registry.findMetaCall(u8aToU8a(callIndex));
-}
-export function findError(registry, errorIndex) {
-    return registry.findMetaError(u8aToU8a(errorIndex));
-}

package/build/base/index.d.ts

@@ -1,47 +0,0 @@
-import type { SignerPayloadRawBase } from '@pezkuwi/types/types';
-import type { ApiOptions, ApiTypes, DecorateMethod, Signer } from '../types/index.js';
-import { Getters } from './Getters.js';
-interface KeyringSigner {
-    sign(message: Uint8Array): Uint8Array;
-}
-interface SignerRawOptions {
-    signer?: Signer;
-}
-export declare abstract class ApiBase<ApiType extends ApiTypes> extends Getters<ApiType> {
-    /**
-     * @description Create an instance of the class
-     *
-     * @param options Options object to create API instance or a Provider instance
-     *
-     * @example
-     * <BR>
-     *
-     * ```javascript
-     * import Api from '@pezkuwi/api/promise';
-     *
-     * const api = new Api().isReady();
-     *
-     * api.rpc.subscribeNewHeads((header) => {
-     *   console.log(`new block #${header.number.toNumber()}`);
-     * });
-     * ```
-     */
-    constructor(options: ApiOptions | undefined, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>);
-    /**
-     * @description Connect from the underlying provider, halting all network traffic
-     */
-    connect(): Promise<void>;
-    /**
-     * @description Disconnect from the underlying provider, halting all network traffic
-     */
-    disconnect(): Promise<void>;
-    /**
-     * @description Set an external signer which will be used to sign extrinsic when account passed in is not KeyringPair
-     */
-    setSigner(signer: Signer | undefined): void;
-    /**
-     * @description Signs a raw signer payload, string or Uint8Array
-     */
-    sign(address: KeyringSigner | string, data: SignerPayloadRawBase, { signer }?: SignerRawOptions): Promise<string>;
-}
-export {};

package/build/base/index.js

@@ -1,57 +0,0 @@
-import { isString, objectSpread, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { Getters } from './Getters.js';
-export class ApiBase extends Getters {
-    /**
-     * @description Create an instance of the class
-     *
-     * @param options Options object to create API instance or a Provider instance
-     *
-     * @example
-     * <BR>
-     *
-     * ```javascript
-     * import Api from '@pezkuwi/api/promise';
-     *
-     * const api = new Api().isReady();
-     *
-     * api.rpc.subscribeNewHeads((header) => {
-     *   console.log(`new block #${header.number.toNumber()}`);
-     * });
-     * ```
-     */
-    constructor(options = {}, type, decorateMethod) {
-        super(options, type, decorateMethod);
-    }
-    /**
-     * @description Connect from the underlying provider, halting all network traffic
-     */
-    connect() {
-        return this._rpcCore.connect();
-    }
-    /**
-     * @description Disconnect from the underlying provider, halting all network traffic
-     */
-    disconnect() {
-        this._unsubscribe();
-        return this._rpcCore.disconnect();
-    }
-    /**
-     * @description Set an external signer which will be used to sign extrinsic when account passed in is not KeyringPair
-     */
-    setSigner(signer) {
-        this._rx.signer = signer;
-    }
-    /**
-     * @description Signs a raw signer payload, string or Uint8Array
-     */
-    async sign(address, data, { signer } = {}) {
-        if (isString(address)) {
-            const _signer = signer || this._rx.signer;
-            if (!_signer?.signRaw) {
-                throw new Error('No signer exists with a signRaw interface. You possibly need to pass through an explicit keypair for the origin so it can be used for signing.');
-            }
-            return (await _signer.signRaw(objectSpread({ type: 'bytes' }, data, { address }))).signature;
-        }
-        return u8aToHex(address.sign(u8aToU8a(data.data)));
-    }
-}

package/build/base/types.d.ts

@@ -1,15 +0,0 @@
-import type { Metadata } from '@pezkuwi/types';
-import type { RuntimeVersionPartial } from '@pezkuwi/types/interfaces';
-import type { DecoratedMeta } from '@pezkuwi/types/metadata/decorate/types';
-import type { Registry } from '@pezkuwi/types/types';
-import type { ApiDecoration, ApiTypes } from '../types/index.js';
-export interface VersionedRegistry<ApiType extends ApiTypes> {
-    counter: number;
-    decoratedApi?: ApiDecoration<ApiType>;
-    decoratedMeta?: DecoratedMeta;
-    isDefault?: boolean;
-    lastBlockHash?: Uint8Array | null;
-    metadata: Metadata;
-    registry: Registry;
-    runtimeVersion: RuntimeVersionPartial;
-}

package/build/base/types.js

@@ -1 +0,0 @@
-export {};