@snapshot-labs/snapshot.js 0.14.4 → 0.14.6

package/dist/src/index.d.ts

@@ -812,6 +812,7 @@ declare const _default: {
     utils: {
         call: typeof import("./utils").call;
         multicall: typeof import("./multicall").multicall;
+        fetch: typeof import("./utils").fetch;
         subgraphRequest: typeof import("./utils").subgraphRequest;
         ipfsGet: typeof import("./utils").ipfsGet;
         getUrl: typeof import("./utils").getUrl;

package/dist/src/utils.d.ts

@@ -16,6 +16,41 @@ interface Strategy {
 export declare function call(provider: any, abi: any[], call: any[], options?: any): Promise<any>;
 export declare function subgraphRequest(url: string, query: any, options?: any): Promise<any>;
 export declare function getUrl(uri: any, gateway?: string): any;
+interface FetchOptions extends RequestInit {
+    timeout?: number;
+}
+/**
+ * Enhanced fetch with timeout support - drop-in replacement for native fetch
+ *
+ * @param url - The URL to fetch
+ * @param options - Fetch options with optional timeout
+ * @param options.timeout - Request timeout in milliseconds (default: 30000ms). Set to 0 to disable timeout.
+ *
+ * @returns Promise that resolves to the Response object
+ *
+ * @throws {Error} Throws timeout error if request exceeds the specified timeout duration
+ *
+ * @example
+ * ```typescript
+ * // Uses default 30s timeout
+ * const response = await fetch('https://api.example.com/data');
+ *
+ * // Custom 5s timeout
+ * const response = await fetch('https://api.example.com/data', { timeout: 5000 });
+ *
+ * // Disable timeout
+ * const response = await fetch('https://api.example.com/data', { timeout: 0 });
+ *
+ * // With additional fetch options
+ * const response = await fetch('https://api.example.com/data', {
+ *   timeout: 10000,
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ key: 'value' })
+ * });
+ * ```
+ */
+export declare function fetch(url: string, options?: FetchOptions): Promise<Response>;
 export declare function getJSON(uri: any, options?: any): Promise<any>;
 export declare function ipfsGet(gateway: string, ipfsHash: string, protocolType?: string): Promise<any>;
 export declare function sendTransaction(web3: any, contractAddress: string, abi: any[], action: string, params: any[], overrides?: {}): Promise<any>;
@@ -31,7 +66,7 @@ export declare function getEnsTextRecord(ens: string, record: string, network?:
 export declare function getSpaceUri(id: string, network?: string, options?: any): Promise<string | null>;
 export declare function getEnsOwner(ens: string, network?: string, options?: any): Promise<string>;
 export declare function getShibariumNameOwner(id: string, network: string): Promise<string>;
-export declare function getSonicNameOwner(id: string, network: string): Promise<string>;
+export declare function getUDNameOwner(id: string, network: string): Promise<string>;
 export declare function getSpaceController(id: string, network?: string, options?: any): Promise<string>;
 export declare function clone(item: any): any;
 export declare function sleep(time: any): Promise<unknown>;
@@ -43,6 +78,7 @@ export { getDelegatesBySpace, SNAPSHOT_SUBGRAPH_URL };
 declare const _default: {
     call: typeof call;
     multicall: typeof multicall;
+    fetch: typeof fetch;
     subgraphRequest: typeof subgraphRequest;
     ipfsGet: typeof ipfsGet;
     getUrl: typeof getUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapshot-labs/snapshot.js",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",

package/src/sign/index.ts

@@ -1,4 +1,4 @@
-import fetch from 'cross-fetch';
+import { fetch } from '../utils';
 import { Web3Provider } from '@ethersproject/providers';
 import { Wallet } from '@ethersproject/wallet';
 import {

package/src/utils.ts

@@ -1,4 +1,4 @@
-import fetch from 'cross-fetch';
+import crossFetch from 'cross-fetch';
 import { Contract } from '@ethersproject/contracts';
 import { getAddress, isAddress } from '@ethersproject/address';
 import { parseUnits } from '@ethersproject/units';
@@ -43,14 +43,17 @@ const ENS_ABI = [
   'function text(bytes32 node, string calldata key) external view returns (string memory)',
   'function resolver(bytes32 node) view returns (address)' // ENS registry ABI
 ];
-const SONIC_ABI = [
-  'function ownerOf(uint256 tokenId) external view returns (address address)'
+const UD_MAPPING = {
+  '146': {
+    tlds: ['.sonic'],
+    registryContract: '0xde1dadcf11a7447c3d093e97fdbd513f488ce3b4'
+  }
+};
+const UD_REGISTRY_ABI = [
+  'function ownerOf(uint256 tokenId) view returns (address owner)'
 ];
-const SONIC_CONTRACT_ADDRESS = '0xde1dadcf11a7447c3d093e97fdbd513f488ce3b4';
 const ENS_CHAIN_IDS = ['1', '11155111'];
 const SHIBARIUM_CHAIN_IDS = ['109', '157'];
-const SONIC_CHAIN_IDS = ['146'];
-const SONIC_TLD = '.sonic';
 const SHIBARIUM_TLD = '.shib';
 const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
 
@@ -311,9 +314,76 @@ export function getUrl(uri, gateway = gateways[0]) {
   return uri;
 }
 
+interface FetchOptions extends RequestInit {
+  timeout?: number;
+}
+
+/**
+ * Enhanced fetch with timeout support - drop-in replacement for native fetch
+ *
+ * @param url - The URL to fetch
+ * @param options - Fetch options with optional timeout
+ * @param options.timeout - Request timeout in milliseconds (default: 30000ms). Set to 0 to disable timeout.
+ *
+ * @returns Promise that resolves to the Response object
+ *
+ * @throws {Error} Throws timeout error if request exceeds the specified timeout duration
+ *
+ * @example
+ * ```typescript
+ * // Uses default 30s timeout
+ * const response = await fetch('https://api.example.com/data');
+ *
+ * // Custom 5s timeout
+ * const response = await fetch('https://api.example.com/data', { timeout: 5000 });
+ *
+ * // Disable timeout
+ * const response = await fetch('https://api.example.com/data', { timeout: 0 });
+ *
+ * // With additional fetch options
+ * const response = await fetch('https://api.example.com/data', {
+ *   timeout: 10000,
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ key: 'value' })
+ * });
+ * ```
+ */
+export async function fetch(
+  url: string,
+  options: FetchOptions = {}
+): Promise<Response> {
+  const { timeout = 30000, ...fetchOptions } = options;
+
+  if (timeout > 0) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await crossFetch(url, {
+        ...fetchOptions,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { signal, ...cleanFetchOptions } = fetchOptions;
+  return crossFetch(url, cleanFetchOptions);
+}
+
 export async function getJSON(uri, options: any = {}) {
   const url = getUrl(uri, options.gateways);
-  return fetch(url).then((res) => res.json());
+  const response = await fetch(url, options);
+  return response.json();
 }
 
 export async function ipfsGet(
@@ -701,23 +771,24 @@ export async function getShibariumNameOwner(
   return data.result;
 }
 
-export async function getSonicNameOwner(
+export async function getUDNameOwner(
   id: string,
   network: string
 ): Promise<string> {
-  if (!id.endsWith(SONIC_TLD)) {
+  const tlds = UD_MAPPING[network]?.tlds || [];
+  if (!tlds.some((tld: string) => id.endsWith(tld))) {
     return Promise.resolve(EMPTY_ADDRESS);
   }
 
   try {
     const hash = namehash(ensNormalize(id));
-    const tokenId = BigInt(hash).toString();
+    const tokenId = BigInt(hash);
     const provider = getProvider(network);
 
     return await call(
       provider,
-      SONIC_ABI,
-      [SONIC_CONTRACT_ADDRESS, 'ownerOf', [tokenId]],
+      UD_REGISTRY_ABI,
+      [UD_MAPPING[network].registryContract, 'ownerOf', [tokenId]],
       {
         blockTag: 'latest'
       }
@@ -736,8 +807,8 @@ export async function getSpaceController(
     return getEnsSpaceController(id, network, options);
   } else if (SHIBARIUM_CHAIN_IDS.includes(network)) {
     return getShibariumNameOwner(id, network);
-  } else if (SONIC_CHAIN_IDS.includes(network)) {
-    return getSonicNameOwner(id, network);
+  } else if (UD_MAPPING[String(network)]) {
+    return getUDNameOwner(id, network);
   }
 
   throw new Error(`Network not supported: ${network}`);
@@ -819,6 +890,7 @@ export { getDelegatesBySpace, SNAPSHOT_SUBGRAPH_URL };
 export default {
   call,
   multicall,
+  fetch,
   subgraphRequest,
   ipfsGet,
   getUrl,