@helia/trustless-gateway-client 0.0.0-9114743f

package/dist/src/broker.d.ts

@@ -0,0 +1,44 @@
+import type { TrustlessGatewayBlockBrokerInit, TrustlessGatewayBlockBrokerComponents, TrustlessGatewayGetBlockProgressEvents } from './index.ts';
+import type { TransformRequestInit } from './trustless-gateway.ts';
+import type { BlockRetrievalOptions, BlockBroker, CreateSessionOptions, SessionBlockBroker } from '@helia/interface';
+import type { CID } from 'multiformats/cid';
+export interface CreateTrustlessGatewaySessionOptions extends CreateSessionOptions<TrustlessGatewayGetBlockProgressEvents> {
+    /**
+     * By default we will only connect to peers with HTTPS addresses, pass true
+     * to also connect to HTTP addresses.
+     *
+     * @default false
+     */
+    allowInsecure?: boolean;
+    /**
+     * By default we will only connect to peers with public or DNS addresses, pass
+     * true to also connect to private addresses.
+     *
+     * @default false
+     */
+    allowLocal?: boolean;
+    /**
+     * Provide a function that will be called before querying trustless-gateways.
+     *
+     * This lets you modify the fetch options to pass custom headers or other
+     * necessary things.
+     */
+    transformRequestInit?: TransformRequestInit;
+}
+/**
+ * A class that accepts a list of trustless gateways that are queried
+ * for blocks.
+ */
+export declare class TrustlessGatewayBlockBroker implements BlockBroker<TrustlessGatewayGetBlockProgressEvents> {
+    readonly name = "trustless-gateway";
+    private readonly allowInsecure;
+    private readonly allowLocal;
+    private readonly transformRequestInit?;
+    private readonly routing;
+    private readonly log;
+    private readonly logger;
+    constructor(components: TrustlessGatewayBlockBrokerComponents, init?: TrustlessGatewayBlockBrokerInit);
+    retrieve(cid: CID, options?: BlockRetrievalOptions<TrustlessGatewayGetBlockProgressEvents>): Promise<Uint8Array>;
+    createSession(options?: CreateTrustlessGatewaySessionOptions): SessionBlockBroker<TrustlessGatewayGetBlockProgressEvents>;
+}
+//# sourceMappingURL=broker.d.ts.map

package/dist/src/broker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker.d.ts","sourceRoot":"","sources":["../../src/broker.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,+BAA+B,EAAE,qCAAqC,EAAE,sCAAsC,EAAE,MAAM,YAAY,CAAA;AAChJ,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAClE,OAAO,KAAK,EAAW,qBAAqB,EAAE,WAAW,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE7H,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAE3C,MAAM,WAAW,oCAAqC,SAAQ,oBAAoB,CAAC,sCAAsC,CAAC;IACxH;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;CAC5C;AAED;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,WAAW,CAAC,sCAAsC,CAAC;IACrG,SAAgB,IAAI,uBAAsB;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;gBAE3B,UAAU,EAAE,qCAAqC,EAAE,IAAI,GAAE,+BAAoC;IASpG,QAAQ,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,qBAAqB,CAAC,sCAAsC,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA2C3H,aAAa,CAAE,OAAO,GAAE,oCAAyC,GAAG,kBAAkB,CAAC,sCAAsC,CAAC;CAW/H"}

package/dist/src/broker.js

