@hypercerts-org/marketplace-sdk 0.0.1

package/LICENSE

@@ -0,0 +1,4 @@
+This project is dual licensed under MIT and Apache-2.0.
+
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0

package/LICENSE-APACHE

@@ -0,0 +1,10 @@
+Copyright 2023 Hypercerts Foundation
+
+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.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hypercerts Foundation
+
+Copyright (c) 2022 LooksRare for portions of marketplace: https://github.com/LooksRare/contracts-exchange-v2 commit:
+7fca565
+
+Copyright (c) 2022 Paul Razvan Berg for inital template: https://github.com/paulrberg/foundry-template
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# @looksrare/sdk-v2
+
+![GitHub package.json version](https://img.shields.io/github/package-json/v/LooksRare/sdk-v2) ![GitHub](https://img.shields.io/github/license/LooksRare/sdk-v2) ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/LooksRare/sdk-v2/build.yml) ![npm](https://img.shields.io/npm/dt/@looksrare/sdk-v2)
+
+A collection of typescript tools to interact with LooksRare protocol V2 smart contracts 👀💎
+
+## Install
+
+This package has a peer dependency on [etherjs V5](https://docs.ethers.io/v5/).
+
+```bash
+yarn add @looksrare/sdk-v2 ethers
+```
+
+```bash
+npm install @looksrare/sdk-v2 ethers --save
+```
+
+## Getting Started
+
+The SDK expose a main class used to perform all the onchain operations:
+
+```ts
+import { ChainId } from "@looksrare/sdk-v2";
+const looksrare = new LooksRare(ChainId.MAINNET, provider, signer);
+```
+
+The signer is optional if you need access to read only data (:warning: Calls to function that need a signer will throw a `Signer is undefined` exception):
+
+```ts
+import { ChainId } from "@looksrare/sdk-v2";
+const looksrare = new LooksRare(ChainId.MAINNET, provider);
+```
+
+If you work on a hardhat setup, you can override the addresses as follow:
+
+```ts
+import { Addresses } from "@looksrare/sdk-v2";
+const addresses: Addresses = {...};
+const looksrare = new LooksRare(ChainId.HARDHAT, provider, signer, addresses);
+```
+
+:information_source: Use [`JsonRpcProvider`](https://docs.ethers.org/v6/api/providers/jsonrpc/#JsonRpcApiProviderOptions) from `ethers v6` if you want to make batched RPC calls.
+
+```ts
+import { JsonRpcProvider, Network } from "ethers";
+
+// Create a HTTP/HTTPS batch call provider
+const provider = new JsonRpcProvider(RPC_URL, CHAIN_ID, { staticNetwork: Network.from(CHAIN_ID) });
+
+// Create LooksRare instance using this provider
+const looksrare = new LooksRare(ChainId.HARDHAT, provider, signer, addresses);
+```
+
+Prior to [`@looksrare/sdk-v2@0.9.2`](https://www.npmjs.com/package/@looksrare/sdk-v2/v/0.9.2?activeTab=readme), LooksRareSDK was making batched calls using `0xsequence/multicall`. But this is not natively supported since `@looksrare/sdk-v2@1.0.0`.
+
+## Documentation
+
+Read the [guides](./guides) if you need help with the implementation.
+
+You can also read the detailed [api documentation](./doc).
+
+## FAQ
+
+### ❓ How to use ABIs
+
+The SDK exposes most of the LooksRare contract [ABIs](https://github.com/LooksRare/sdk-v2/tree/master/src/abis). For convenience, some commonly used ABIs are also exported.
+
+```js
+import LooksRareProtocolABI from "@looksrare/sdk-v2/dist/abis/LooksRareProtocol.json";
+```
+
+### ❓ How to retrieve order nonce ?
+
+Call the public api endpoint [/orders/nonce](https://looksrare.dev/reference/getordernonce), and use this nonce directly.
+
+### ❓ What to do when the order is created and signed ?
+
+Use the public api endpoint [/orders](https://looksrare.dev/reference/createorder) to push the order to the database. After that, the order will be visible by everyone using the API (looksrare.org, aggregators, etc..).
+
+### ❓ When should I use merkle tree orders ?
+
+Merkle tree orders are used to create several orders with a single signature. You shouldn't use them when using a bot. Their main purpose is to facilitate orders creation using a user interface.
+
+### ❓ Why do I need to call grantTransferManagerApproval ?
+
+When you approve a collection to be traded on LooksRare, you approve the TransferManager instead of the exchange. Calling `grantTransferManagerApproval` gives the exchange contract the right to call the transfer function on the TransferManager. You need to call this function only once, the first time you use the V2.
+
+### ❓ What are subset nonces and how to use them ?
+
+tl;dr subset nonces allow you to cancel all the orders sharing the same subset nonce.
+Subset nonces allow you to group some orders together according to arbitrary rules (for example all your orders for a specific collection, all your orders above a certain threshold, etc). You can then cancel them all with a single call to `cancelSubsetOrders`.
+:information_source: Unlike order nonces, executing an order with a specific subset nonce doesn't invalidate other orders sharing the same subset nonce.
+
+## Resources
+
+🔗 [Developer documentation](https://docs.looksrare.org/developers/welcome)
+
+🔗 [Public API documentation](https://looksrare.dev/reference/important-information)
+
+🔗 [Developer discord](https://discord.gg/jJA4qM5dXz)

package/dist/LooksRare.d.ts

@@ -0,0 +1,223 @@
+import { BigNumberish, ContractTransactionResponse, Overrides, TypedDataDomain, Provider, Signer } from "ethers";
+import { Addresses, Maker, Taker, ChainId, CreateMakerInput, CreateMakerAskOutput, CreateMakerBidOutput, CreateMakerCollectionOfferInput, CreateMakerCollectionOfferWithProofInput, MerkleTree, ContractMethods, OrderValidatorCode, BatchTransferItem, SignMerkleTreeOrdersOutput, StrategyType, StrategyInfo } from "./types";
+/**
+ * LooksRare
+ * This class provides helpers to interact with the LooksRare V2 contracts
+ */
+export declare class LooksRare {
+    /** Current app chain ID */
+    readonly chainId: ChainId;
+    /** Mapping of LooksRare protocol addresses for the current chain */
+    readonly addresses: Addresses;
+    /**
+     * Ethers signer
+     * @see {@link https://docs.ethers.org/v6/api/providers/#Signer Ethers signer doc}
+     */
+    readonly signer?: Signer;
+    /**
+     * Ethers provider. If you want a batch functionality, use JsonRpcProvider.
+     * @see {@link https://docs.ethers.org/v6/api/providers/#Provider Ethers provider doc}
+     */
+    readonly provider: Provider;
+    /**
+     * LooksRare 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
+     */
+    constructor(chainId: ChainId, provider: Provider, signer?: Signer, override?: Addresses);
+    /**
+     * Return the signer it it's set, throw an exception otherwise
+     * @returns Signer
+     */
+    private getSigner;
+    /**
+     * Validate a timestamp format (seconds)
+     * @param timestamp
+     * @returns boolean
+     */
+    private isTimestampValid;
+    /**
+     * Retrieve EIP-712 domain
+     * @returns TypedDataDomain
+     */
+    getTypedDataDomain(): TypedDataDomain;
+    /**
+     * Create a maker ask object ready to be signed
+     * @param CreateMakerInput
+     * @returns the maker object, isTransferManagerApproved, and isTransferManagerApproved
+     */
+    createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, amounts, currency, startTime, additionalParameters, }: CreateMakerInput): Promise<CreateMakerAskOutput>;
+    /**
+     * Create a maker bid object ready to be signed
+     * @param CreateMakerInput
+     * @returns the maker object, isCurrencyApproved, and isBalanceSufficient
+     */
+    createMakerBid({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, amounts, currency, startTime, additionalParameters, }: CreateMakerInput): Promise<CreateMakerBidOutput>;
+    /**
+     * Create a maker bid for collection offer.
+     * @see this.createMakerBid
+     * @param orderInputs Order data
+     * @returns CreateMakerBidOutput
+     */
+    createMakerCollectionOffer(orderInputs: CreateMakerCollectionOfferInput): Promise<CreateMakerBidOutput>;
+    /**
+     * Create a maker bid for collection, with a list of item id that can be used for the taker order
+     * @see this.createMakerBid
+     * @param orderInputs Order data
+     * @returns CreateMakerBidOutput
+     */
+    createMakerCollectionOfferWithProof(orderInputs: CreateMakerCollectionOfferWithProofInput): Promise<CreateMakerBidOutput>;
+    /**
+     * Create a taker ask ready to be executed against a maker bid
+     * @param maker Maker order that will be used as counterparty for the taker
+     * @param recipient Recipient address of the taker (if none, it will use the sender)
+     * @param additionalParameters Additional parameters used to support complex orders
+     * @returns Taker object
+     */
+    createTaker(maker: Maker, recipient?: string, additionalParameters?: any[]): Taker;
+    /**
+     * Create a taker ask order for collection order.
+     * @see this.createTaker
+     * @see this.createMakerCollectionOffer
+     * @param makerBid Maker bid that will be used as counterparty for the taker
+     * @param itemId Token id to use as a counterparty for the collection order
+     * @param recipient Recipient address of the taker (if none, it will use the sender)
+     * @returns Taker object
+     */
+    createTakerCollectionOffer(maker: Maker, itemId: BigNumberish, recipient?: string): Taker;
+    /**
+     * Create a taker ask to fulfill a collection order (maker bid) created with a whitelist of item ids
+     * @see this.createTaker
+     * @see this.createMakerCollectionOfferWithMerkleTree
+     * @param makerBid Maker bid that will be used as counterparty for the taker
+     * @param itemId Token id to use as a counterparty for the collection order
+     * @param itemIds List of token ids used during the maker creation
+     * @param recipient Recipient address of the taker (if none, it will use the sender)
+     * @returns Taker object
+     */
+    createTakerCollectionOfferWithProof(maker: Maker, itemId: BigNumberish, itemIds: BigNumberish[], recipient?: string): Taker;
+    /**
+     * Sign a maker order using the signer provided in the constructor
+     * @param maker Order to be signed by the user
+     * @returns Signature
+     */
+    signMakerOrder(maker: Maker): Promise<string>;
+    /**
+     * Sign multiple maker orders with a single signature
+     * /!\ Use this function for UI implementation only
+     * @param makerOrders Array of maker orders
+     * @returns Signature, proofs, and Merkletree object
+     */
+    signMultipleMakerOrders(makerOrders: Maker[]): Promise<SignMerkleTreeOrdersOutput>;
+    /**
+     * Execute a trade
+     * @param makerBid Maker order
+     * @param taker Taker order
+     * @param signature Signature of the maker order
+     * @param merkleTree If the maker has been signed with a merkle tree
+     * @param affiliate Affiliate address if applicable
+     * @returns ContractMethods
+     */
+    executeOrder(maker: Maker, taker: Taker, signature: string, merkleTree?: MerkleTree, affiliate?: string, overrides?: Overrides): ContractMethods;
+    /**
+     * Execute several orders
+     * @param orders List of orders data
+     * @param isAtomic Should the transaction revert or not if a trade fails
+     * @param affiliate Affiliate address
+     * @param overrides Call overrides
+     * @returns ContractMethods
+     */
+    executeMultipleOrders(orders: {
+        maker: Maker;
+        taker: Taker;
+        signature: string;
+        merkleTree?: MerkleTree;
+    }[], isAtomic: boolean, affiliate?: string, overrides?: Overrides): {
+        /**
+         * Validate a timestamp format (seconds)
+         * @param timestamp
+         * @returns boolean
+         */
+        call: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => Promise<ContractTransactionResponse>;
+        estimateGas: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => Promise<bigint>;
+        callStatic: (additionalOverrides?: import("./typechain/common").PayableOverrides | undefined) => Promise<void>;
+    };
+    /**
+     * Cancell all maker bid and/or ask orders for the current user
+     * @param bid Cancel all bids
+     * @param ask Cancel all asks
+     * @returns ContractMethods
+     */
+    cancelAllOrders(bid: boolean, ask: boolean, overrides?: Overrides): ContractMethods;
+    /**
+     * Cancel a list of specific orders
+     * @param nonces List of nonces to be cancelled
+     * @returns ContractMethods
+     */
+    cancelOrders(nonces: BigNumberish[], overrides?: Overrides): ContractMethods;
+    /**
+     * Cancel a list of specific subset orders
+     * @param nonces List of nonces to be cancelled
+     * @returns ContractMethods
+     */
+    cancelSubsetOrders(nonces: BigNumberish[], overrides?: Overrides): ContractMethods;
+    /**
+     * Approve all the items of a collection, to eventually be traded on LooksRare
+     * 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)
+     * @returns ContractTransaction
+     */
+    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.
+     * @param tokenAddress Address of the ERC20 to approve
+     * @param amount Amount to be approved (default to MaxUint256)
+     * @returns ContractTransaction
+     */
+    approveErc20(tokenAddress: string, amount?: bigint, overrides?: Overrides): Promise<ContractTransactionResponse>;
+    /**
+     * Check whether or not an operator has been approved by the user
+     * @param operator Operator address (default to the exchange address)
+     * @returns true if the operator is approved, false otherwise
+     */
+    isTransferManagerApproved(operator?: string, overrides?: Overrides): Promise<boolean>;
+    /**
+     * Grant a list of operators the rights to transfer user's assets using the transfer manager
+     * @param operators List of operators (default to the exchange address)
+     * @defaultValue Exchange address
+     * @returns ContractMethods
+     */
+    grantTransferManagerApproval(operators?: string[], overrides?: Overrides): ContractMethods;
+    /**
+     * Revoke a list of operators the rights to transfer user's assets using the transfer manager
+     * @param operators List of operators
+     * @defaultValue Exchange address
+     * @returns ContractMethods
+     */
+    revokeTransferManagerApproval(operators?: string[], overrides?: Overrides): ContractMethods;
+    /**
+     * Transfer a list of items across different collections
+     * @param to Recipient address
+     * @param collectionItems Each object in the array represent a list of items for a specific collection
+     * @returns ContractMethods
+     */
+    transferItemsAcrossCollection(to: string, collectionItems: BatchTransferItem[], overrides?: Overrides): Promise<ContractMethods>;
+    /**
+     * Verify if a set of orders can be executed (i.e are valid)
+     * @param makerOrders List of maker orders
+     * @param signatures List of signatures
+     * @param merkleTrees List of merkle trees (optional)
+     * @returns A list of OrderValidatorCode for each order (code 0 being valid)
+     */
+    verifyMakerOrders(makerOrders: Maker[], signatures: string[], merkleTrees?: MerkleTree[], overrides?: Overrides): Promise<OrderValidatorCode[][]>;
+    /**
+     * Retrieve strategy info
+     * @param strategyId use the enum StrategyType
+     * @returns StrategyInfo
+     */
+    strategyInfo(strategyId: StrategyType, overrides?: Overrides): Promise<StrategyInfo>;
+}

package/dist/abis/IERC1155.json

@@ -0,0 +1,276 @@
+[
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "operator",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "bool",
+        "name": "approved",
+        "type": "bool"
+      }
+    ],
+    "name": "ApprovalForAll",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "operator",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256[]",
+        "name": "ids",
+        "type": "uint256[]"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256[]",
+        "name": "values",
+        "type": "uint256[]"
+      }
+    ],
+    "name": "TransferBatch",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "operator",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "id",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "TransferSingle",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "string",
+        "name": "value",
+        "type": "string"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "id",
+        "type": "uint256"
+      }
+    ],
+    "name": "URI",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "id",
+        "type": "uint256"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address[]",
+        "name": "accounts",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "ids",
+        "type": "uint256[]"
+      }
+    ],
+    "name": "balanceOfBatch",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "operator",
+        "type": "address"
+      }
+    ],
+    "name": "isApprovedForAll",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "ids",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
+      }
+    ],
+    "name": "safeBatchTransferFrom",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "id",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
+      }
+    ],
+    "name": "safeTransferFrom",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "operator",
+        "type": "address"
+      },
+      {
+        "internalType": "bool",
+        "name": "approved",
+        "type": "bool"
+      }
+    ],
+    "name": "setApprovalForAll",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]