@hypercerts-org/marketplace-sdk 0.0.24 → 0.1.1

package/dist/HypercertExchangeClient.d.ts

@@ -1,16 +1,16 @@
 import { BigNumberish, ContractTransactionResponse, Overrides, Provider, Signer, TypedDataDomain } from "ethers";
-import * as api from "./utils/api";
 import { Addresses, BatchTransferItem, ChainId, ContractMethods, CreateMakerAskOutput, CreateMakerBidOutput, CreateMakerCollectionOfferInput, CreateMakerCollectionOfferWithProofInput, CreateMakerInput, Maker, MerkleTree, OrderValidatorCode, SignMerkleTreeOrdersOutput, StrategyInfo, StrategyType, Taker } from "./types";
+import { ApiClient } from "./utils/api";
 /**
- * LooksRare
- * This class provides helpers to interact with the LooksRare V2 contracts
+ * HypercertExchange
+ * This class provides helpers to interact with the HypercertExchange V2 contracts
  */
 export declare class HypercertExchangeClient {
     /** Current app chain ID */
     readonly chainId: ChainId;
-    /** Mapping of LooksRare protocol addresses for the current chain */
+    /** Mapping of Hypercert protocol addresses for the current chain */
     readonly addresses: Addresses;
-    readonly api: typeof api;
+    readonly api: ApiClient;
     /**
      * Ethers signer
      * @see {@link https://docs.ethers.org/v6/api/providers/#Signer Ethers signer doc}
@@ -22,13 +22,16 @@ export declare class HypercertExchangeClient {
      */
     readonly provider: Provider;
     /**
-     * LooksRare protocol main class
+     * HypercertExchange protocol main class
      * @param chainId Current app chain id
      * @param provider Ethers provider
      * @param signer Ethers signer
-     * @param override Overrides contract addresses for hardhat setup
+     * @param overrides Override contract addresses or api endpoint used
      */
-    constructor(chainId: ChainId, provider: Provider, signer?: Signer, override?: Addresses);
+    constructor(chainId: ChainId, provider: Provider, signer?: Signer, overrides?: {
+        addresses: Addresses;
+        apiEndpoint?: string;
+    });
     /**
      * Return the signer it it's set, throw an exception otherwise
      * @returns Signer
@@ -135,9 +138,9 @@ export declare class HypercertExchangeClient {
         signature: string;
         merkleTree?: MerkleTree;
     }[], isAtomic: boolean, overrides?: Overrides): {
-        call: (additionalOverrides?: any) => any;
-        estimateGas: (additionalOverrides?: any) => any;
-        callStatic: (additionalOverrides?: any) => any;
+        call: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
+        estimateGas: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
+        callStatic: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
     };
     /**
      * Cancell all maker bid and/or ask orders for the current user
@@ -159,7 +162,7 @@ export declare class HypercertExchangeClient {
      */
     cancelSubsetOrders(nonces: BigNumberish[], overrides?: Overrides): ContractMethods;
     /**
-     * Approve all the items of a collection, to eventually be traded on LooksRare
+     * Approve all the items of a collection, to eventually be traded on HypercertExchange
      * The spender is the TransferManager.
      * @param collectionAddress Address of the collection to be approved.
      * @param approved true to approve, false to revoke the approval (default to true)
@@ -167,8 +170,8 @@ export declare class HypercertExchangeClient {
      */
     approveAllCollectionItems(collectionAddress: string, approved?: boolean, overrides?: Overrides): Promise<ContractTransactionResponse>;
     /**
-     * Approve an ERC20 to be used as a currency on LooksRare.
-     * The spender is the LooksRareProtocol contract.
+     * Approve an ERC20 to be used as a currency on HypercertExchange.
+     * The spender is the HypercertExchangeProtocol contract.
      * @param tokenAddress Address of the ERC20 to approve
      * @param amount Amount to be approved (default to MaxUint256)
      * @returns ContractTransaction

package/dist/index.cjs.js

@@ -4804,119 +4804,120 @@ const contractName = "LooksRareProtocol";
  */
 const version = 2;
 
-const HYPERCERTS_MARKETPLACE_API_URL = "https://staging.hyperboards.org/api";
+const HYPERCERTS_MARKETPLACE_API_URL = "http://localhost:3000/api";
 const SUPABASE_HYPERCERTS_URL = "https://clagjjfinooizoqdkvqc.supabase.co";
 const SUPABASE_HYPERCERTS_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNsYWdqamZpbm9vaXpvcWRrdnFjIiwicm9sZSI6ImFub24iLCJpYXQiOjE2NzY5NTAxNDAsImV4cCI6MTk5MjUyNjE0MH0.LOIW3NcYEfF7w893PS3Ne1VrntACE3OPeSRFkspvyqw";
 const supabaseHypercerts = supabaseJs.createClient(SUPABASE_HYPERCERTS_URL, SUPABASE_HYPERCERTS_ANON_KEY);
-/**
- * Fetches order nonce from api
- * @param address Address
- * @param chainId Chain ID
- */
-const fetchOrderNonce = async ({ address, chainId }) => {
-    return fetch(`${HYPERCERTS_MARKETPLACE_API_URL}/marketplace/order-nonce/`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            address,
-            chainId,
-        }),
-    })
-        .then((res) => res.json())
-        .then((res) => res.data);
-};
-/**
- * Registers order in api
- * @param order Order
- * @param signer Signer
- * @param signature Signature
- * @param quoteType Quote type
- * @param chainId Chain ID
- */
-const registerOrder = async ({ order, signer, signature, quoteType, chainId, }) => {
-    const { globalNonce, ...orderWithoutGlobalNonce } = order;
-    return fetch(`${HYPERCERTS_MARKETPLACE_API_URL}/marketplace/order/`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            ...orderWithoutGlobalNonce,
-            globalNonce: globalNonce.toString(10),
-            price: order.price.toString(10),
-            quoteType,
-            signer,
-            signature,
-            chainId,
-        }),
-    }).then((res) => res.json());
-};
-/**
- * Fetches orders from api by hypercert ID
- * @param hypercertId Hypercert ID
- * @param chainId Chain ID
- */
-const fetchOrdersByHypercertId = async ({ hypercertId, chainId }) => {
-    const hypercertsClient = new sdk.HypercertClient({
-        chain: { id: chainId },
-    });
-    const fractions = await hypercertsClient.indexer.fractionsByClaim(hypercertId);
-    const tokenIds = fractions.claimTokens.map((fraction) => fraction.tokenID);
-    return supabaseHypercerts.from("marketplace-orders").select("*").containedBy("itemIds", tokenIds).throwOnError();
-};
-/**
- * Fetch existing open orders from the marketplace API
- * @param signer address of the user that created the order
- * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
- * @param chainId chain id for the order
- * @param strategy strategy for the order
- */
-const fetchOrders = async ({ signer, claimTokenIds, chainId, strategy }) => {
-    let baseQuery = supabaseHypercerts.from("marketplace-orders").select("*");
-    if (signer) {
-        baseQuery.eq("signer", signer);
-    }
-    if (claimTokenIds) {
-        baseQuery = baseQuery.overlaps("itemIds", claimTokenIds);
-    }
-    if (chainId) {
-        baseQuery.eq("chainId", chainId);
-    }
-    if (strategy) {
-        baseQuery.eq("strategyId", strategy);
+class ApiClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        /**
+         * Fetches order nonce from api
+         * @param address Address
+         * @param chainId Chain ID
+         */
+        this.fetchOrderNonce = async ({ address, chainId }) => {
+            return fetch(`${this.baseUrl}/marketplace/order-nonce/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    address,
+                    chainId,
+                }),
+            })
+                .then((res) => res.json())
+                .then((res) => res.data);
+        };
+        /**
+         * Registers order in api
+         * @param order Order
+         * @param signer Signer
+         * @param signature Signature
+         * @param quoteType Quote type
+         * @param chainId Chain ID
+         */
+        this.registerOrder = async ({ order, signer, signature, quoteType, chainId, }) => {
+            const { globalNonce, ...orderWithoutGlobalNonce } = order;
+            return fetch(`${this.baseUrl}/marketplace/order/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    ...orderWithoutGlobalNonce,
+                    globalNonce: globalNonce.toString(10),
+                    price: order.price.toString(10),
+                    quoteType,
+                    signer,
+                    signature,
+                    chainId,
+                }),
+            }).then((res) => res.json());
+        };
+        /**
+         * Fetch existing open orders from the marketplace API
+         * @param signer address of the user that created the order
+         * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
+         * @param chainId chain id for the order
+         * @param strategy strategy for the order
+         */
+        this.fetchOrders = async ({ signer, claimTokenIds, chainId, strategy }) => {
+            let baseQuery = supabaseHypercerts.from("marketplace-orders").select("*");
+            if (signer) {
+                baseQuery.eq("signer", signer);
+            }
+            if (claimTokenIds) {
+                baseQuery = baseQuery.overlaps("itemIds", claimTokenIds);
+            }
+            if (chainId) {
+                baseQuery.eq("chainId", chainId);
+            }
+            if (strategy) {
+                baseQuery.eq("strategyId", strategy);
+            }
+            return baseQuery.throwOnError();
+        };
+        /**
+         * Fetches orders from api by hypercert ID
+         * @param hypercertId Hypercert ID
+         * @param chainId Chain ID
+         */
+        this.fetchOrdersByHypercertId = async ({ hypercertId, chainId }) => {
+            const hypercertsClient = new sdk.HypercertClient({
+                chain: { id: chainId },
+            });
+            const fractions = await hypercertsClient.indexer.fractionsByClaim(hypercertId);
+            const tokenIds = fractions.claimTokens.map((fraction) => fraction.tokenID);
+            return supabaseHypercerts.from("marketplace-orders").select("*").containedBy("itemIds", tokenIds).throwOnError();
+        };
+        const url = baseUrl || HYPERCERTS_MARKETPLACE_API_URL;
+        if (!url) {
+            throw new Error("No API URL provided");
+        }
+        this._baseUrl = url;
     }