@@ -0,0 +1,75 @@
+import { DEFAULT_ALLOW_INSECURE, DEFAULT_ALLOW_LOCAL } from "./index.js";
+import { createTrustlessGatewaySession } from "./session.js";
+import { findHttpGatewayProviders } from "./utils.js";
+/**
+ * A class that accepts a list of trustless gateways that are queried
+ * for blocks.
+ */
+export class TrustlessGatewayBlockBroker {
+    name = 'trustless-gateway';
+    allowInsecure;
+    allowLocal;
+    transformRequestInit;
+    routing;
+    log;
+    logger;
+    constructor(components, init = {}) {
+        this.log = components.logger.forComponent('helia:trustless-gateway-block-broker');
+        this.logger = components.logger;
+        this.routing = components.routing;
+        this.allowInsecure = init.allowInsecure ?? DEFAULT_ALLOW_INSECURE;
+        this.allowLocal = init.allowLocal ?? DEFAULT_ALLOW_LOCAL;
+        this.transformRequestInit = init.transformRequestInit;
+    }
+    async retrieve(cid, options = {}) {
+        const aggregateErrors = [];
+        for await (const gateway of findHttpGatewayProviders(cid, this.routing, this.logger, this.allowInsecure, this.allowLocal, { ...options, transformRequestInit: this.transformRequestInit })) {
+            this.log('getting block for %c from %s', cid, gateway.url);
+            try {
+                const block = await gateway.getRawBlock(cid, options);
+                this.log.trace('got block for %c from %s', cid, gateway.url);
+                try {
+                    await options.validateFn?.(block);
+                }
+                catch (err) {
+                    this.log.error('failed to validate block for %c from %s - %e', cid, gateway.url, err);
+                    // try another gateway
+                    continue;
+                }
+                return block;
+            }
+            catch (err) {
+                this.log.error('failed to get block for %c from %s - %e', cid, gateway.url, err);
+                if (err instanceof Error) {
+                    aggregateErrors.push(err);
+                }
+                else {
+                    aggregateErrors.push(new Error(`Unable to fetch raw block for CID ${cid} from gateway ${gateway.url}`));
+                }
+                // if signal was aborted, exit the loop
+                if (options.signal?.aborted === true) {
+                    this.log.trace('request aborted while fetching raw block for CID %c from gateway %s', cid, gateway.url);
+                    break;
+                }
+            }
+        }
+        if (aggregateErrors.length > 0) {
+            throw new AggregateError(aggregateErrors, `Unable to fetch raw block for CID ${cid} from any gateway`);
+        }
+        else {
+            throw new Error(`Unable to fetch raw block for CID ${cid} from any gateway`);
+        }
+    }
+    createSession(options = {}) {
+        return createTrustlessGatewaySession({
+            logger: this.logger,
+            routing: this.routing
+        }, {
+            ...options,
+            allowLocal: this.allowLocal,
+            allowInsecure: this.allowInsecure,
+            transformRequestInit: this.transformRequestInit
+        });
+    }
+}
+//# sourceMappingURL=broker.js.map

package/dist/src/broker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker.js","sourceRoot":"","sources":["../../src/broker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAiCrD;;;GAGG;AACH,MAAM,OAAO,2BAA2B;IACtB,IAAI,GAAG,mBAAmB,CAAA;IACzB,aAAa,CAAS;IACtB,UAAU,CAAS;IACnB,oBAAoB,CAAuB;IAC3C,OAAO,CAAS;IAChB,GAAG,CAAQ;IACX,MAAM,CAAiB;IAExC,YAAa,UAAiD,EAAE,OAAwC,EAAE;QACxG,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,sCAAsC,CAAC,CAAA;QACjF,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAA;QAC/B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAA;QACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,IAAI,sBAAsB,CAAA;QACjE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,mBAAmB,CAAA;QACxD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,CAAA;IACvD,CAAC;IAED,KAAK,CAAC,QAAQ,CAAE,GAAQ,EAAE,UAAyE,EAAE;QACnG,MAAM,eAAe,GAAY,EAAE,CAAA;QAEnC,IAAI,KAAK,EAAE,MAAM,OAAO,IAAI,wBAAwB,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,GAAG,OAAO,EAAE,oBAAoB,EAAE,IAAI,CAAC,oBAAoB,EAAE,CAAC,EAAE,CAAC;YAC3L,IAAI,CAAC,GAAG,CAAC,8BAA8B,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;YAE1D,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;gBACrD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,0BAA0B,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;gBAE5D,IAAI,CAAC;oBACH,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAA;gBACnC,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,8CAA8C,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;oBACrF,sBAAsB;oBACtB,SAAQ;gBACV,CAAC;gBAED,OAAO,KAAK,CAAA;YACd,CAAC;YAAC,OAAO,GAAY,EAAE,CAAC;gBACtB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,yCAAyC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;gBAEhF,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;oBACzB,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBAC3B,CAAC;qBAAM,CAAC;oBACN,eAAe,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,qCAAqC,GAAG,iBAAiB,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;gBACzG,CAAC;gBAED,uCAAuC;gBACvC,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,EAAE,CAAC;oBACrC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,qEAAqE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;oBACvG,MAAK;gBACP,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,cAAc,CAAC,eAAe,EAAE,qCAAqC,GAAG,mBAAmB,CAAC,CAAA;QACxG,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,qCAAqC,GAAG,mBAAmB,CAAC,CAAA;QAC9E,CAAC;IACH,CAAC;IAED,aAAa,CAAE,UAAgD,EAAE;QAC/D,OAAO,6BAA6B,CAAC;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,EAAE;YACD,GAAG,OAAO;YACV,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;SAChD,CAAC,CAAA;IACJ,CAAC;CACF"}

