@ar.io/sdk 3.10.2 → 3.11.0-alpha.10

package/lib/types/common/wayfinder/routers/static.test.d.ts

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

package/lib/types/common/wayfinder/verification/data-root-verifier.d.ts

@@ -0,0 +1,31 @@
+import { Readable } from 'node:stream';
+import { DataRootProvider, DataVerifier } from '../../../types/wayfinder.js';
+export declare function convertBufferToDataRoot({ buffer, }: {
+    buffer: Buffer;
+}): Promise<string>;
+export declare const convertReadableToDataRoot: <T extends AsyncIterable<Uint8Array>>({ iterable, }: {
+    iterable: T;
+}) => Promise<string>;
+export declare class DataRootVerifier implements DataVerifier {
+    private readonly trustedDataRootProvider;
+    constructor({ trustedDataRootProvider, }: {
+        trustedDataRootProvider: DataRootProvider;
+    });
+    verifyData({ data, txId, }: {
+        data: Buffer | Readable | ReadableStream;
+        txId: string;
+    }): Promise<void>;
+}
+/**
+ * - when you get a signature of a data item, you can only verify the owner
+ * - you still need to verify it's going back to the bundle, unpack it, and verify the data item exists at the offset
+ * - you need to the location of the chunks for the data item, and prove it's in the chunk and then prove the data root of the bundle, then you have fully verified the data verifier
+ * - how to prove the data item is on arweave - verify the merkle hash that the chunks for the data item, fit within the expected tree of the parent bundle
+ *
+ * Composite verifier - you'll want to be very efficient with streams
+ * - hash verifier
+ * - parent chunks verifier --> for any range of data within a single transaction, tell me that it's correct
+ * - signature verifier
+ * - offset verifier
+ * - data item verifier
+ */

