@ar.io/sdk 3.10.0-alpha.1 → 3.10.0-alpha.3

package/lib/esm/common/faucet.js

@@ -0,0 +1,145 @@
+const DEFAULT_FAUCET_API_URL = 'https://faucet.ario.permaweb.services';
+/**
+ * Creates a proxy object that implements the TokenFaucet interface. It wraps the ARIOReadable instance and adds methods for claiming tokens from the faucet API.
+ * @param arioInstance - The ARIOReadable instance
+ * @param faucetApiUrl - The URL of the faucet API
+ * @returns A proxy object that implements the TokenFaucet interface
+ */
+export function createFaucet({ arioInstance, faucetApiUrl = DEFAULT_FAUCET_API_URL, }) {
+    const faucet = new ARIOTokenFaucet({
+        faucetUrl: faucetApiUrl,
+        processId: arioInstance.process.processId,
+    });
+    const proxy = new Proxy(arioInstance, {
+        get(target, prop) {
+            if (prop === 'faucet') {
+                return faucet;
+            }
+            if (prop in target) {
+                const result = target[prop];
+                if (typeof result === 'function') {
+                    return result.bind(target);
+                }
+                return result;
+            }
+            return undefined;
+        },
+    });
+    return proxy;
+}
+export class ARIOTokenFaucet {
+    faucetUrl;
+    processId;
+    constructor({ faucetUrl, processId, }) {
+        this.faucetUrl = faucetUrl;
+        this.processId = processId;
+    }
+    /**
+     * Returns the captcha URL for a process. The captcha is used to verify a human is solving the captcha. Once you have a captcha response, you can use it to request an authorization token via the requestAuthToken method.
+     * @returns The captcha URL for a process
+     */
+    async captchaUrl() {
+        const res = await fetch(`${this.faucetUrl}/api/captcha/url?process-id=${this.processId}`, {
+            method: 'GET',
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Claim tokens for a process using a captcha response. This method is used to synchronously claim tokens for a process using a captcha response.
+     * @param captchaResponse - The captcha response
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The claim id and success status
+     */
+    async claimWithCaptchaResponse({ captchaResponse, recipient, quantity, }) {
+        const res = await fetch(`${this.faucetUrl}/api/claim/sync`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                processId: this.processId,
+                recipient,
+                quantity,
+                captchaResponse,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Requests an authorization token for a process. The captcha response is used to verify a human is solving the captcha. Once you have an authorization token, you can use it to claim tokens from the faucet via the claimWithAuthToken method.
+     * @param captchaResponse - The captcha response
+     * @returns The status of the request, the authorization token, and the expiration time
+     */
+    async requestAuthToken({ captchaResponse, }) {
+        const res = await fetch(`${this.faucetUrl}/api/captcha/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                processId: this.processId,
+                captchaResponse,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Transfers tokens from the faucet wallet to a recipient address using an authorization token. To request an authorization token, solve the captcha from the captchaUrl method.
+     * @param authToken - The authorization token
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The message id of the transfer and success status
+     */
+    async claimWithAuthToken({ authToken, recipient, quantity, }) {
+        const res = await fetch(`${this.faucetUrl}/api/claim/async`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${authToken}`,
+            },
+            body: JSON.stringify({
+                recipient,
+                qty: quantity,
+                processId: this.processId,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+    /**
+     * Verifies an authorization token is valid.
+     * @param authToken - The authorization token
+     * @returns The validity of the authorization token and the expiration time
+     */
+    async verifyAuthToken({ authToken }) {
+        const res = await fetch(`${this.faucetUrl}/api/token/verify?process-id=${this.processId}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${authToken}`,
+            },
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error);
+        }
+        const data = (await res.json());
+        return data;
+    }
+}

package/lib/esm/common/index.js

@@ -18,6 +18,7 @@ export * from './logger.js';
 export * from './ant.js';
 export * from './ant-registry.js';
 export * from './ant-versions.js';
+export * from './faucet.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';

package/lib/esm/common/io.js

@@ -1,11 +1,28 @@
-import { ARIO_MAINNET_PROCESS_ID } from '../constants.js';
-import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/io.js';
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { connect } from '@permaweb/aoconnect';
+import { ARIO_MAINNET_PROCESS_ID, ARIO_TESTNET_PROCESS_ID, } from '../constants.js';
+import { isProcessConfiguration, isProcessIdConfiguration, } from '../types/index.js';
 import { createAoSigner } from '../utils/ao.js';
 import { getEpochDataFromGqlWithCUFallback, paginationParamsToTags, pruneTags, removeEligibleRewardsFromEpochData, sortAndPaginateEpochDataIntoEligibleDistributions, } from '../utils/arweave.js';
 import { defaultArweave } from './arweave.js';
 import { AOProcess } from './contracts/ao-process.js';
 import { InvalidContractConfigurationError } from './error.js';
-import { TurboArNSPaymentProvider } from './turbo.js';
+import { createFaucet } from './faucet.js';
+import { TurboArNSPaymentFactory, TurboArNSPaymentProviderAuthenticated, isTurboArNSSigner, } from './turbo.js';
 export class ARIO {
     // Implementation
     static init(config) {
@@ -14,6 +31,56 @@ export class ARIO {
         }
         return new ARIOReadable(config);
     }
+    static mainnet(config) {
+        if (config !== undefined && 'signer' in config) {
+            return new ARIOWriteable({
+                ...config,
+                process: new AOProcess({
+                    processId: ARIO_MAINNET_PROCESS_ID,
+                    ao: connect({
+                        CU_URL: 'https://cu.ardrive.io',
+                        ...config?.process?.ao,
+                    }),
+                }),
+            });
+        }
+        return new ARIOReadable({
+            ...config,
+            process: new AOProcess({
+                processId: ARIO_MAINNET_PROCESS_ID,
+            }),
+        });
+    }
+    static testnet(config) {
+        if (config !== undefined && 'signer' in config) {
+            return createFaucet({
+                arioInstance: new ARIOWriteable({
+                    ...config,
+                    process: new AOProcess({
+                        processId: ARIO_TESTNET_PROCESS_ID,
+                        ao: connect({
+                            CU_URL: 'https://cu.ardrive.io',
+                            ...config?.process?.ao,
+                        }),
+                    }),
+                }),
+                faucetApiUrl: config?.faucetUrl,
+            });
+        }
+        return createFaucet({
+            arioInstance: new ARIOReadable({
+                ...config,
+                process: new AOProcess({
+                    processId: ARIO_TESTNET_PROCESS_ID,
+                    ao: connect({
+                        CU_URL: 'https://cu.ardrive.io',
+                        ...config?.process?.ao,
+                    }),
+                }),
+            }),
+            faucetApiUrl: config?.faucetUrl,
+        });
+    }
 }
 export class ARIOReadable {
     process;
@@ -38,7 +105,7 @@ export class ARIOReadable {
         else {
             throw new InvalidContractConfigurationError();
         }
-        this.paymentProvider = new TurboArNSPaymentProvider({
+        this.paymentProvider = TurboArNSPaymentFactory.init({
             paymentUrl: config?.paymentUrl,
         });
     }
@@ -565,8 +632,8 @@ export class ARIOWriteable extends ARIOReadable {
             super(config);
         }
         this.signer = createAoSigner(signer);
-        this.paymentProvider = new TurboArNSPaymentProvider({
-            signer: signer,
+        this.paymentProvider = TurboArNSPaymentFactory.init({
+            signer: isTurboArNSSigner(signer) ? signer : undefined,
             paymentUrl,
         });
     }
@@ -844,6 +911,9 @@ export class ARIOWriteable extends ARIOReadable {
     }
     async buyRecord(params, options) {
         if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
             return this.paymentProvider.initiateArNSPurchase({
                 intent: 'Buy-Name',
                 ...params,
@@ -874,6 +944,9 @@ export class ARIOWriteable extends ARIOReadable {
      */
     async upgradeRecord(params, options) {
         if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
             return this.paymentProvider.initiateArNSPurchase({
                 intent: 'Upgrade-Name',
                 name: params.name,
@@ -902,6 +975,9 @@ export class ARIOWriteable extends ARIOReadable {
      */
     async extendLease(params, options) {
         if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
             return this.paymentProvider.initiateArNSPurchase({
                 intent: 'Extend-Lease',
                 ...params,
@@ -922,6 +998,9 @@ export class ARIOWriteable extends ARIOReadable {
     }
     async increaseUndernameLimit(params, options) {
         if (params.fundFrom === 'turbo') {
+            if (!(this.paymentProvider instanceof TurboArNSPaymentProviderAuthenticated)) {
+                throw new Error('Turbo funding is not supported for this payment provider');
+            }
             return this.paymentProvider.initiateArNSPurchase({
                 intent: 'Increase-Undername-Limit',
                 ...params,

package/lib/esm/common/turbo.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { SignatureConfig } from '@dha-team/arbundles';
+import { ArconnectSigner, ArweaveSigner, EthereumSigner, InjectedEthereumSigner, SignatureConfig, } from '@dha-team/arbundles';
 import { v4 as uuidv4 } from 'uuid';
 import { mARIOToken } from '../types/token.js';
 import { toB64Url } from '../utils/base64.js';
@@ -21,39 +21,87 @@ import { createAxiosInstance } from '../utils/http-client.js';
 import { urlWithSearchParams } from '../utils/url.js';
 import { Logger } from './logger.js';
 export async function signedRequestHeadersFromSigner({ signer, nonce = uuidv4(), }) {
-    await signer.setPublicKey?.();
-    const signature = await signer.sign(Uint8Array.from(Buffer.from(nonce)));
-    let publicKey;
-    switch (signer.signatureType) {
+    let signature = undefined;
+    let publicKey = undefined;
+    const signatureType = isWanderArweaveBrowserSigner(signer)
+        ? SignatureConfig.ARWEAVE
+        : signer.signatureType;
+    // equivalent to window.arweaveWallet
+    if (isWanderArweaveBrowserSigner(signer)) {
+        signature = toB64Url(Buffer.from(await signer.signMessage(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    else if (signer instanceof ArconnectSigner) {
+        signature = toB64Url(Buffer.from(await signer['signer'].signMessage(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    else if (signer instanceof ArweaveSigner ||
+        signer instanceof EthereumSigner ||
+        signer instanceof InjectedEthereumSigner) {
+        if ('setPublicKey' in signer) {
+            await signer.setPublicKey();
+        }
+        signature = toB64Url(Buffer.from(await signer.sign(Uint8Array.from(Buffer.from(nonce)))));
+    }
+    switch (signatureType) {
         case SignatureConfig.ARWEAVE:
-            publicKey = toB64Url(signer.publicKey);
+            if (isWanderArweaveBrowserSigner(signer)) {
+                publicKey = await signer.getActivePublicKey();
+            }
+            else if ('setPublicKey' in signer) {
+                await signer.setPublicKey();
+                publicKey = toB64Url(signer.publicKey);
+            }
             break;
         case SignatureConfig.ETHEREUM:
-            publicKey = '0x' + signer.publicKey.toString('hex');
+            if ('publicKey' in signer) {
+                publicKey = '0x' + signer.publicKey.toString('hex');
+            }
+            else {
+                throw new Error('Public key not found');
+            }
             break;
         // TODO: solana sig support
         // case SignatureConfig.SOLANA:
         // case SignatureConfig.ED25519:
         default:
-            throw new Error(`Unsupported signer type for signing requests: ${signer.signatureType}`);
+            throw new Error(`Unsupported signer type for signing requests: ${signatureType}`);
+    }
+    if (publicKey === undefined || signature === undefined) {
+        throw new Error('Public key or signature not found');
     }
     return {
         'x-public-key': publicKey,
         'x-nonce': nonce,
-        'x-signature': toB64Url(Buffer.from(signature)),
-        'x-signature-type': signer.signatureType,
+        'x-signature': signature,
+        'x-signature-type': signatureType,
     };
 }
-export class TurboArNSPaymentProvider {
+export class TurboArNSPaymentFactory {
+    static init(config) {
+        const { signer, paymentUrl, axios, logger } = config ?? {};
+        if (signer !== undefined) {
+            return new TurboArNSPaymentProviderAuthenticated({
+                signer,
+                paymentUrl,
+                axios,
+                logger,
+            });
+        }
+        return new TurboArNSPaymentProviderUnauthenticated({
+            paymentUrl,
+            axios,
+            logger,
+        });
+    }
+}
+// Base class for unauthenticated operations
+export class TurboArNSPaymentProviderUnauthenticated {
     paymentUrl;
     axios;
     logger;
-    signer;
-    constructor({ paymentUrl = 'https://payment.ardrive.io', axios = createAxiosInstance(), logger = Logger.default, signer, }) {
+    constructor({ paymentUrl = 'https://payment.ardrive.io', axios = createAxiosInstance(), logger = Logger.default, }) {
         this.paymentUrl = paymentUrl;
         this.axios = axios;
         this.logger = logger;
-        this.signer = signer;
     }
     async getArNSPriceDetails({ intent, name, quantity, type, years, }) {
         const url = urlWithSearchParams({
@@ -89,10 +137,19 @@ export class TurboArNSPaymentProvider {
         const { winc } = await this.getArNSPriceDetails(params);
         return +winc;
     }
-    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, }) {
-        if (!this.signer) {
-            throw new Error('Signer required for initiating ArNS purchase with Turbo');
+}
+// Class for authenticated operations, extending the base class
+export class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProviderUnauthenticated {
+    signer;
+    constructor({ signer, ...restConfig }) {
+        super(restConfig); // Pass unauthenticated config to base class+
+        if (!isTurboArNSSigner(signer)) {
+            throw new Error('Signer must be a TurboArNSSigner');
         }
+        this.signer = signer;
+    }
+    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, }) {
+        // Signer check is implicitly handled by requiring it in the constructor
         const url = urlWithSearchParams({
             baseUrl: `${this.paymentUrl}/v1/arns/purchase/${intent}/${name}`,
             params: {
@@ -127,3 +184,17 @@ export class TurboArNSPaymentProvider {
         };
     }
 }
+function isWanderArweaveBrowserSigner(signer) {
+    return (typeof signer === 'object' &&
+        signer !== null &&
+        'signMessage' in signer &&
+        'getActivePublicKey' in signer);
+}
+export function isTurboArNSSigner(signer) {
+    const isWanderWallet = isWanderArweaveBrowserSigner(signer);
+    const isSigner = signer instanceof EthereumSigner ||
+        signer instanceof InjectedEthereumSigner ||
+        signer instanceof ArweaveSigner ||
+        signer instanceof ArconnectSigner;
+    return isWanderWallet || isSigner;
+}

package/lib/esm/types/faucet.js

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

package/lib/esm/types/index.js

@@ -16,5 +16,6 @@
 export * from './ant-registry.js';
 export * from './ant.js';
 export * from './common.js';
+export * from './faucet.js';
 export * from './io.js';
 export * from './token.js';

package/lib/esm/types/io.js

@@ -28,10 +28,11 @@ export const isValidFundFrom = (fundFrom) => {
 };
 // Type-guard functions
 export function isProcessConfiguration(config) {
-    return 'process' in config;
+    return config !== undefined && 'process' in config;
 }
 export function isProcessIdConfiguration(config) {
-    return ('processId' in config &&
+    return (config !== undefined &&
+        'processId' in config &&
         typeof config.processId === 'string' &&
         validateArweaveId(config.processId) === true);
 }

package/lib/esm/utils/ao.js

@@ -131,6 +131,8 @@ export function createAoSigner(signer) {
         }));
         return signedData;
     };
+    // eslint-disable-next-line
+    // @ts-ignore Buffer vs ArrayBuffer type mismatch
     return aoSigner;
 }
 export const defaultTargetManifestId = '-k7t8xMoB8hW482609Z9F4bTFMC3MnuW8bTvTyT8pFI';

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '3.10.0-alpha.1';
+export const version = '3.10.0-alpha.3';

package/lib/esm/web/index.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { ArweaveSigner, ArconnectSigner } from '@dha-team/arbundles';
+export { ArweaveSigner, ArconnectSigner, InjectedEthereumSigner, EthereumSigner, } from '@dha-team/arbundles';
 export * from '../types/index.js';
 export * from '../common/index.js';
 export * from '../constants.js';

package/lib/types/cli/utils.d.ts

@@ -80,7 +80,7 @@ export declare function positiveIntegerFromOptions<O extends GlobalCLIOptions>(o
 export declare function requiredPositiveIntegerFromOptions<O extends GlobalCLIOptions>(options: O, key: string): number;
 export declare function getANTStateFromOptions(options: ANTStateCLIOptions): SpawnANTState;
 export declare function getTokenCostParamsFromOptions(o: GetTokenCostCLIOptions): {
-    type: "permabuy" | "lease";
+    type: "lease" | "permabuy";
     quantity: number | undefined;
     years: number;
     intent: "Buy-Name" | "Buy-Record" | "Extend-Lease" | "Increase-Undername-Limit" | "Upgrade-Name" | "Primary-Name-Request";

package/lib/types/common/faucet.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ARIOWithFaucet, TokenFaucet } from '../types/faucet.js';
+import { ARIOReadable, ARIOWriteable } from './io.js';
+/**
+ * Creates a proxy object that implements the TokenFaucet interface. It wraps the ARIOReadable instance and adds methods for claiming tokens from the faucet API.
+ * @param arioInstance - The ARIOReadable instance
+ * @param faucetApiUrl - The URL of the faucet API
+ * @returns A proxy object that implements the TokenFaucet interface
+ */
+export declare function createFaucet({ arioInstance, faucetApiUrl, }: {
+    arioInstance: ARIOReadable | ARIOWriteable;
+    faucetApiUrl?: string;
+}): ARIOWithFaucet<ARIOReadable | ARIOWriteable>;
+export declare class ARIOTokenFaucet implements TokenFaucet {
+    private faucetUrl;
+    private processId;
+    constructor({ faucetUrl, processId, }: {
+        faucetUrl: string;
+        processId: string;
+    });
+    /**
+     * Returns the captcha URL for a process. The captcha is used to verify a human is solving the captcha. Once you have a captcha response, you can use it to request an authorization token via the requestAuthToken method.
+     * @returns The captcha URL for a process
+     */
+    captchaUrl(): Promise<{
+        processId: string;
+        captchaUrl: string;
+    }>;
+    /**
+     * Claim tokens for a process using a captcha response. This method is used to synchronously claim tokens for a process using a captcha response.
+     * @param captchaResponse - The captcha response
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The claim id and success status
+     */
+    claimWithCaptchaResponse({ captchaResponse, recipient, quantity, }: {
+        captchaResponse: string;
+        recipient: string;
+        quantity: number;
+    }): Promise<{
+        id: string;
+        success: boolean;
+    }>;
+    /**
+     * Requests an authorization token for a process. The captcha response is used to verify a human is solving the captcha. Once you have an authorization token, you can use it to claim tokens from the faucet via the claimWithAuthToken method.
+     * @param captchaResponse - The captcha response
+     * @returns The status of the request, the authorization token, and the expiration time
+     */
+    requestAuthToken({ captchaResponse, }: {
+        captchaResponse: string;
+    }): Promise<{
+        status: 'success' | 'error';
+        token: string;
+        expiresAt: number;
+    }>;
+    /**
+     * Transfers tokens from the faucet wallet to a recipient address using an authorization token. To request an authorization token, solve the captcha from the captchaUrl method.
+     * @param authToken - The authorization token
+     * @param recipient - The recipient address
+     * @param quantity - The quantity of tokens to claim
+     * @returns The message id of the transfer and success status
+     */
+    claimWithAuthToken({ authToken, recipient, quantity, }: {
+        authToken: string;
+        recipient: string;
+        quantity: number;
+    }): Promise<{
+        id: string;
+        success: boolean;
+    }>;
+    /**
+     * Verifies an authorization token is valid.
+     * @param authToken - The authorization token
+     * @returns The validity of the authorization token and the expiration time
+     */
+    verifyAuthToken({ authToken }: {
+        authToken: string;
+    }): Promise<{
+        valid: boolean;
+        expiresAt: number;
+    }>;
+}

package/lib/types/common/index.d.ts

@@ -18,5 +18,6 @@ export * from './logger.js';
 export * from './ant.js';
 export * from './ant-registry.js';
 export * from './ant-versions.js';
+export * from './faucet.js';
 export * from './io.js';
 export * from './contracts/ao-process.js';