package/dist/src/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @packageDocumentation
+ *
+ * A Trustless Gateway is an HTTP endpoint that can be used to download blocks
+ * or CAR files in a verifiable way.
+ */
+import type { TransformRequestInit } from './trustless-gateway.ts';
+import type { Routing, BlockBroker, RoutingFindProvidersProgressEvents, BlockBrokerGetBlockProgressEvents } from '@helia/interface';
+import type { ComponentLogger } from 'birnam';
+import type { CID } from 'multiformats';
+import type { ProgressEvent } from 'progress-events';
+export declare const DEFAULT_ALLOW_INSECURE = false;
+export declare const DEFAULT_ALLOW_LOCAL = false;
+/**
+ * The maximum number of bytes to allow when fetching a raw block.
+ *
+ * @see https://specs.ipfs.tech/bitswap-protocol/#block-sizes
+ */
+export declare const DEFAULT_MAX_SIZE = 2097152;
+export interface TrustlessGatewayProvider {
+    /**
+     * The type of provider
+     */
+    type: 'trustless-gateway';
+    /**
+     * The CID that the provider can provide the block for
+     */
+    cid: CID;
+    /**
+     * The provider's URL
+     */
+    url: string;
+    /**
+     * Which routing implementation found the provider
+     */
+    routing: string;
+}
+export type TrustlessGatewayGetBlockProgressEvents = ProgressEvent<'trustless-gateway:get-block:fetch', URL> | ProgressEvent<'trustless-gateway:found-provider', TrustlessGatewayProvider> | RoutingFindProvidersProgressEvents | BlockBrokerGetBlockProgressEvents;
+export interface TrustlessGatewayBlockBrokerInit {
+    /**
+     * By default we will only connect to peers with HTTPS addresses, pass true
+     * to also connect to HTTP addresses.
+     *
+     * @default false
+     */
+    allowInsecure?: boolean;
+    /**
+     * By default we will only connect to peers with public or DNS addresses, pass
+     * true to also connect to private addresses.
+     *
+     * @default false
+     */
+    allowLocal?: boolean;
+    /**
+     * Provide a function that will be called before querying trustless-gateways. This lets you modify the fetch options to pass custom headers or other necessary things.
+     */
+    transformRequestInit?: TransformRequestInit;
+}
+export interface TrustlessGatewayBlockBrokerComponents {
+    routing: Routing;
+    logger: ComponentLogger;
+}
+export declare function trustlessGatewayBlockBroker(init?: TrustlessGatewayBlockBrokerInit): (components: TrustlessGatewayBlockBrokerComponents) => BlockBroker<TrustlessGatewayGetBlockProgressEvents>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,kCAAkC,EAAE,iCAAiC,EAAE,MAAM,kBAAkB,CAAA;AACnI,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,eAAO,MAAM,sBAAsB,QAAQ,CAAA;AAC3C,eAAO,MAAM,mBAAmB,QAAQ,CAAA;AACxC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,UAAY,CAAA;AAEzC,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,IAAI,EAAE,mBAAmB,CAAA;IAEzB;;OAEG;IACH,GAAG,EAAE,GAAG,CAAA;IAER;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IAEX;;OAEG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,sCAAsC,GAChD,aAAa,CAAC,mCAAmC,EAAE,GAAG,CAAC,GACvD,aAAa,CAAC,kCAAkC,EAAE,wBAAwB,CAAC,GAC3E,kCAAkC,GAClC,iCAAiC,CAAA;AAEnC,MAAM,WAAW,+BAA+B;IAC9C;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;OAEG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;CAC5C;AAED,MAAM,WAAW,qCAAqC;IACpD,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,wBAAgB,2BAA2B,CAAE,IAAI,GAAE,+BAAoC,GAAG,CAAC,UAAU,EAAE,qCAAqC,KAAK,WAAW,CAAC,sCAAsC,CAAC,CAEnM"}