package/lib/types/common/wayfinder/verification/hash-verifier.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { Readable } from 'node:stream';
+import { DataHashProvider, DataVerifier } from '../../../types/wayfinder.js';
+export declare class HashVerifier implements DataVerifier {
+    private readonly trustedHashProvider;
+    constructor({ trustedHashProvider, }: {
+        trustedHashProvider: DataHashProvider;
+    });
+    verifyData({ data, txId, }: {
+        data: Buffer | Readable | ReadableStream;
+        txId: string;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,265 @@
+/**
+ * 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 EventEmitter from 'node:events';
+import { PassThrough, Readable } from 'node:stream';
+import { DataHashProvider, DataVerifier, WayfinderRouter } from '../../types/wayfinder.js';
+import { Logger } from '../logger.js';
+type HttpClientArgs = unknown[];
+type HttpClientFunction = (...args: HttpClientArgs) => unknown;
+type WayfinderHttpClient<T extends HttpClientFunction> = T;
+export declare const arnsRegex: RegExp;
+export declare const txIdRegex: RegExp;
+/**
+ * Core function to resolve a wayfinder url against a target gateway
+ * @param originalUrl - the wayfinder url to resolve
+ * @param targetGateway - the target gateway to resolve the url against
+ * @returns the resolved url that can be used to make a request
+ */
+export declare const resolveWayfinderUrl: ({ originalUrl, targetGateway, logger, }: {
+    originalUrl: string | URL;
+    targetGateway: () => Promise<string | URL>;
+    logger?: Logger;
+}) => Promise<URL>;
+/**
+ * Wayfinder event emitter with verification events
+ */
+export type WayfinderEvent = {
+    type: 'verification-passed';
+    txId: string;
+} | {
+    type: 'verification-failed';
+    txId: string;
+    error: Error;
+} | {
+    type: 'verification-skipped';
+    originalUrl: string;
+} | {
+    type: 'verification-progress';
+    txId: string;
+    processedBytes: number;
+    totalBytes: number;
+} | {
+    type: 'routing-started';
+    originalUrl: string;
+} | {
+    type: 'routing-succeeded';
+    originalUrl: string;
+    targetGateway: string;
+} | {
+    type: 'routing-failed';
+    originalUrl: string;
+    error: Error;
+} | {
+    type: 'identified-transaction-id';
+    originalUrl: string;
+    targetGateway: string;
+    txId: string;
+};
+export interface WayfinderEventArgs {
+    onVerificationPassed?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-passed';
+    }>, 'type'>) => void;
+    onVerificationFailed?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-failed';
+    }>, 'type'>) => void;
+    onVerificationProgress?: (payload: Omit<Extract<WayfinderEvent, {
+        type: 'verification-progress';
+    }>, 'type'>) => void;
+}
+export declare class WayfinderEmitter extends EventEmitter {
+    constructor({ onVerificationPassed, onVerificationFailed, onVerificationProgress, }?: WayfinderEventArgs);
+    emit<E extends WayfinderEvent['type']>(event: E, payload: Omit<Extract<WayfinderEvent, {
+        type: E;
+    }>, 'type'>): boolean;
+    on<E extends WayfinderEvent['type']>(event: E, listener: (payload: Omit<Extract<WayfinderEvent, {
+        type: E;
+    }>, 'type'>) => void): this;
+}
+export declare function tapAndVerifyStream<T extends Readable | ReadableStream>({ originalStream, contentLength, verifyData, txId, emitter, }: {
+    originalStream: T;
+    contentLength: number;
+    verifyData: DataVerifier['verifyData'];
+    txId: string;
+    emitter?: WayfinderEmitter;
+}): T extends Readable ? PassThrough : T;
+export declare function wrapVerifiedResponse(original: Response, newBody: ReadableStream<Uint8Array>, txId: string): Response;
+/**
+ * Creates a wrapped http client that supports ar:// protocol
+ *
+ * This function leverages a Proxy to intercept calls to the http client
+ * and redirects them to the target gateway using the resolveUrl function url.
+ * It also supports the http client methods like get(), post(), put(), delete(), etc.
+ *
+ * Any URLs provided that are not wayfinder urls will be returned as is.
+ *
+ * @param httpClient - the http client to wrap (e.g. axios, fetch, got, etc.)
+ * @param resolveUrl - the function to construct the redirect url for ar:// requests
+ * @returns a wrapped http client that supports ar:// protocol
+ */
+export declare const createWayfinderClient: <T extends HttpClientFunction>({ httpClient, resolveUrl, verifyData, emitter, logger, }: {
+    httpClient: T;
+    resolveUrl: (params: {
+        originalUrl: string | URL;
+        logger?: Logger;
+    }) => Promise<URL>;
+    verifyData?: <T_1 extends Readable | ReadableStream | Buffer>({ data, txId, }: {
+        data: T_1;
+        txId: string;
+    }) => Promise<void>;
+    logger?: Logger;
+    emitter?: WayfinderEmitter;
+}) => WayfinderHttpClient<T>;
+/**
+ * The main class for the wayfinder
+ * @param router - the router to use for requests
+ * @param httpClient - the http client to use for requests
+ * @param blocklist - the blocklist of gateways to avoid
+ */
+export declare class Wayfinder<T extends HttpClientFunction> {
+    /**
+     * The router to use for requests
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({
+     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *       ttlSeconds: 60 * 60 * 24, // 1 day
+     *     }),
+     *   }),
+     * });
+     *
+     * // Returns a target gateway based on the routing strategy
+     * const targetGateway = await wayfinder.router.getTargetGateway();
+     */
+    readonly router: WayfinderRouter;
+    /**
+     * The native http client used by wayfinder
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({
+     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *       ttlSeconds: 60 * 60 * 24, // 1 day
+     *     }),
+     *   }),
+     *   httpClient: axios,
+     * });
+     *
+     */
+    readonly httpClient: T;
+    /**
+     * The function that resolves the redirect url for ar:// requests to a target gateway
+     *
+     * @example
+     * const wayfinder = new Wayfinder({
+     *   router: new RandomGatewayRouter({
+     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *       ttlSeconds: 60 * 60 * 24, // 1 day
+     *     }),
+     *   }),
+     *   httpClient: axios,
+     * });
+     *
+     * // returns the redirected URL based on the routing strategy and the original url
+     * const redirectUrl = await wayfinder.resolveUrl({ originalUrl: 'ar://example' });
+     */
+    readonly resolveUrl: (params: {
+        originalUrl: string;
+        logger?: Logger;
+    }) => Promise<URL>;
+    /**
+     * A wrapped http client that supports ar:// protocol
+     *
+     * @example
+     * const { request: wayfind } = new Wayfinder({
+     *   router: new RandomGatewayRouter({
+     *     gatewaysProvider: new SimpleCacheGatewaysProvider({
+     *       gatewaysProvider: new NetworkGatewaysProvider({ ario: ARIO.mainnet() }),
+     *       ttlSeconds: 60 * 60 * 24, // 1 day
+     *     }),
+     *   }),
+     *   httpClient: axios,
+     * });;
+     *
+     * const response = await wayfind('ar://example', {
+     *   method: 'POST',
+     *   data: {
+     *     name: 'John Doe',
+     *   },
+     * })
+     */
+    readonly request: WayfinderHttpClient<T>;
+    readonly verifyData: DataVerifier['verifyData'];
+    /**
+     * The event emitter for wayfinder that emits verification events.
+     *
+     * const wayfinder = new Wayfinder()
+     *
+     * wayfinder.emitter.on('verification-passed', (event) => {
+     *   console.log('Verification passed!', event);
+     * })
+     *
+     * wayfinder.emitter.on('verification-failed', (event) => {
+     *   console.log('Verification failed!', event);
+     * })
+     *
+     * or implement the events interface and pass it in, using callback functions
+     *
+     * const wayfinder = new Wayfinder({
+     *   events: {
+     *     onVerificationPassed: (event) => {
+     *       console.log('Verification passed!', event);
+     *     },
+     *     onVerificationFailed: (event) => {
+     *       console.log('Verification failed!', event);
+     *     },
+     *     onVerificationProgress: (event) => {
+     *       console.log('Verification progress!', event);
+     *     },
+     *   }
+     * })
+     *
+     * const response = await wayfind('ar://example');
+     */
+    readonly emitter: WayfinderEmitter;
+    constructor({ httpClient, router, logger, verifier, events, }: {
+        httpClient: T;
+        router?: WayfinderRouter;
+        logger?: Logger;
+        verifier?: DataVerifier;
+        hashProvider?: DataHashProvider;
+        events?: WayfinderEventArgs;
+    });
+}
+export {};
+/**
+ *
+ *  type    | complexity | performance | security
+ * ---------|------------|-------------|---------
+ *  hash    | low        | high        | low
+ * ---------|------------|-------------|---------
+ *  data root    | medium       | medium      | low | only L1
+ * ---------|------------|-------------|---------
+ * signature    | medium       | medium      | medium
+ * ---------|------------|-------------|---------
+ *  composite | high       | low         | high
+ * ---------|------------|-------------|---------
+ *
+ *
+ */