-    return baseQuery.throwOnError();
-};
-
-var api = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  fetchOrderNonce: fetchOrderNonce,
-  fetchOrders: fetchOrders,
-  fetchOrdersByHypercertId: fetchOrdersByHypercertId,
-  registerOrder: registerOrder,
-  supabaseHypercerts: supabaseHypercerts
-});
+}
 
 /**
- * LooksRare
- * This class provides helpers to interact with the LooksRare V2 contracts
+ * HypercertExchange
+ * This class provides helpers to interact with the HypercertExchange V2 contracts
  */
 class HypercertExchangeClient {
     /**
-     * LooksRare protocol main class
+     * HypercertExchange protocol main class
      * @param chainId Current app chain id
      * @param provider Ethers provider
      * @param signer Ethers signer
-     * @param override Overrides contract addresses for hardhat setup
+     * @param overrides Override contract addresses or api endpoint used
      */
-    constructor(chainId, provider, signer, override) {
+    constructor(chainId, provider, signer, overrides) {
         this.chainId = chainId;
-        this.addresses = override ?? addressesByNetwork[this.chainId];
+        this.addresses = overrides?.addresses ?? addressesByNetwork[this.chainId];
         this.signer = signer;
         this.provider = provider;
-        this.api = api;
+        this.api = new ApiClient(overrides?.apiEndpoint);
     }
     /**
      * Return the signer it it's set, throw an exception otherwise
@@ -5209,7 +5210,7 @@ class HypercertExchangeClient {
         return cancelSubsetNonces(signer, this.addresses.EXCHANGE_V2, nonces, overrides);
     }
     /**
-     * Approve all the items of a collection, to eventually be traded on LooksRare
+     * Approve all the items of a collection, to eventually be traded on HypercertExchange
      * The spender is the TransferManager.
      * @param collectionAddress Address of the collection to be approved.
      * @param approved true to approve, false to revoke the approval (default to true)
@@ -5221,8 +5222,8 @@ class HypercertExchangeClient {
         return setApprovalForAll(signer, collectionAddress, spenderAddress, approved, overrides);
     }
     /**
-     * Approve an ERC20 to be used as a currency on LooksRare.
-     * The spender is the LooksRareProtocol contract.
+     * Approve an ERC20 to be used as a currency on HypercertExchange.
+     * The spender is the HypercertExchangeProtocol contract.
      * @param tokenAddress Address of the ERC20 to approve
      * @param amount Amount to be approved (default to MaxUint256)
      * @returns ContractTransaction
@@ -5307,7 +5308,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        const { nonce_counter } = await fetchOrderNonce({
+        const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
             chainId,
         });
@@ -5348,7 +5349,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        const { nonce_counter } = await fetchOrderNonce({
+        const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
             chainId,
         });
@@ -5404,7 +5405,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        return registerOrder({
+        return this.api.registerOrder({
             order,
             signer: address,
             signature,

package/dist/index.d.ts

@@ -23,12 +23,12 @@ declare const utils: {
     cancelOrderNonces: (signer: import("ethers").Signer, address: string, nonces: import("ethers").BigNumberish[], overrides?: import("ethers").Overrides | undefined) => import("./types").ContractMethods;
     cancelSubsetNonces: (signer: import("ethers").Signer, address: string, nonces: import("ethers").BigNumberish[], overrides?: import("ethers").Overrides | undefined) => import("./types").ContractMethods;
     incrementBidAskNonces: (signer: import("ethers").Signer, address: string, bid: boolean, ask: boolean, overrides?: import("ethers").Overrides | undefined) => import("./types").ContractMethods;
-    executeTakerBid: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker, maker: import("./types").Maker, makerSignature: string, merkleTree: import("./types").MerkleTree, overrides?: any) => import("./types").ContractMethods;
-    executeTakerAsk: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker, maker: import("./types").Maker, makerSignature: string, merkleTree: import("./types").MerkleTree, overrides?: any) => import("./types").ContractMethods;
-    executeMultipleTakerBids: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker[], maker: import("./types").Maker[], makerSignature: string[], isAtomic: boolean, merkleTree: import("./types").MerkleTree[], overrides?: any) => {
-        call: (additionalOverrides?: any) => any;
-        estimateGas: (additionalOverrides?: any) => any;
-        callStatic: (additionalOverrides?: any) => any;
+    executeTakerBid: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker, maker: import("./types").Maker, makerSignature: string, merkleTree: import("./types").MerkleTree, overrides?: import("./typechain/common").PayableOverrides | undefined) => import("./types").ContractMethods;
+    executeTakerAsk: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker, maker: import("./types").Maker, makerSignature: string, merkleTree: import("./types").MerkleTree, overrides?: import("./typechain/common").PayableOverrides | undefined) => import("./types").ContractMethods;
+    executeMultipleTakerBids: (signer: import("ethers").Signer, address: string, taker: import("./types").Taker[], maker: import("./types").Maker[], makerSignature: string[], isAtomic: boolean, merkleTree: import("./types").MerkleTree[], overrides?: import("./typechain/common").PayableOverrides | undefined) => {
+        call: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
+        estimateGas: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
+        callStatic: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => any;
     };
     setApprovalForAll: (signer: import("ethers").Signer, collection: string, operator: string, approved: boolean, overrides?: import("ethers").Overrides | undefined) => Promise<import("ethers").ContractTransactionResponse>;
     isApprovedForAll: (signerOrProvider: import("ethers").Signer | import("ethers").Provider, collection: string, account: string, operator: string, overrides?: import("ethers").Overrides | undefined) => Promise<boolean>;

package/dist/index.esm.js

@@ -4802,119 +4802,120 @@ const contractName = "LooksRareProtocol";
  */
 const version = 2;
 
-const HYPERCERTS_MARKETPLACE_API_URL = "https://staging.hyperboards.org/api";
+const HYPERCERTS_MARKETPLACE_API_URL = "http://localhost:3000/api";
 const SUPABASE_HYPERCERTS_URL = "https://clagjjfinooizoqdkvqc.supabase.co";
 const SUPABASE_HYPERCERTS_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNsYWdqamZpbm9vaXpvcWRrdnFjIiwicm9sZSI6ImFub24iLCJpYXQiOjE2NzY5NTAxNDAsImV4cCI6MTk5MjUyNjE0MH0.LOIW3NcYEfF7w893PS3Ne1VrntACE3OPeSRFkspvyqw";
 const supabaseHypercerts = createClient(SUPABASE_HYPERCERTS_URL, SUPABASE_HYPERCERTS_ANON_KEY);
-/**
- * Fetches order nonce from api
- * @param address Address
- * @param chainId Chain ID
- */
-const fetchOrderNonce = async ({ address, chainId }) => {
-    return fetch(`${HYPERCERTS_MARKETPLACE_API_URL}/marketplace/order-nonce/`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            address,
-            chainId,
-        }),
-    })
-        .then((res) => res.json())
-        .then((res) => res.data);
-};
-/**
- * Registers order in api
- * @param order Order
- * @param signer Signer
- * @param signature Signature
- * @param quoteType Quote type
- * @param chainId Chain ID
- */
-const registerOrder = async ({ order, signer, signature, quoteType, chainId, }) => {
-    const { globalNonce, ...orderWithoutGlobalNonce } = order;
-    return fetch(`${HYPERCERTS_MARKETPLACE_API_URL}/marketplace/order/`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            ...orderWithoutGlobalNonce,
-            globalNonce: globalNonce.toString(10),
-            price: order.price.toString(10),
-            quoteType,
-            signer,
-            signature,
-            chainId,
-        }),
-    }).then((res) => res.json());
-};
-/**
- * Fetches orders from api by hypercert ID
- * @param hypercertId Hypercert ID
- * @param chainId Chain ID
- */
-const fetchOrdersByHypercertId = async ({ hypercertId, chainId }) => {
-    const hypercertsClient = new HypercertClient({
-        chain: { id: chainId },
-    });
-    const fractions = await hypercertsClient.indexer.fractionsByClaim(hypercertId);
-    const tokenIds = fractions.claimTokens.map((fraction) => fraction.tokenID);
-    return supabaseHypercerts.from("marketplace-orders").select("*").containedBy("itemIds", tokenIds).throwOnError();
-};
-/**
- * Fetch existing open orders from the marketplace API
- * @param signer address of the user that created the order
- * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
- * @param chainId chain id for the order
- * @param strategy strategy for the order
- */
-const fetchOrders = async ({ signer, claimTokenIds, chainId, strategy }) => {
-    let baseQuery = supabaseHypercerts.from("marketplace-orders").select("*");
-    if (signer) {
-        baseQuery.eq("signer", signer);
-    }
-    if (claimTokenIds) {
-        baseQuery = baseQuery.overlaps("itemIds", claimTokenIds);
-    }
-    if (chainId) {
-        baseQuery.eq("chainId", chainId);
-    }
-    if (strategy) {
-        baseQuery.eq("strategyId", strategy);
+class ApiClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        /**
+         * Fetches order nonce from api
+         * @param address Address
+         * @param chainId Chain ID
+         */
+        this.fetchOrderNonce = async ({ address, chainId }) => {
+            return fetch(`${this.baseUrl}/marketplace/order-nonce/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    address,
+                    chainId,
+                }),
+            })
+                .then((res) => res.json())
+                .then((res) => res.data);
+        };
+        /**
+         * Registers order in api
+         * @param order Order
+         * @param signer Signer
+         * @param signature Signature
+         * @param quoteType Quote type
+         * @param chainId Chain ID
+         */
+        this.registerOrder = async ({ order, signer, signature, quoteType, chainId, }) => {
+            const { globalNonce, ...orderWithoutGlobalNonce } = order;
+            return fetch(`${this.baseUrl}/marketplace/order/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    ...orderWithoutGlobalNonce,
+                    globalNonce: globalNonce.toString(10),
+                    price: order.price.toString(10),
+                    quoteType,
+                    signer,
+                    signature,
+                    chainId,
+                }),
+            }).then((res) => res.json());
+        };
+        /**
+         * Fetch existing open orders from the marketplace API
+         * @param signer address of the user that created the order
+         * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
+         * @param chainId chain id for the order
+         * @param strategy strategy for the order
+         */
+        this.fetchOrders = async ({ signer, claimTokenIds, chainId, strategy }) => {
+            let baseQuery = supabaseHypercerts.from("marketplace-orders").select("*");
+            if (signer) {
+                baseQuery.eq("signer", signer);
+            }
+            if (claimTokenIds) {
+                baseQuery = baseQuery.overlaps("itemIds", claimTokenIds);
+            }
+            if (chainId) {
+                baseQuery.eq("chainId", chainId);
+            }
+            if (strategy) {
+                baseQuery.eq("strategyId", strategy);
+            }
+            return baseQuery.throwOnError();
+        };
+        /**
+         * Fetches orders from api by hypercert ID
+         * @param hypercertId Hypercert ID
+         * @param chainId Chain ID
+         */
+        this.fetchOrdersByHypercertId = async ({ hypercertId, chainId }) => {
+            const hypercertsClient = new HypercertClient({
+                chain: { id: chainId },
+            });
+            const fractions = await hypercertsClient.indexer.fractionsByClaim(hypercertId);
+            const tokenIds = fractions.claimTokens.map((fraction) => fraction.tokenID);
+            return supabaseHypercerts.from("marketplace-orders").select("*").containedBy("itemIds", tokenIds).throwOnError();
+        };
+        const url = baseUrl || HYPERCERTS_MARKETPLACE_API_URL;
+        if (!url) {
+            throw new Error("No API URL provided");
+        }
+        this._baseUrl = url;
     }