package/dist/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ *
+ * A Trustless Gateway is an HTTP endpoint that can be used to download blocks
+ * or CAR files in a verifiable way.
+ */
+import { TrustlessGatewayBlockBroker } from "./broker.js";
+export const DEFAULT_ALLOW_INSECURE = false;
+export const DEFAULT_ALLOW_LOCAL = false;
+/**
+ * The maximum number of bytes to allow when fetching a raw block.
+ *
+ * @see https://specs.ipfs.tech/bitswap-protocol/#block-sizes
+ */
+export const DEFAULT_MAX_SIZE = 2_097_152;
+export function trustlessGatewayBlockBroker(init = {}) {
+    return (components) => new TrustlessGatewayBlockBroker(components, init);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAOzD,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,CAAA;AAC3C,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAA;AACxC;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAA;AAyDzC,MAAM,UAAU,2BAA2B,CAAE,OAAwC,EAAE;IACrF,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,2BAA2B,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;AAC1E,CAAC"}

package/dist/src/session.d.ts

@@ -0,0 +1,30 @@
+import { AbstractSession } from '@helia/utils';
+import { CID } from 'multiformats/cid';
+import { TrustlessGateway } from './trustless-gateway.ts';
+import type { CreateTrustlessGatewaySessionOptions } from './broker.ts';
+import type { TrustlessGatewayGetBlockProgressEvents } from './index.ts';
+import type { BlockRetrievalOptions, Routing } from '@helia/interface';
+import type { Multiaddr } from '@multiformats/multiaddr';
+import type { AbortOptions } from 'abort-error';
+import type { ComponentLogger } from 'birnam';
+export interface TrustlessGatewaySessionComponents {
+    logger: ComponentLogger;
+    routing: Routing;
+}
+declare class TrustlessGatewaySession extends AbstractSession<TrustlessGateway, TrustlessGatewayGetBlockProgressEvents> {
+    readonly name = "trustless-gateway-session";
+    private readonly routing;
+    private readonly allowInsecure;
+    private readonly allowLocal;
+    private readonly transformRequestInit?;
+    constructor(components: TrustlessGatewaySessionComponents, init: CreateTrustlessGatewaySessionOptions);
+    queryProvider(cid: CID, provider: TrustlessGateway, options: BlockRetrievalOptions): Promise<Uint8Array>;
+    findNewProviders(cid: CID, options?: AbortOptions): AsyncGenerator<TrustlessGateway>;
+    toFilterKey(provider: TrustlessGateway): Uint8Array | string;
+    equals(providerA: TrustlessGateway, providerB: TrustlessGateway): boolean;
+    convertToProvider(provider: CID | Multiaddr | Multiaddr[], routing: string, options?: AbortOptions): Promise<TrustlessGateway | undefined>;
+    emitFoundProviderProgressEvent(cid: CID, provider: TrustlessGateway, options: BlockRetrievalOptions<TrustlessGatewayGetBlockProgressEvents>): void;
+}
+export declare function createTrustlessGatewaySession(components: TrustlessGatewaySessionComponents, init: CreateTrustlessGatewaySessionOptions): TrustlessGatewaySession;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/dist/src/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAS,MAAM,cAAc,CAAA;AAErD,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAGtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,sCAAsC,EAA4B,MAAM,YAAY,CAAA;AAElG,OAAO,KAAK,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAE7C,MAAM,WAAW,iCAAiC;IAChD,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,cAAM,uBAAwB,SAAQ,eAAe,CAAC,gBAAgB,EAAE,sCAAsC,CAAC;IAC7G,SAAgB,IAAI,+BAA8B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAsB;gBAE/C,UAAU,EAAE,iCAAiC,EAAE,IAAI,EAAE,oCAAoC;IAYhG,aAAa,CAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC;IA6BvG,gBAAgB,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,YAAiB,GAAG,cAAc,CAAC,gBAAgB,CAAC;IAIjG,WAAW,CAAE,QAAQ,EAAE,gBAAgB,GAAG,UAAU,GAAG,MAAM;IAI7D,MAAM,CAAE,SAAS,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,GAAG,OAAO;IAIpE,iBAAiB,CAAE,QAAQ,EAAE,GAAG,GAAG,SAAS,GAAG,SAAS,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IA0BjJ,8BAA8B,CAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,qBAAqB,CAAC,sCAAsC,CAAC,GAAG,IAAI;CAQpJ;AAED,wBAAgB,6BAA6B,CAAE,UAAU,EAAE,iCAAiC,EAAE,IAAI,EAAE,oCAAoC,GAAG,uBAAuB,CAEjK"}

package/dist/src/session.js

@@ -0,0 +1,89 @@
+import { AbstractSession, isCID } from '@helia/utils';
+import { multiaddrToUri } from '@multiformats/multiaddr-to-uri';
+import { CID } from 'multiformats/cid';
+import { CustomProgressEvent } from 'progress-events';
+import { DEFAULT_ALLOW_INSECURE, DEFAULT_ALLOW_LOCAL } from "./index.js";
+import { TrustlessGateway } from "./trustless-gateway.js";
+import { filterNonHTTPMultiaddrs, findHttpGatewayProviders } from "./utils.js";
+class TrustlessGatewaySession extends AbstractSession {
+    name = 'trustless-gateway-session';
+    routing;
+    allowInsecure;
+    allowLocal;
+    transformRequestInit;
+    constructor(components, init) {
+        super(components, {
+            ...init,
+            name: 'helia:trustless-gateway:session'
+        });
+        this.routing = components.routing;
+        this.allowInsecure = init.allowInsecure ?? DEFAULT_ALLOW_INSECURE;
+        this.allowLocal = init.allowLocal ?? DEFAULT_ALLOW_LOCAL;
+        this.transformRequestInit = init.transformRequestInit;
+    }
+    async queryProvider(cid, provider, options) {
+        this.log('fetching BLOCK for %c from %s', cid, provider.url);
+        options?.onProgress?.(new CustomProgressEvent('helia:block-brokers:query-provider:start', {
+            blockBroker: 'trustless-gateway',
+            provider: provider.url,
+            transport: 'http',
+            cid
+        }));
+        let block;
+        try {
+            block = await provider.getRawBlock(cid, options);
+            this.log.trace('got block for %c from %s', cid, provider.url);
+        }
+        finally {
+            options?.onProgress?.(new CustomProgressEvent('helia:block-brokers:query-provider:end', {
+                blockBroker: 'trustless-gateway',
+                provider: provider.url,
+                transport: 'http',
+                cid
+            }));
+        }
+        await options.validateFn?.(block);
+        return block;
+    }
+    async *findNewProviders(cid, options = {}) {
+        yield* findHttpGatewayProviders(cid, this.routing, this.logger, this.allowInsecure, this.allowLocal, { ...options, transformRequestInit: this.transformRequestInit });
+    }
+    toFilterKey(provider) {
+        return provider.url.toString();
+    }
+    equals(providerA, providerB) {
+        return providerA.url.toString() === providerB.url.toString();
+    }
+    async convertToProvider(provider, routing, options) {
+        options?.signal?.throwIfAborted();
+        if (isCID(provider)) {
+            return;
+        }
+        const httpAddresses = filterNonHTTPMultiaddrs(Array.isArray(provider) ? provider : [provider], this.allowInsecure, this.allowLocal);
+        if (httpAddresses.length === 0) {
+            return;
+        }
+        // take first address?
+        // /ip4/x.x.x.x/tcp/31337/http
+        // /ip4/x.x.x.x/tcp/31337/https
+        // etc
+        const uri = multiaddrToUri(httpAddresses[0]);
+        return new TrustlessGateway(uri, {
+            logger: this.logger,
+            transformRequestInit: this.transformRequestInit,
+            routing
+        });
+    }
+    emitFoundProviderProgressEvent(cid, provider, options) {
+        options?.onProgress?.(new CustomProgressEvent('trustless-gateway:found-provider', {
+            type: 'trustless-gateway',
+            cid,
+            url: provider.url.toJSON(),
+            routing: provider.routing
+        }));
+    }
+}
+export function createTrustlessGatewaySession(components, init) {
+    return new TrustlessGatewaySession(components, init);
+}
+//# sourceMappingURL=session.js.map

package/dist/src/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"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"}