package/lib/types/common/wayfinder/wayfinder.test.d.ts

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

package/lib/types/types/ant.d.ts

@@ -127,11 +127,63 @@ export declare const AntStateSchema: z.ZodObject<{
     Initialized: boolean;
 }>;
 export type AoANTState = z.infer<typeof AntStateSchema>;
+export declare const SpawnANTStateSchema: z.ZodObject<{
+    name: z.ZodString;
+    ticker: z.ZodString;
+    description: z.ZodString;
+    keywords: z.ZodArray<z.ZodString, "many">;
+    owner: z.ZodString;
+    controllers: z.ZodArray<z.ZodString, "many">;
+    records: z.ZodRecord<z.ZodString, z.ZodObject<{
+        transactionId: z.ZodEffects<z.ZodString, string, string>;
+        ttlSeconds: z.ZodNumber;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        transactionId: string;
+        ttlSeconds: number;
+        priority?: number | undefined;
+    }, {
+        transactionId: string;
+        ttlSeconds: number;
+        priority?: number | undefined;
+    }>>;
+    balances: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    logo: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    ticker: string;
+    keywords: string[];
+    owner: string;
+    controllers: string[];
+    records: Record<string, {
+        transactionId: string;
+        ttlSeconds: number;
+        priority?: number | undefined;
+    }>;
+    balances: Record<string, number>;
+    logo: string;
+}, {
+    description: string;
+    name: string;
+    ticker: string;
+    keywords: string[];
+    owner: string;
+    controllers: string[];
+    records: Record<string, {
+        transactionId: string;
+        ttlSeconds: number;
+        priority?: number | undefined;
+    }>;
+    balances: Record<string, number>;
+    logo: string;
+}>;
+export type SpawnANTState = z.infer<typeof SpawnANTStateSchema>;
 export declare const AntReadHandlers: readonly ["balance", "balances", "totalSupply", "info", "controllers", "record", "records", "state"];
 export type AoANTReadHandler = (typeof AntReadHandlers)[number];
 export declare const AntWriteHandlers: readonly ["_eval", "_default", "transfer", "addController", "removeController", "setRecord", "removeRecord", "setName", "setTicker", "setDescription", "setKeywords", "setLogo", "initializeState", "releaseName", "reassignName", "approvePrimaryName", "removePrimaryNames"];
 export type AoANTWriteHandler = (typeof AntWriteHandlers)[number];