-    return baseQuery.throwOnError();
-};
-
-var api = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  fetchOrderNonce: fetchOrderNonce,
-  fetchOrders: fetchOrders,
-  fetchOrdersByHypercertId: fetchOrdersByHypercertId,
-  registerOrder: registerOrder,
-  supabaseHypercerts: supabaseHypercerts
-});
+}
 
 /**
- * LooksRare
- * This class provides helpers to interact with the LooksRare V2 contracts
+ * HypercertExchange
+ * This class provides helpers to interact with the HypercertExchange V2 contracts
  */
 class HypercertExchangeClient {
     /**
-     * LooksRare protocol main class
+     * HypercertExchange protocol main class
      * @param chainId Current app chain id
      * @param provider Ethers provider
      * @param signer Ethers signer
-     * @param override Overrides contract addresses for hardhat setup
+     * @param overrides Override contract addresses or api endpoint used
      */
-    constructor(chainId, provider, signer, override) {
+    constructor(chainId, provider, signer, overrides) {
         this.chainId = chainId;
-        this.addresses = override ?? addressesByNetwork[this.chainId];
+        this.addresses = overrides?.addresses ?? addressesByNetwork[this.chainId];
         this.signer = signer;
         this.provider = provider;
-        this.api = api;
+        this.api = new ApiClient(overrides?.apiEndpoint);
     }
     /**
      * Return the signer it it's set, throw an exception otherwise
@@ -5207,7 +5208,7 @@ class HypercertExchangeClient {
         return cancelSubsetNonces(signer, this.addresses.EXCHANGE_V2, nonces, overrides);
     }
     /**
-     * Approve all the items of a collection, to eventually be traded on LooksRare
+     * Approve all the items of a collection, to eventually be traded on HypercertExchange
      * The spender is the TransferManager.
      * @param collectionAddress Address of the collection to be approved.
      * @param approved true to approve, false to revoke the approval (default to true)
@@ -5219,8 +5220,8 @@ class HypercertExchangeClient {
         return setApprovalForAll(signer, collectionAddress, spenderAddress, approved, overrides);
     }
     /**
-     * Approve an ERC20 to be used as a currency on LooksRare.
-     * The spender is the LooksRareProtocol contract.
+     * Approve an ERC20 to be used as a currency on HypercertExchange.
+     * The spender is the HypercertExchangeProtocol contract.
      * @param tokenAddress Address of the ERC20 to approve
      * @param amount Amount to be approved (default to MaxUint256)
      * @returns ContractTransaction
@@ -5305,7 +5306,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        const { nonce_counter } = await fetchOrderNonce({
+        const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
             chainId,
         });
@@ -5346,7 +5347,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        const { nonce_counter } = await fetchOrderNonce({
+        const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
             chainId,
         });
@@ -5402,7 +5403,7 @@ class HypercertExchangeClient {
             throw new Error("No signer address could be determined");
         }
         const chainId = this.chainId;
-        return registerOrder({
+        return this.api.registerOrder({
             order,
             signer: address,
             signature,

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { BigNumberish, BytesLike, Overrides, TypedDataField, ContractTransactionResponse } from "ethers";
 import { Eip712MakerMerkleTree } from "./utils/Eip712MakerMerkleTree";
-/** Addresses used to create a LooksRare instance */
+/** Addresses used to create a HypercertExchange instance */
 export interface Addresses {
     EXCHANGE_V2: `0x${string}`;
     TRANSFER_MANAGER_V2: `0x${string}`;
@@ -13,7 +13,7 @@ export declare enum ChainId {
     SEPOLIA = 11155111,
     HARDHAT = 31337
 }
-/** ChainInfo data used to interact with LooksRare ecosystem */
+/** ChainInfo data used to interact with HypercertExchange ecosystem */
 export interface ChainInfo {
     label: string;
     appUrl: string;
@@ -97,7 +97,7 @@ export interface CreateMakerInput {
     collectionType: CollectionType;
     /** Subset nonce used to group an arbitrary number of orders under the same nonce */
     subsetNonce: BigNumberish;
-    /** Order nonce, get it from the LooksRare api */
+    /** Order nonce, get it from the HypercertExchange api */
     orderNonce: BigNumberish;
     /** Timestamp in seconds when the order becomes invalid */
     endTime: BigNumberish;

package/dist/utils/api.d.ts

@@ -74,11 +74,6 @@ export declare const supabaseHypercerts: import("@supabase/supabase-js").Supabas
                 created_at?: string | null | undefined;
                 fractionCounter?: number | null | undefined;
                 hidden?: boolean | undefined;
-                /**
-                 * Fetches orders from api by hypercert ID
-                 * @param hypercertId Hypercert ID
-                 * @param chainId Chain ID
-                 */
                 id?: number | undefined;
             };
             Update: {
@@ -90,7 +85,13 @@ export declare const supabaseHypercerts: import("@supabase/supabase-js").Supabas
                 id?: number | undefined;
             };
             Relationships: [];
-        };
+        }; /**
+         * Fetch existing open orders from the marketplace API
+         * @param signer address of the user that created the order
+         * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
+         * @param chainId chain id for the order
+         * @param strategy strategy for the order
+         */
         "allowlistCache-optimism": {
             Row: {
                 address: string | null;
@@ -105,13 +106,7 @@ export declare const supabaseHypercerts: import("@supabase/supabase-js").Supabas
                 claimId?: string | null | undefined;
                 created_at?: string | null | undefined;
                 fractionCounter?: number | null | undefined;
-                hidden?: boolean | undefined; /**
-                 * Fetch existing open orders from the marketplace API
-                 * @param signer address of the user that created the order
-                 * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
-                 * @param chainId chain id for the order
-                 * @param strategy strategy for the order
-                 */
+                hidden?: boolean | undefined;
                 id?: number | undefined;
             };
             Update: {
@@ -735,97 +730,102 @@ export declare const supabaseHypercerts: import("@supabase/supabase-js").Supabas
     Enums: {};
     CompositeTypes: {};
 }>;
-/**
- * Fetches order nonce from api
- * @param address Address
- * @param chainId Chain ID
- */
-export declare const fetchOrderNonce: ({ address, chainId }: {
-    address: string;
-    chainId: number;
-}) => Promise<{
-    nonce_counter: number;
-    address: string;
-    chain_id: number;
-}>;
-/**
- * Registers order in api
- * @param order Order
- * @param signer Signer
- * @param signature Signature
- * @param quoteType Quote type
- * @param chainId Chain ID
- */
-export declare const registerOrder: ({ order, signer, signature, quoteType, chainId, }: {
-    order: Maker;
-    signer: string;
-    signature: string;
-    quoteType: QuoteType;
-    chainId: number;
-}) => Promise<{
-    success: boolean;
-}>;
-/**
- * Fetches orders from api by hypercert ID
- * @param hypercertId Hypercert ID
- * @param chainId Chain ID
- */
-export declare const fetchOrdersByHypercertId: ({ hypercertId, chainId }: {
-    hypercertId: string;
-    chainId: number;
-}) => Promise<import("@supabase/supabase-js").PostgrestSingleResponse<{
-    additionalParameters: string;
-    amounts: number[];
-    chainId: number;
-    collection: string;
-    collectionType: number;
-    createdAt: string;
-    currency: string;
-    endTime: number;
-    globalNonce: string;
-    id: string;
-    itemIds: string[];
-    orderNonce: string;
-    price: string;
-    quoteType: number;
-    signature: string;
-    signer: string;
-    startTime: number;
-    strategyId: number;
-    subsetNonce: number;
-}[]>>;
+export declare class ApiClient {
+    private readonly baseUrl?;
+    private _baseUrl;
+    constructor(baseUrl?: string | undefined);
+    /**
+     * Fetches order nonce from api
+     * @param address Address
+     * @param chainId Chain ID
+     */
+    fetchOrderNonce: ({ address, chainId }: {
+        address: string;
+        chainId: number;
+    }) => Promise<{
+        nonce_counter: number;
+        address: string;
+        chain_id: number;
+    }>;
+    /**
+     * Registers order in api
+     * @param order Order
+     * @param signer Signer
+     * @param signature Signature
+     * @param quoteType Quote type
+     * @param chainId Chain ID
+     */
+    registerOrder: ({ order, signer, signature, quoteType, chainId, }: {
+        order: Maker;
+        signer: string;
+        signature: string;
+        quoteType: QuoteType;
+        chainId: number;
+    }) => Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Fetch existing open orders from the marketplace API
+     * @param signer address of the user that created the order
+     * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
+     * @param chainId chain id for the order
+     * @param strategy strategy for the order
+     */
+    fetchOrders: ({ signer, claimTokenIds, chainId, strategy }: Partial<FetchOrderArgs>) => Promise<import("@supabase/supabase-js").PostgrestSingleResponse<{
+        additionalParameters: string;
+        amounts: number[];
+        chainId: number;
+        collection: string;
+        collectionType: number;
+        createdAt: string;
+        currency: string;
+        endTime: number;
+        globalNonce: string;
+        id: string;
+        itemIds: string[];
+        orderNonce: string;
+        price: string;
+        quoteType: number;
+        signature: string;
+        signer: string;
+        startTime: number;
+        strategyId: number;
+        subsetNonce: number;
+    }[]>>;
+    /**
+     * Fetches orders from api by hypercert ID
+     * @param hypercertId Hypercert ID
+     * @param chainId Chain ID
+     */
+    fetchOrdersByHypercertId: ({ hypercertId, chainId }: {
+        hypercertId: string;
+        chainId: number;
+    }) => Promise<import("@supabase/supabase-js").PostgrestSingleResponse<{
+        additionalParameters: string;
+        amounts: number[];
+        chainId: number;
+        collection: string;
+        collectionType: number;
+        createdAt: string;
+        currency: string;
+        endTime: number;
+        globalNonce: string;
+        id: string;
+        itemIds: string[];
+        orderNonce: string;
+        price: string;
+        quoteType: number;
+        signature: string;
+        signer: string;
+        startTime: number;
+        strategyId: number;
+        subsetNonce: number;
+    }[]>>;
+}
 interface FetchOrderArgs {
     signer: `0x${string}`;
     claimTokenIds: string[];
     chainId: number;
     strategy: StrategyType;
 }
-/**
- * Fetch existing open orders from the marketplace API
- * @param signer address of the user that created the order
- * @param claimTokenIds a list of claimTokenIds - will return any order that is for one or more of these claimTokenIds
- * @param chainId chain id for the order
- * @param strategy strategy for the order
- */
-export declare const fetchOrders: ({ signer, claimTokenIds, chainId, strategy }: Partial<FetchOrderArgs>) => Promise<import("@supabase/supabase-js").PostgrestSingleResponse<{
-    additionalParameters: string;
-    amounts: number[];
-    chainId: number;
-    collection: string;
-    collectionType: number;
-    createdAt: string;
-    currency: string;
-    endTime: number;
-    globalNonce: string;
-    id: string;
-    itemIds: string[];
-    orderNonce: string;
-    price: string;
-    quoteType: number;
-    signature: string;
-    signer: string;
-    startTime: number;
-    strategyId: number;
-    subsetNonce: number;
-}[]>>;
 export {};

package/dist/utils/calls/exchange.d.ts

@@ -1,9 +1,10 @@
 import { Signer } from "ethers";
 import { Maker, MerkleTree, Taker, ContractMethods } from "../../types";
-export declare const executeTakerBid: (signer: Signer, address: string, taker: Taker, maker: Maker, makerSignature: string, merkleTree: MerkleTree, overrides?: any) => ContractMethods;
-export declare const executeTakerAsk: (signer: Signer, address: string, taker: Taker, maker: Maker, makerSignature: string, merkleTree: MerkleTree, overrides?: any) => ContractMethods;
-export declare const executeMultipleTakerBids: (signer: Signer, address: string, taker: Taker[], maker: Maker[], makerSignature: string[], isAtomic: boolean, merkleTree: MerkleTree[], overrides?: any) => {
-    call: (additionalOverrides?: any) => any;
-    estimateGas: (additionalOverrides?: any) => any;
-    callStatic: (additionalOverrides?: any) => any;
+import { PayableOverrides } from "../../typechain/common";
+export declare const executeTakerBid: (signer: Signer, address: string, taker: Taker, maker: Maker, makerSignature: string, merkleTree: MerkleTree, overrides?: PayableOverrides) => ContractMethods;
+export declare const executeTakerAsk: (signer: Signer, address: string, taker: Taker, maker: Maker, makerSignature: string, merkleTree: MerkleTree, overrides?: PayableOverrides) => ContractMethods;
+export declare const executeMultipleTakerBids: (signer: Signer, address: string, taker: Taker[], maker: Maker[], makerSignature: string[], isAtomic: boolean, merkleTree: MerkleTree[], overrides?: PayableOverrides) => {
+    call: (additionalOverrides?: PayableOverrides) => any;
+    estimateGas: (additionalOverrides?: PayableOverrides) => any;
+    callStatic: (additionalOverrides?: PayableOverrides) => any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypercerts-org/marketplace-sdk",
-  "version": "0.0.24",
+  "version": "0.1.1",
   "license": "MIT",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -13,7 +13,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "keywords": [
-    "looksrare"
+    "hypercertexchange"
   ],
   "homepage": "https://hypercerts.org/",
   "bugs": "https://github.com/hypercerts-org/hypercerts/issues",