package/dist/src/trustless-gateway.d.ts

@@ -0,0 +1,64 @@
+import { CID } from 'multiformats/cid';
+import type { BlockBrokerGetBlockProgressEvents } from '@helia/interface';
+import type { ComponentLogger } from 'birnam';
+import type { ProgressOptions } from 'progress-events';
+export interface TrustlessGatewayStats {
+    attempts: number;
+    errors: number;
+    invalidBlocks: number;
+    successes: number;
+    pendingResponses?: number;
+}
+export interface TransformRequestInit {
+    (defaultReqInit: RequestInit): Promise<RequestInit> | RequestInit;
+}
+export interface TrustlessGatewayComponents {
+    logger: ComponentLogger;
+    transformRequestInit?: TransformRequestInit;
+    routing: string;
+}
+export interface GetRawBlockOptions extends ProgressOptions<BlockBrokerGetBlockProgressEvents> {
+    signal?: AbortSignal;
+    /**
+     * The maximum number of bytes to allow when fetching a raw block.
+     *
+     * @default 2_097_152 (2MiB)
+     */
+    maxSize?: number;
+}
+/**
+ * A `TrustlessGateway` keeps track of the number of attempts, errors, and
+ * successes for a given gateway url so that we can prioritize gateways that
+ * have been more reliable in the past, and ensure that requests are distributed
+ * across all gateways within a given `TrustlessGatewayBlockBroker` instance.
+ */
+export declare class TrustlessGateway {
+    #private;
+    readonly url: URL;
+    private readonly peer;
+    private readonly log;
+    private readonly transformRequestInit?;
+    readonly routing: string;
+    constructor(url: URL | string, { logger, transformRequestInit, routing }: TrustlessGatewayComponents);
+    /**
+     * Fetch a raw block from `this.url` following the specification defined at
+     * https://specs.ipfs.tech/http-gateways/trustless-gateway/
+     */
+    getRawBlock(cid: CID, options?: GetRawBlockOptions): Promise<Uint8Array>;
+    /**
+     * Encapsulate the logic for determining whether a gateway is considered
+     * reliable, for prioritization. This is based on the number of successful attempts made
+     * and the number of errors encountered.
+     *
+     * Unused gateways have 100% reliability; They will be prioritized over
+     * gateways with a 100% success rate to ensure that we attempt all gateways.
+     */
+    reliability(): number;
+    /**
+     * Increment the number of invalid blocks returned by this gateway.
+     */
+    incrementInvalidBlocks(): void;
+    getStats(): TrustlessGatewayStats;
+    toString(): string;
+}
+//# sourceMappingURL=trustless-gateway.d.ts.map