-export declare const AntHandlerNames: ("balance" | "balances" | "totalSupply" | "info" | "controllers" | "record" | "records" | "state" | "_eval" | "_default" | "transfer" | "addController" | "removeController" | "setRecord" | "removeRecord" | "setName" | "setTicker" | "setDescription" | "setKeywords" | "setLogo" | "initializeState" | "releaseName" | "reassignName" | "approvePrimaryName" | "removePrimaryNames")[];
+export declare const AntHandlerNames: ("controllers" | "records" | "balances" | "balance" | "totalSupply" | "info" | "record" | "state" | "_eval" | "_default" | "transfer" | "addController" | "removeController" | "setRecord" | "removeRecord" | "setName" | "setTicker" | "setDescription" | "setKeywords" | "setLogo" | "initializeState" | "releaseName" | "reassignName" | "approvePrimaryName" | "removePrimaryNames")[];
 export type AoANTHandler = AoANTWriteHandler | AoANTReadHandler;
 export declare const AntHandlersSchema: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
 export declare const AntInfoSchema: z.ZodObject<{

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Signer } from '@dha-team/arbundles';
+import { ArconnectSigner, ArweaveSigner, EthereumSigner, InjectedEthereumSigner, Signer } from '@dha-team/arbundles';
 import { dryrun, message, monitor, result, results, spawn, unmonitor } from '@permaweb/aoconnect';
 import Arweave from 'arweave';
 import { AoSigner } from './token.js';
@@ -26,6 +26,10 @@ export type ProcessId = string;
 export type OptionalArweave<T = NonNullable<unknown>> = {
     arweave?: Arweave;
 } & T;
+export type OptionalPaymentUrl<T = NonNullable<unknown>> = {
+    paymentUrl?: string;
+} & T;
+export type TurboArNSSigner = EthereumSigner | InjectedEthereumSigner | ArweaveSigner | ArconnectSigner | Window['arweaveWallet'];
 export type ContractSigner = Signer | Window['arweaveWallet'] | AoSigner;
 export type WithSigner<T = NonNullable<unknown>> = {
     signer: ContractSigner;
@@ -44,8 +48,9 @@ export type WriteOptions = {
     }[];
 };
 export type WriteParameters<Input> = WithSigner<Required<ReadParameters<Input>>>;