package/dist/src/trustless-gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trustless-gateway.d.ts","sourceRoot":"","sources":["../../src/trustless-gateway.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAMtC,OAAO,KAAK,EAAsE,iCAAiC,EAA8E,MAAM,kBAAkB,CAAA;AACzN,OAAO,KAAK,EAAE,eAAe,EAAU,MAAM,QAAQ,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAItD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,CAAC,cAAc,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAA;CAClE;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,eAAe,CAAA;IACvB,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe,CAAC,iCAAiC,CAAC;IAC5F,MAAM,CAAC,EAAE,WAAW,CAAA;IAEpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;GAKG;AACH,qBAAa,gBAAgB;;IAC3B,SAAgB,GAAG,EAAE,GAAG,CAAA;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAK;IAqC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAsB;IAE5D,SAAgB,OAAO,EAAE,MAAM,CAAA;gBAElB,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,EAAE,0BAA0B;IAsBrG;;;OAGG;IACG,WAAW,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;IA0GnF;;;;;;;OAOG;IACH,WAAW,IAAK,MAAM;IAyBtB;;OAEG;IACH,sBAAsB,IAAK,IAAI;IAI/B,QAAQ,IAAK,qBAAqB;IAUlC,QAAQ,IAAK,MAAM;CAGpB"}

package/dist/src/trustless-gateway.js

@@ -0,0 +1,217 @@
+import { uriToMultiaddr } from '@multiformats/uri-to-multiaddr';
+import { base64 } from 'multiformats/bases/base64';
+import { CID } from 'multiformats/cid';
+import { identity } from 'multiformats/hashes/identity';
+import { CustomProgressEvent } from 'progress-events';
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
+import { DEFAULT_MAX_SIZE } from "./index.js";
+import { limitedResponse } from "./utils.js";
+const TRANSPORT_IPFS_GATEWAY_HTTP_CODE = 0x0920;
+/**
+ * A `TrustlessGateway` keeps track of the number of attempts, errors, and
+ * successes for a given gateway url so that we can prioritize gateways that
+ * have been more reliable in the past, and ensure that requests are distributed
+ * across all gateways within a given `TrustlessGatewayBlockBroker` instance.
+ */
+export class TrustlessGateway {
+    url;
+    peer;
+    /**
+     * The number of times this gateway has been attempted to be used to fetch a
+     * block. This includes successful, errored, and aborted attempts. By counting
+     * even aborted attempts, slow gateways that are out-raced by others will be
+     * considered less reliable.
+     */
+    #attempts = 0;
+    /**
+     * The number of times this gateway has errored while attempting to fetch a
+     * block. This includes `response.ok === false` and any other errors that
+     * throw while attempting to fetch a block. This does not include aborted
+     * attempts.
+     */
+    #errors = 0;
+    /**
+     * The number of times this gateway has returned an invalid block. A gateway
+     * that returns the wrong blocks for a CID should be considered for removal
+     * from the list of gateways to fetch blocks from.
+     */
+    #invalidBlocks = 0;
+    /**
+     * The number of times this gateway has successfully fetched a block.
+     */
+    #successes = 0;
+    /**
+     * A map of pending responses for this gateway. This is used to ensure that
+     * only one request per CID is made to a given gateway at a time, and that we
+     * don't make multiple in-flight requests for the same CID to the same gateway.
+     */
+    #pendingResponses = new Map();
+    log;
+    transformRequestInit;
+    routing;
+    constructor(url, { logger, transformRequestInit, routing }) {
+        this.url = url instanceof URL ? url : new URL(url);
+        this.transformRequestInit = transformRequestInit;
+        this.log = logger.forComponent(`helia:trustless-gateway-block-broker:${this.url.host}`);
+        this.routing = routing;
+        this.peer = CID.createV1(TRANSPORT_IPFS_GATEWAY_HTTP_CODE, identity.digest(uint8ArrayFromString(this.url.toString())));
+    }
+    /**
+     * This function returns a unique string for the multihash.bytes of the CID.
+     *
+     * Some useful resources for why this is needed can be found using the links below:
+     *
+     * - https://github.com/ipfs/helia/pull/503#discussion_r1572451331
+     * - https://github.com/ipfs/kubo/issues/6815
+     * - https://www.notion.so/pl-strflt/Handling-ambiguity-around-CIDs-9d5e14f6516f438980b01ef188efe15d#d9d45cd1ed8b4d349b96285de4aed5ab
+     */
+    #uniqueBlockId(cid) {
+        const multihashBytes = cid.multihash.bytes;
+        return base64.encode(multihashBytes);
+    }
+    /**
+     * Fetch a raw block from `this.url` following the specification defined at
+     * https://specs.ipfs.tech/http-gateways/trustless-gateway/
+     */
+    async getRawBlock(cid, options = {}) {
+        const gwUrl = new URL(this.url.toString());
+        gwUrl.pathname = `/ipfs/${cid.toString()}`;
+        const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+        // necessary as not every gateway supports dag-cbor, but every should support
+        // sending raw block as-is
+        gwUrl.search = '?format=raw';
+        if (options.signal?.aborted === true) {
+            throw new Error(`Signal to fetch raw block for CID ${cid} from gateway ${this.url} was aborted prior to fetch`);
+        }
+        const blockId = this.#uniqueBlockId(cid);
+        // workaround for https://github.com/nodejs/node/issues/52635
+        const innerController = new AbortController();
+        const abortInnerSignal = () => {
+            innerController.abort();
+        };
+        options.signal?.addEventListener('abort', abortInnerSignal);
+        try {
+            let pendingResponse = this.#pendingResponses.get(blockId);
+            if (pendingResponse == null) {
+                this.#attempts++;
+                const defaultReqInit = {
+                    signal: innerController.signal,
+                    headers: {
+                        Accept: 'application/vnd.ipld.raw'
+                    },
+                    cache: 'force-cache'
+                };
+                const reqInit = this.transformRequestInit != null ? await this.transformRequestInit(defaultReqInit) : defaultReqInit;
+                const headers = new Headers(reqInit.headers);
+                this.log(`sending request
+%s %s HTTP/1.1
+%s
+`, reqInit.method ?? 'GET', gwUrl, [...headers.entries()].map(([key, value]) => `${key}: ${value}`).join('\n'));
+                options.onProgress?.(new CustomProgressEvent('helia:block-broker:connect', {
+                    broker: 'trustless-gateway',
+                    type: 'connect',
+                    provider: this.peer,
+                    cid
+                }));
+                pendingResponse = fetch(gwUrl.toString(), reqInit).then(async (res) => {
+                    this.log(`received response
+HTTP/1.1 %d %s
+%s
+`, res.status, res.statusText, [...res.headers.entries()].map(([key, value]) => `${key}: ${value}`).join('\n'));
+                    if (!res.ok) {
+                        this.#errors++;
+                        throw new Error(`Unable to fetch raw block for CID ${cid} from gateway ${this.url}, received ${res.status} ${res.statusText}`);
+                    }
+                    options.onProgress?.(new CustomProgressEvent('helia:block-broker:connected', {
+                        broker: 'trustless-gateway',
+                        type: 'connected',
+                        provider: this.peer,
+                        address: uriToMultiaddr(gwUrl.toString()),
+                        cid
+                    }));
+                    options.onProgress?.(new CustomProgressEvent('helia:block-broker:request-block', {
+                        broker: 'trustless-gateway',
+                        type: 'request-block',
+                        provider: this.peer,
+                        cid
+                    }));
+                    // limited Response ensures the body is less than 2MiB (or configurable maxSize)
+                    // see https://github.com/ipfs/helia/issues/790
+                    const body = await limitedResponse(res, maxSize, { signal: innerController.signal, log: this.log });
+                    options.onProgress?.(new CustomProgressEvent('helia:block-broker:receive-block', {
+                        broker: 'trustless-gateway',
+                        type: 'receive-block',
+                        provider: this.peer,
+                        cid
+                    }));
+                    this.#successes++;
+                    return body;
+                });
+                this.#pendingResponses.set(blockId, pendingResponse);
+            }
+            return await pendingResponse;
+        }
+        catch (cause) {
+            // @ts-expect-error - TS thinks signal?.aborted can only be false now
+            // because it was checked for true above.
+            if (options.signal?.aborted === true) {
+                throw new Error(`Fetching raw block for CID ${cid} from gateway ${this.url} was aborted`);
+            }
+            this.#errors++;
+            throw new Error(`Unable to fetch raw block for CID ${cid} - ${cause.message}`);
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abortInnerSignal);
+            this.#pendingResponses.delete(blockId);
+        }
+    }
+    /**
+     * Encapsulate the logic for determining whether a gateway is considered
+     * reliable, for prioritization. This is based on the number of successful attempts made
+     * and the number of errors encountered.
+     *
+     * Unused gateways have 100% reliability; They will be prioritized over
+     * gateways with a 100% success rate to ensure that we attempt all gateways.
+     */
+    reliability() {
+        /**
+         * if we have never tried to use this gateway, it is considered the most
+         * reliable until we determine otherwise (prioritize unused gateways)
+         */
+        if (this.#attempts === 0) {
+            return 1;
+        }
+        if (this.#invalidBlocks > 0) {
+            // this gateway may not be trustworthy..
+            return -Infinity;
+        }
+        /**
+         * We have attempted the gateway, so we need to calculate the reliability
+         * based on the number of attempts, errors, and successes. Gateways that
+         * return a single error should drop their reliability score more than a
+         * single success increases it.
+         *
+         * Play around with the below reliability function at https://www.desmos.com/calculator/d6hfhf5ukm
+         */
+        return this.#successes / (this.#attempts + (this.#errors * 3));
+    }
+    /**
+     * Increment the number of invalid blocks returned by this gateway.
+     */
+    incrementInvalidBlocks() {
+        this.#invalidBlocks++;
+    }
+    getStats() {
+        return {
+            attempts: this.#attempts,
+            errors: this.#errors,
+            invalidBlocks: this.#invalidBlocks,
+            successes: this.#successes,
+            pendingResponses: this.#pendingResponses.size
+        };
+    }
+    toString() {
+        return `TrustlessGateway(${this.url})`;
+    }
+}
+//# sourceMappingURL=trustless-gateway.js.map