-export type AoMessageResult = {
+export type AoMessageResult<T = Record<string, string | number | boolean | null>> = {
     id: string;
+    result?: T;
 };
 export type AoPrimaryNameRequest = {
     name: string;

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

@@ -19,3 +19,4 @@ export * from './common.js';
 export * from './faucet.js';
 export * from './io.js';
 export * from './token.js';
+export * from './wayfinder.js';

package/lib/types/types/io.d.ts

@@ -310,7 +310,7 @@ export type AoTokenCostParams = {
     quantity?: number;
     fromAddress?: WalletAddress;
 };
-export declare const fundFromOptions: readonly ["balance", "stakes", "any"];
+export declare const fundFromOptions: readonly ["balance", "stakes", "any", "turbo"];
 export type FundFrom = (typeof fundFromOptions)[number];
 export declare const isValidFundFrom: (fundFrom: string) => fundFrom is FundFrom;
 export type AoGetCostDetailsParams = AoTokenCostParams & {
@@ -338,6 +338,7 @@ export type CostDetailsResult = {
         basePrice: number;
     };
     fundingPlan?: AoFundingPlan;
+    wincQty?: string;
 };
 export type AoGetVaultParams = {
     address: WalletAddress;
@@ -419,7 +420,23 @@ export type DemandFactorSettings = {
     maxPeriodsAtMinDemandFactor: number;
     criteria: string;
 };
-export interface AoARIORead {
+export type ArNSNameResolutionData = {
+    name: string;
+    owner?: string;
+    txId: string;
+    type: 'lease' | 'permabuy';
+    processId: string;
+    ttlSeconds: number;
+    priority?: number;
+    undernameLimit: number;
+};
+export interface ArNSNameResolver {
+    resolveArNSName({ name }: {
+        name: string;
+    }): Promise<ArNSNameResolutionData>;
+}
+export interface AoARIORead extends ArNSNameResolver {
+    process: AOProcess;
     getInfo(): Promise<{
         Ticker: string;
         Name: string;
@@ -523,10 +540,10 @@ export interface AoARIOWrite extends AoARIORead {
         reportTxId: TransactionId;
         failedGateways: WalletAddress[];
     }>;
-    buyRecord: AoWriteAction<AoBuyRecordParams>;
-    upgradeRecord: AoWriteAction<AoArNSPurchaseParams>;
-    extendLease: AoWriteAction<AoExtendLeaseParams>;
-    increaseUndernameLimit: AoWriteAction<AoIncreaseUndernameLimitParams>;
+    buyRecord: AoWriteAction<AoBuyRecordParams, AoMessageResult>;
+    upgradeRecord: AoWriteAction<AoArNSPurchaseParams, AoMessageResult>;
+    extendLease: AoWriteAction<AoExtendLeaseParams, AoMessageResult>;
+    increaseUndernameLimit: AoWriteAction<AoIncreaseUndernameLimitParams, AoMessageResult>;
     cancelWithdrawal: AoWriteAction<{
         gatewayAddress?: WalletAddress;
         vaultId: string;

package/lib/types/types/wayfinder.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 { Readable } from 'stream';
+export interface WayfinderRouter {
+    readonly name: string;
+    getTargetGateway: () => Promise<URL>;
+}
+export interface DataVerifier {
+    /**
+     * Verifies the provided data for a given txId
+     *
+     * Depending on the implementation, the hash can be the computed data root of a transaction, the digest of the data, or some other hash of the data.
+     *
+     * The interface is intended to be vague in order to support various degrees of verification.
+     *
+     * @param data - The data to verify
+     * @param txId - The txId of the data
+     * @returns the hash of the data
+     */
+    verifyData: ({ data, txId, }: {
+        data: Buffer | Readable | ReadableStream;
+        txId: string;
+    }) => Promise<void>;
+}
+export interface DataHashProvider {
+    /**
+     * Returns a hash for the provided txId using the specified algorithm.
+     *
+     * @param txId - The txId of the data
+     * @returns the hash of the data
+     */
+    getHash: ({ txId, }: {
+        txId: string;
+    }) => Promise<{
+        hash: string;
+        algorithm: 'sha256';
+    }>;
+}
+export interface DataRootProvider {
+    /**
+     * Returns the data root for the provided txId
+     *
+     * @param txId - The txId of the data
+     * @returns the data root of the data
+     */
+    getDataRoot: ({ txId }: {
+        txId: string;
+    }) => Promise<string>;
+}

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

@@ -1,18 +1,7 @@
 import Arweave from 'arweave';
 import { Logger } from '../common/index.js';
-import { AoANTRecord } from '../types/ant.js';
+import { SpawnANTState } from '../types/ant.js';
 import { AoClient, AoEpochData, AoEpochDistributed, AoSigner, ContractSigner, WalletAddress } from '../types/index.js';
-export type SpawnANTState = {
-    owner: WalletAddress;
-    controllers: WalletAddress[];
-    name: string;
-    description: string;
-    keywords: string[];
-    ticker: string;
-    records: Record<string, AoANTRecord>;
-    balances: Record<WalletAddress, number>;
-    logo: string;
-};
 export type SpawnANTParams = {
     signer: AoSigner;
     module?: string;

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

@@ -0,0 +1,4 @@
+import { Readable } from 'stream';
+export declare const hashReadableToB64Url: (stream: Readable, algorithm?: string) => Promise<string>;
+export declare const hashReadableStreamToB64Url: (stream: ReadableStream, algorithm?: string) => Promise<string>;
+export declare const hashBufferToB64Url: (buffer: Buffer, algorithm?: string) => string;

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

@@ -0,0 +1,7 @@
+/**
+ * Cryptographically secure helper for randomness, does not support seeding
+ * @param min - the minimum value
+ * @param max - the maximum value
+ * @returns a random integer between min and max
+ */
+export declare const randomInt: (min: number, max: number) => number;

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export declare const urlWithSearchParams: ({ baseUrl, params, }: {
+    baseUrl: string;
+    params: Record<string, string | number | boolean | null | undefined>;
+}) => string;

package/lib/types/utils/url.test.d.ts

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

package/lib/types/version.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const version = "3.10.1";
+export declare const version = "3.11.0-alpha.9";

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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ar.io/sdk",
-  "version": "3.10.2",
+  "version": "3.11.0-alpha.10",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ar-io/ar-io-sdk.git"
@@ -72,7 +72,7 @@
     "test:cjs": "yarn build:cjs && yarn link && cd ./tests/e2e/cjs && yarn && yarn test",
     "test:esm": "yarn build:esm && yarn link && cd ./tests/e2e/esm && yarn && yarn test",
     "test:web": "yarn build:esm && yarn link && cd ./tests/e2e/web && yarn && yarn test",
-    "test:unit": "node --import=./register.mjs --test --test-reporter=spec src/**/**.test.ts",
+    "test:unit": "node --import=./register.mjs --test --test-reporter=spec --enable-source-maps --trace-warnings 'src/**/*.test.ts'",
     "test:link": "yarn build && yarn link",
     "test:e2e": "yarn test:cjs && yarn test:esm && yarn test:web",
     "test:integration": "yarn build:esm && yarn link && cd ./tests/integration && yarn && yarn test",
@@ -91,8 +91,9 @@
     "@semantic-release/exec": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/npm": "^11.0.3",
+    "@swc/core": "^1.11.22",
     "@trivago/prettier-plugin-sort-imports": "^4.2.0",
-    "@types/node": "^20.12.12",
+    "@types/node": "^22.14.1",
     "@types/prompts": "^2.4.9",
     "@types/sinon": "^10.0.15",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
@@ -110,6 +111,7 @@
     "eslint-plugin-n": "^16.0.1",
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-promise": "^6.1.1",
+    "got": "^12.4.7",
     "http-server": "^14.1.1",
     "husky": "^8.0.3",
     "lint-staged": "^15.2.2",