@hypercerts-org/marketplace-sdk 0.6.0 → 0.7.0

package/dist/HypercertExchangeClient.d.ts

@@ -1,4 +1,5 @@
 import { BigNumberish, ContractTransactionResponse, Overrides, Provider, Signer, TypedDataDomain } from "ethers";
+import SafeApiKit from "@safe-global/api-kit";
 import { Addresses, ChainId, ContractMethods, CreateDirectFractionsSaleMakerAskInput, CreateFractionalSaleMakerAskInput, CreateMakerAskOutput, CreateMakerBidOutput, CreateMakerInput, Currencies, Maker, MerkleTree, Order, OrderValidatorCode, SignMerkleTreeOrdersOutput, StrategyInfo, StrategyType, Taker } from "./types";
 import { ApiClient } from "./utils/api";
 import { WalletClient } from "viem";
@@ -63,7 +64,9 @@ export declare class HypercertExchangeClient {
      * @param CreateMakerInput
      * @returns the maker object, isTransferManagerApproved, and isTransferManagerApproved
      */
-    createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency, startTime, additionalParameters, }: CreateMakerInput): Promise<CreateMakerAskOutput>;
+    createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency, startTime, additionalParameters, safeAddress, }: CreateMakerInput & {
+        safeAddress?: string;
+    }): Promise<CreateMakerAskOutput>;
     /**
      * Create a maker bid object ready to be signed
      * @param CreateMakerInput
@@ -84,6 +87,14 @@ export declare class HypercertExchangeClient {
      * @returns Signature
      */
     signMakerOrder(maker: Maker): Promise<string>;
+    /**
+     * Create a maker order message and upload it to the Safe Transaction Service to be signed in the Safe app
+     * @param maker Order to be signed by the user
+     * @param safeAddress Address of the Safe to use
+     * @param safeApiKit Optional pre-initialized Safe API Kit instance
+     * @returns Signature
+     */
+    signMakerOrderSafe(maker: Maker, safeAddress: string, safeApiKit?: SafeApiKit): Promise<string>;
     /**
      * Sign multiple maker orders with a single signature
      * /!\ Use this function for UI implementation only
@@ -147,6 +158,14 @@ export declare class HypercertExchangeClient {
      * @returns ContractTransaction
      */
     approveAllCollectionItems(collectionAddress: string, approved?: boolean, overrides?: Overrides): Promise<ContractTransactionResponse>;
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @param collectionAddress Address of the collection to be approved
+     * @param approved true to approve, false to revoke the approval (default to true)
+     * @param safeAddress Address of the Safe to use
+     * @returns Safe transaction hash
+     */
+    approveAllCollectionItemsSafe(safeAddress: string, collectionAddress: string, approved?: boolean): Promise<string>;
     /**
      * Approve an ERC20 to be used as a currency on the Hypercert Exchange.
      * The spender is the HypercertExchangeProtocol contract.
@@ -210,7 +229,7 @@ export declare class HypercertExchangeClient {
      * @param orders List of orders to be checked
      * @param overrides Call overrides (optional)
      */
-    checkOrdersValidity(orders: Order[], overrides?: Overrides): Promise<{
+    checkOrdersValidity(orders: Omit<Order, "createdAt" | "invalidated" | "validator_codes">[], overrides?: Overrides): Promise<{
         id: string;
         valid: boolean;
         validatorCodes: OrderValidatorCode[];
@@ -227,11 +246,31 @@ export declare class HypercertExchangeClient {
      * @param CreateDirectFractionsSaleMakerAskInput
      */
     createDirectFractionsSaleMakerAsk({ itemIds, price, startTime, endTime, currency, additionalParameters, }: CreateDirectFractionsSaleMakerAskInput): Promise<CreateMakerAskOutput>;
+    /**
+     * Create a maker ask for a collection or singular offer of fractions using Safe
+     * @param CreateDirectFractionsSaleMakerAskInput
+     */
+    createDirectFractionsSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, additionalParameters, safeAddress, }: CreateDirectFractionsSaleMakerAskInput & {
+        safeAddress: string;
+    }): Promise<CreateMakerAskOutput>;
     /**
      * Create a maker ask to let the buyer decide how much of a fraction they want to buy
      * @param CreateFractionalSaleMakerInput
      */
     createFractionalSaleMakerAsk({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, }: CreateFractionalSaleMakerAskInput): Promise<CreateMakerAskOutput>;
+    /**
+     * Create a maker ask to let the buyer decide how much of a fraction they want to buy using Safe
+     * @param CreateFractionalSaleMakerInput
+     */
+    createFractionalSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, safeAddress, }: CreateFractionalSaleMakerAskInput & {
+        safeAddress: string;
+    }): Promise<CreateMakerAskOutput>;
+    /**
+     * Prepare a fractional sale maker ask with common logic for both regular and Safe transactions
+     * @param params CreateFractionalSaleMakerInput with optional safeAddress
+     * @private
+     */
+    private prepareFractionalSaleMakerAsk;
     /**
      * Create a taker bid for buying part of a fraction
      * @param maker Maker order
@@ -251,14 +290,26 @@ export declare class HypercertExchangeClient {
     }): Promise<{
         success: boolean;
     }>;
+    /**
+     * Register the order with the hypercerts marketplace API for Safe transactions
+     * @param messageHash The message hash from the Safe transaction
+     */
+    registerOrderSafe({ messageHash }: {
+        messageHash: string;
+    }): Promise<{
+        success: boolean;
+    }>;
     /**
      * Delete the order from the hypercerts marketplace API
      * @param orderId Order ID
      */
     deleteOrder(orderId: string): Promise<boolean>;
     /**
-     * Bundle approval operations into a single Safe transaction
+     * Bundle the following operations into a single Safe transaction:
+     * - grantApprovals on the TransferManager
+     * - setApprovalForAll on the collection
      * @param safeAddress The address of the Safe contract
+     * @param walletClient Connected wallet client
      * @param collectionAddress Address of the collection to approve
      * @returns Transaction hash
      */

package/dist/index.cjs.js

@@ -7640,6 +7640,7 @@ class ApiClient {
                 },
                 body: JSON.stringify({
                     ...orderWithoutGlobalNonce,
+                    type: "eoa",
                     globalNonce: globalNonce.toString(10),
                     price: order.price.toString(10),
                     quoteType,
@@ -7649,6 +7650,24 @@ class ApiClient {
                 }),
             }).then((res) => this.handleResponse(res));
         };
+        /**
+         * Registers order in the marketplace API for Safe transactions
+         * @param messageHash The message hash from the Safe transaction
+         * @param chainId Chain ID
+         */
+        this.registerOrderSafe = async ({ messageHash, chainId, }) => {
+            return fetch(`${this._baseUrl}/marketplace/orders/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    type: "multisig",
+                    messageHash,
+                    chainId,
+                }),
+            }).then((res) => this.handleResponse(res));
+        };
         /**
          * @deprecated use GraphQL API instead
          * Fetch existing open orders from the marketplace API
@@ -7755,6 +7774,7 @@ class SafeTransactionBuilder {
             const nonce = await this.apiKit.getNextNonce(safeAddress);
             const safeTx = await connected.createTransaction({
                 transactions,
+                onlyCalls: true,
                 options: {
                     nonce,
                 },
@@ -7826,8 +7846,108 @@ class SafeTransactionBuilder {
         }));
         return this.performSafeTransactions(safeAddress, transactions);
     }
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @internal
+     */
+    approveAllCollectionItems(safeAddress, collectionAddress, approved = true) {
+        const erc721Contract = new ethers.Contract(collectionAddress, abiIERC721);
+        const transactions = [
+            {
+                to: collectionAddress,
+                data: erc721Contract.interface.encodeFunctionData("setApprovalForAll", [
+                    this.addresses.TRANSFER_MANAGER_V2,
+                    approved,
+                ]),
+                value: "0",
+            },
+        ];
+        return this.performSafeTransactions(safeAddress, transactions);
+    }
 }
 
+class SafeMessages {
+    /**
+     * @param address - The address of the Safe
+     * @param chainId - The chainId where the Safe is deployed
+     * @param provider - An EIP1193 compatible provider
+     * @param safeApiKit - A pre-initialized Safe API Kit e.g. when on a network with a 3rd party transaction service deployment
+     */
+    constructor(address, chainId, provider, safeApiKit) {
+        this.address = address;
+        this.chainId = chainId;
+        this.provider = provider;
+        this.apiKit = safeApiKit || new SafeApiKit({ chainId: BigInt(chainId) });
+    }
+    async signAndSubmit(values, types, primaryType) {
+        try {
+            const { messageHash } = await this.initiateSigning({
+                types: {
+                    ...types,
+                },
+                primaryType,
+                message: values,
+            });
+            return messageHash;
+        }
+        catch (error) {
+            console.error("[signAndSubmit] error", error instanceof Error ? error.message : error);
+            throw error instanceof Error ? error : new Error("Error signing and submitting message");
+        }
+    }
+    async initiateSigning(config) {
+        if (!this.chainId)
+            throw new Error("No chainId found");
+        const safe = await Safe.init({
+            provider: this.provider,
+            safeAddress: this.address,
+        });
+        const domain = {
+            name: DOMAIN_NAME,
+            version: DOMAIN_VERSION.toString(),
+            chainId: parseInt(this.chainId.toString()),
+            verifyingContract: this.address,
+        };
+        const typedData = {
+            domain,
+            types: {
+                ...DOMAIN_TYPE,
+                ...config.types,
+            },
+            primaryType: config.primaryType,
+            message: config.message,
+        };
+        const safeMessage = await safe.createMessage(typedData);
+        const signature = await safe.signTypedData(safeMessage);
+        try {
+            await this.apiKit.addMessage(this.address, {
+                message: typedData,
+                signature: Safe.buildSignatureBytes([signature]),
+            });
+        }
+        catch (error) {
+            console.error("Error adding message to Safe API:", error);
+            throw error;
+        }
+        const rawMessageHash = this.calculateMessageHash(domain, config);
+        const safeHash = await safe.getSafeMessageHash(rawMessageHash);
+        return {
+            messageHash: safeHash,
+        };
+    }
+    calculateMessageHash(domain, config) {
+        return ethers.TypedDataEncoder.hash(domain, config.types, config.message);
+    }
+}
+const DOMAIN_TYPE = {
+    EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        { name: "chainId", type: "uint256" },
+        { name: "verifyingContract", type: "address" },
+    ],
+};
+
 /**
  * HypercertExchange
  * This class provides helpers to interact with the HypercertExchange V2 contracts
@@ -7890,12 +8010,12 @@ class HypercertExchangeClient {
      * @param CreateMakerInput
      * @returns the maker object, isTransferManagerApproved, and isTransferManagerApproved
      */
-    async createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency = ethers.ZeroAddress, startTime = Math.floor(Date.now() / 1000), additionalParameters = [], }) {
-        const signer = this.getSigner();
+    async createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency = ethers.ZeroAddress, startTime = Math.floor(Date.now() / 1000), additionalParameters = [], safeAddress, }) {
         if (!this.isTimestampValid(startTime) || !this.isTimestampValid(endTime)) {
             throw new ErrorTimestamp();
         }
-        const signerAddress = await signer.getAddress();
+        // Use safeAddress if provided, otherwise get from signer
+        const signerAddress = safeAddress || await this.getSigner().getAddress();
         const spenderAddress = this.addresses.TRANSFER_MANAGER_V2;
         // Use this.provider (MulticallProvider) in order to batch the calls
         const [isCollectionApproved, userBidAskNonce, isTransferManagerApproved] = await Promise.all([
@@ -7992,6 +8112,26 @@ class HypercertExchangeClient {
         const signer = this.getSigner();
         return await signMakerOrder(signer, this.getTypedDataDomain(), maker);
     }
+    /**
+     * Create a maker order message and upload it to the Safe Transaction Service to be signed in the Safe app
+     * @param maker Order to be signed by the user
+     * @param safeAddress Address of the Safe to use
+     * @param safeApiKit Optional pre-initialized Safe API Kit instance
+     * @returns Signature
+     */
+    async signMakerOrderSafe(maker, safeAddress, safeApiKit) {
+        if (!this.walletClient) {
+            throw new Error("wallet client is required to sign a maker order using Safe");
+        }
+        const safe = new SafeMessages(safeAddress, this.chainId, 
+        // The underlying provider is an Eip1193Provider, but the type is not exported
+        this.walletClient, safeApiKit);
+        // The assertion to unknown and Record<string, unknown> is necessary because Maker is a closed type while
+        // Record<string, unknown> is not. Thus TypeScript will complain about the types having no overlap. But we know
+        // that Maker is a Record<string, unknown> and sign() is not trying to get keys out of the Record that don't
+        // exist on Maker, so we can safely type assert here.
+        return safe.signAndSubmit(maker, makerTypes, "Maker");
+    }
     /**
      * Sign multiple maker orders with a single signature
      * /!\ Use this function for UI implementation only
@@ -8088,6 +8228,20 @@ class HypercertExchangeClient {
         const spenderAddress = this.addresses.TRANSFER_MANAGER_V2;
         return setApprovalForAll(signer, collectionAddress, spenderAddress, approved, overrides);
     }
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @param collectionAddress Address of the collection to be approved
+     * @param approved true to approve, false to revoke the approval (default to true)
+     * @param safeAddress Address of the Safe to use
+     * @returns Safe transaction hash
+     */
+    approveAllCollectionItemsSafe(safeAddress, collectionAddress, approved = true) {
+        if (!this.walletClient) {
+            throw new Error("No wallet client");
+        }
+        const safeTransactionBuilder = new SafeTransactionBuilder(this.walletClient, this.chainId, this.addresses);
+        return safeTransactionBuilder.approveAllCollectionItems(safeAddress, collectionAddress, approved);
+    }
     /**
      * Approve an ERC20 to be used as a currency on the Hypercert Exchange.
      * The spender is the HypercertExchangeProtocol contract.
@@ -8239,10 +8393,9 @@ class HypercertExchangeClient {
         if (!currency) {
             throw new ErrorCurrency();
         }
-        const chainId = this.chainId;
         const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
-            chainId,
+            chainId: this.chainId,
         });
         return this.createMakerAsk({
             // Defaults
@@ -8260,14 +8413,90 @@ class HypercertExchangeClient {
             additionalParameters,
         });
     }
+    /**
+     * Create a maker ask for a collection or singular offer of fractions using Safe
+     * @param CreateDirectFractionsSaleMakerAskInput
+     */
+    async createDirectFractionsSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, additionalParameters = [], safeAddress, }) {
+        if (!safeAddress) {
+            throw new Error("Safe address is required for Safe transactions");
+        }
+        if (!currency) {
+            throw new ErrorCurrency();
+        }
+        const { nonce_counter } = await this.api.fetchOrderNonce({
+            address: safeAddress,
+            chainId: this.chainId,
+        });
+        return this.createMakerAsk({
+            // Defaults
+            strategyId: exports.StrategyType.standard,
+            collectionType: exports.CollectionType.HYPERCERT,
+            collection: this.addresses.MINTER,
+            subsetNonce: 0,
+            currency,
+            orderNonce: nonce_counter.toString(),
+            // User specified
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            additionalParameters,
+            safeAddress,
+        });
+    }
     /**
      * Create a maker ask to let the buyer decide how much of a fraction they want to buy
      * @param CreateFractionalSaleMakerInput
      */
     async createFractionalSaleMakerAsk({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, }) {
-        const address = await this.signer?.getAddress();
+        return this.prepareFractionalSaleMakerAsk({
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            currency,
+            maxUnitAmount,
+            minUnitAmount,
+            minUnitsToKeep,
+            sellLeftoverFraction,
+            root,
+        });
+    }
+    /**
+     * Create a maker ask to let the buyer decide how much of a fraction they want to buy using Safe
+     * @param CreateFractionalSaleMakerInput
+     */
+    async createFractionalSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, safeAddress, }) {
+        if (!safeAddress) {
+            throw new Error("Safe address is required for Safe transactions");
+        }
+        return this.prepareFractionalSaleMakerAsk({
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            currency,
+            maxUnitAmount,
+            minUnitAmount,
+            minUnitsToKeep,
+            sellLeftoverFraction,
+            root,
+            safeAddress,
+        });
+    }
+    /**
+     * Prepare a fractional sale maker ask with common logic for both regular and Safe transactions
+     * @param params CreateFractionalSaleMakerInput with optional safeAddress
+     * @private
+     */
+    async prepareFractionalSaleMakerAsk({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, safeAddress, }) {
+        let address = safeAddress;
         if (!address) {
-            throw new Error("No signer address could be determined");
+            address = await this.getSigner().getAddress();
+            if (!address) {
+                throw new Error("No signer address could be determined");
+            }
         }
         if (!currency) {
             throw new ErrorCurrency();
@@ -8291,6 +8520,7 @@ class HypercertExchangeClient {
             price,
             startTime,
             endTime,
+            safeAddress,
         };
         if (root) {
             return this.createMakerAsk({
@@ -8337,6 +8567,16 @@ class HypercertExchangeClient {
             chainId,
         });
     }
+    /**
+     * Register the order with the hypercerts marketplace API for Safe transactions
+     * @param messageHash The message hash from the Safe transaction
+     */
+    async registerOrderSafe({ messageHash }) {
+        return this.api.registerOrderSafe({
+            messageHash,
+            chainId: this.chainId,
+        });
+    }
     /**
      * Delete the order from the hypercerts marketplace API
      * @param orderId Order ID
@@ -8350,8 +8590,11 @@ class HypercertExchangeClient {
         return this.api.deleteOrder(orderId, signedMessage);
     }
     /**
-     * Bundle approval operations into a single Safe transaction
+     * Bundle the following operations into a single Safe transaction:
+     * - grantApprovals on the TransferManager
+     * - setApprovalForAll on the collection
      * @param safeAddress The address of the Safe contract
+     * @param walletClient Connected wallet client
      * @param collectionAddress Address of the collection to approve
      * @returns Transaction hash
      */

package/dist/index.esm.js

@@ -2,7 +2,7 @@ import { Contract, ZeroAddress, AbiCoder, TypedDataEncoder, keccak256, solidityP
 import { HypercertExchangeAbi, TransferManagerAbi, OrderValidatorV2AAbi, deployments, asDeployedChain as asDeployedChain$2 } from '@hypercerts-org/contracts';
 import { MerkleTree } from 'merkletreejs';
 import { CONSTANTS } from '@hypercerts-org/sdk';
-import Safe from '@safe-global/protocol-kit';
+import Safe, { buildSignatureBytes } from '@safe-global/protocol-kit';
 import SafeApiKit from '@safe-global/api-kit';
 
 var abiIERC721 = [
@@ -7638,6 +7638,7 @@ class ApiClient {
                 },
                 body: JSON.stringify({
                     ...orderWithoutGlobalNonce,
+                    type: "eoa",
                     globalNonce: globalNonce.toString(10),
                     price: order.price.toString(10),
                     quoteType,
@@ -7647,6 +7648,24 @@ class ApiClient {
                 }),
             }).then((res) => this.handleResponse(res));
         };
+        /**
+         * Registers order in the marketplace API for Safe transactions
+         * @param messageHash The message hash from the Safe transaction
+         * @param chainId Chain ID
+         */
+        this.registerOrderSafe = async ({ messageHash, chainId, }) => {
+            return fetch(`${this._baseUrl}/marketplace/orders/`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    type: "multisig",
+                    messageHash,
+                    chainId,
+                }),
+            }).then((res) => this.handleResponse(res));
+        };
         /**
          * @deprecated use GraphQL API instead
          * Fetch existing open orders from the marketplace API
@@ -7753,6 +7772,7 @@ class SafeTransactionBuilder {
             const nonce = await this.apiKit.getNextNonce(safeAddress);
             const safeTx = await connected.createTransaction({
                 transactions,
+                onlyCalls: true,
                 options: {
                     nonce,
                 },
@@ -7824,8 +7844,108 @@ class SafeTransactionBuilder {
         }));
         return this.performSafeTransactions(safeAddress, transactions);
     }
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @internal
+     */
+    approveAllCollectionItems(safeAddress, collectionAddress, approved = true) {
+        const erc721Contract = new Contract(collectionAddress, abiIERC721);
+        const transactions = [
+            {
+                to: collectionAddress,
+                data: erc721Contract.interface.encodeFunctionData("setApprovalForAll", [
+                    this.addresses.TRANSFER_MANAGER_V2,
+                    approved,
+                ]),
+                value: "0",
+            },
+        ];
+        return this.performSafeTransactions(safeAddress, transactions);
+    }
 }
 
+class SafeMessages {
+    /**
+     * @param address - The address of the Safe
+     * @param chainId - The chainId where the Safe is deployed
+     * @param provider - An EIP1193 compatible provider
+     * @param safeApiKit - A pre-initialized Safe API Kit e.g. when on a network with a 3rd party transaction service deployment
+     */
+    constructor(address, chainId, provider, safeApiKit) {
+        this.address = address;
+        this.chainId = chainId;
+        this.provider = provider;
+        this.apiKit = safeApiKit || new SafeApiKit({ chainId: BigInt(chainId) });
+    }
+    async signAndSubmit(values, types, primaryType) {
+        try {
+            const { messageHash } = await this.initiateSigning({
+                types: {
+                    ...types,
+                },
+                primaryType,
+                message: values,
+            });
+            return messageHash;
+        }
+        catch (error) {
+            console.error("[signAndSubmit] error", error instanceof Error ? error.message : error);
+            throw error instanceof Error ? error : new Error("Error signing and submitting message");
+        }
+    }
+    async initiateSigning(config) {
+        if (!this.chainId)
+            throw new Error("No chainId found");
+        const safe = await Safe.init({
+            provider: this.provider,
+            safeAddress: this.address,
+        });
+        const domain = {
+            name: DOMAIN_NAME,
+            version: DOMAIN_VERSION.toString(),
+            chainId: parseInt(this.chainId.toString()),
+            verifyingContract: this.address,
+        };
+        const typedData = {
+            domain,
+            types: {
+                ...DOMAIN_TYPE,
+                ...config.types,
+            },
+            primaryType: config.primaryType,
+            message: config.message,
+        };
+        const safeMessage = await safe.createMessage(typedData);
+        const signature = await safe.signTypedData(safeMessage);
+        try {
+            await this.apiKit.addMessage(this.address, {
+                message: typedData,
+                signature: buildSignatureBytes([signature]),
+            });
+        }
+        catch (error) {
+            console.error("Error adding message to Safe API:", error);
+            throw error;
+        }
+        const rawMessageHash = this.calculateMessageHash(domain, config);
+        const safeHash = await safe.getSafeMessageHash(rawMessageHash);
+        return {
+            messageHash: safeHash,
+        };
+    }
+    calculateMessageHash(domain, config) {
+        return TypedDataEncoder.hash(domain, config.types, config.message);
+    }
+}
+const DOMAIN_TYPE = {
+    EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        { name: "chainId", type: "uint256" },
+        { name: "verifyingContract", type: "address" },
+    ],
+};
+
 /**
  * HypercertExchange
  * This class provides helpers to interact with the HypercertExchange V2 contracts
@@ -7888,12 +8008,12 @@ class HypercertExchangeClient {
      * @param CreateMakerInput
      * @returns the maker object, isTransferManagerApproved, and isTransferManagerApproved
      */
-    async createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency = ZeroAddress, startTime = Math.floor(Date.now() / 1000), additionalParameters = [], }) {
-        const signer = this.getSigner();
+    async createMakerAsk({ collection, strategyId, collectionType, subsetNonce, orderNonce, endTime, price, itemIds, currency = ZeroAddress, startTime = Math.floor(Date.now() / 1000), additionalParameters = [], safeAddress, }) {
         if (!this.isTimestampValid(startTime) || !this.isTimestampValid(endTime)) {
             throw new ErrorTimestamp();
         }
-        const signerAddress = await signer.getAddress();
+        // Use safeAddress if provided, otherwise get from signer
+        const signerAddress = safeAddress || await this.getSigner().getAddress();
         const spenderAddress = this.addresses.TRANSFER_MANAGER_V2;
         // Use this.provider (MulticallProvider) in order to batch the calls
         const [isCollectionApproved, userBidAskNonce, isTransferManagerApproved] = await Promise.all([
@@ -7990,6 +8110,26 @@ class HypercertExchangeClient {
         const signer = this.getSigner();
         return await signMakerOrder(signer, this.getTypedDataDomain(), maker);
     }
+    /**
+     * Create a maker order message and upload it to the Safe Transaction Service to be signed in the Safe app
+     * @param maker Order to be signed by the user
+     * @param safeAddress Address of the Safe to use
+     * @param safeApiKit Optional pre-initialized Safe API Kit instance
+     * @returns Signature
+     */
+    async signMakerOrderSafe(maker, safeAddress, safeApiKit) {
+        if (!this.walletClient) {
+            throw new Error("wallet client is required to sign a maker order using Safe");
+        }
+        const safe = new SafeMessages(safeAddress, this.chainId, 
+        // The underlying provider is an Eip1193Provider, but the type is not exported
+        this.walletClient, safeApiKit);
+        // The assertion to unknown and Record<string, unknown> is necessary because Maker is a closed type while
+        // Record<string, unknown> is not. Thus TypeScript will complain about the types having no overlap. But we know
+        // that Maker is a Record<string, unknown> and sign() is not trying to get keys out of the Record that don't
+        // exist on Maker, so we can safely type assert here.
+        return safe.signAndSubmit(maker, makerTypes, "Maker");
+    }
     /**
      * Sign multiple maker orders with a single signature
      * /!\ Use this function for UI implementation only
@@ -8086,6 +8226,20 @@ class HypercertExchangeClient {
         const spenderAddress = this.addresses.TRANSFER_MANAGER_V2;
         return setApprovalForAll(signer, collectionAddress, spenderAddress, approved, overrides);
     }
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @param collectionAddress Address of the collection to be approved
+     * @param approved true to approve, false to revoke the approval (default to true)
+     * @param safeAddress Address of the Safe to use
+     * @returns Safe transaction hash
+     */
+    approveAllCollectionItemsSafe(safeAddress, collectionAddress, approved = true) {
+        if (!this.walletClient) {
+            throw new Error("No wallet client");
+        }
+        const safeTransactionBuilder = new SafeTransactionBuilder(this.walletClient, this.chainId, this.addresses);
+        return safeTransactionBuilder.approveAllCollectionItems(safeAddress, collectionAddress, approved);
+    }
     /**
      * Approve an ERC20 to be used as a currency on the Hypercert Exchange.
      * The spender is the HypercertExchangeProtocol contract.
@@ -8237,10 +8391,9 @@ class HypercertExchangeClient {
         if (!currency) {
             throw new ErrorCurrency();
         }
-        const chainId = this.chainId;
         const { nonce_counter } = await this.api.fetchOrderNonce({
             address,
-            chainId,
+            chainId: this.chainId,
         });
         return this.createMakerAsk({
             // Defaults
@@ -8258,14 +8411,90 @@ class HypercertExchangeClient {
             additionalParameters,
         });
     }
+    /**
+     * Create a maker ask for a collection or singular offer of fractions using Safe
+     * @param CreateDirectFractionsSaleMakerAskInput
+     */
+    async createDirectFractionsSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, additionalParameters = [], safeAddress, }) {
+        if (!safeAddress) {
+            throw new Error("Safe address is required for Safe transactions");
+        }
+        if (!currency) {
+            throw new ErrorCurrency();
+        }
+        const { nonce_counter } = await this.api.fetchOrderNonce({
+            address: safeAddress,
+            chainId: this.chainId,
+        });
+        return this.createMakerAsk({
+            // Defaults
+            strategyId: StrategyType.standard,
+            collectionType: CollectionType.HYPERCERT,
+            collection: this.addresses.MINTER,
+            subsetNonce: 0,
+            currency,
+            orderNonce: nonce_counter.toString(),
+            // User specified
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            additionalParameters,
+            safeAddress,
+        });
+    }
     /**
      * Create a maker ask to let the buyer decide how much of a fraction they want to buy
      * @param CreateFractionalSaleMakerInput
      */
     async createFractionalSaleMakerAsk({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, }) {
-        const address = await this.signer?.getAddress();
+        return this.prepareFractionalSaleMakerAsk({
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            currency,
+            maxUnitAmount,
+            minUnitAmount,
+            minUnitsToKeep,
+            sellLeftoverFraction,
+            root,
+        });
+    }
+    /**
+     * Create a maker ask to let the buyer decide how much of a fraction they want to buy using Safe
+     * @param CreateFractionalSaleMakerInput
+     */
+    async createFractionalSaleMakerAskSafe({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, safeAddress, }) {
+        if (!safeAddress) {
+            throw new Error("Safe address is required for Safe transactions");
+        }
+        return this.prepareFractionalSaleMakerAsk({
+            itemIds,
+            price,
+            startTime,
+            endTime,
+            currency,
+            maxUnitAmount,
+            minUnitAmount,
+            minUnitsToKeep,
+            sellLeftoverFraction,
+            root,
+            safeAddress,
+        });
+    }
+    /**
+     * Prepare a fractional sale maker ask with common logic for both regular and Safe transactions
+     * @param params CreateFractionalSaleMakerInput with optional safeAddress
+     * @private
+     */
+    async prepareFractionalSaleMakerAsk({ itemIds, price, startTime, endTime, currency, maxUnitAmount, minUnitAmount, minUnitsToKeep, sellLeftoverFraction, root, safeAddress, }) {
+        let address = safeAddress;
         if (!address) {
-            throw new Error("No signer address could be determined");
+            address = await this.getSigner().getAddress();
+            if (!address) {
+                throw new Error("No signer address could be determined");
+            }
         }
         if (!currency) {
             throw new ErrorCurrency();
@@ -8289,6 +8518,7 @@ class HypercertExchangeClient {
             price,
             startTime,
             endTime,
+            safeAddress,
         };
         if (root) {
             return this.createMakerAsk({
@@ -8335,6 +8565,16 @@ class HypercertExchangeClient {
             chainId,
         });
     }
+    /**
+     * Register the order with the hypercerts marketplace API for Safe transactions
+     * @param messageHash The message hash from the Safe transaction
+     */
+    async registerOrderSafe({ messageHash }) {
+        return this.api.registerOrderSafe({
+            messageHash,
+            chainId: this.chainId,
+        });
+    }
     /**
      * Delete the order from the hypercerts marketplace API
      * @param orderId Order ID
@@ -8348,8 +8588,11 @@ class HypercertExchangeClient {
         return this.api.deleteOrder(orderId, signedMessage);
     }
     /**
-     * Bundle approval operations into a single Safe transaction
+     * Bundle the following operations into a single Safe transaction:
+     * - grantApprovals on the TransferManager
+     * - setApprovalForAll on the collection
      * @param safeAddress The address of the Safe contract
+     * @param walletClient Connected wallet client
      * @param collectionAddress Address of the collection to approve
      * @returns Transaction hash
      */

package/dist/safe/SafeMessages.d.ts

@@ -0,0 +1,22 @@
+import { Eip1193Provider } from "@safe-global/protocol-kit";
+import SafeApiKit from "@safe-global/api-kit";
+import { ChainId } from "../types";
+export declare class SafeMessages {
+    private address;
+    private chainId;
+    private provider;
+    private apiKit;
+    /**
+     * @param address - The address of the Safe
+     * @param chainId - The chainId where the Safe is deployed
+     * @param provider - An EIP1193 compatible provider
+     * @param safeApiKit - A pre-initialized Safe API Kit e.g. when on a network with a 3rd party transaction service deployment
+     */
+    constructor(address: `0x${string}`, chainId: ChainId, provider: Eip1193Provider, safeApiKit?: SafeApiKit);
+    signAndSubmit(values: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, primaryType: string): Promise<string>;
+    private initiateSigning;
+    private calculateMessageHash;
+}

package/dist/safe/SafeTransactionBuilder.d.ts

@@ -27,6 +27,11 @@ export declare class SafeTransactionBuilder {
      * @internal
      */
     grantTransferManagerApproval(safeAddress: string, operators: string[]): Promise<string>;
+    /**
+     * Approve all items in a collection for trading on the Hypercert Exchange using Safe
+     * @internal
+     */
+    approveAllCollectionItems(safeAddress: string, collectionAddress: string, approved?: boolean): Promise<string>;
     /**
      * Perform a series of Safe transactions in a single transaction
      * @internal

package/dist/utils/api.d.ts

@@ -34,6 +34,17 @@ export declare class ApiClient {
     }) => Promise<{
         success: boolean;
     }>;
+    /**
+     * Registers order in the marketplace API for Safe transactions
+     * @param messageHash The message hash from the Safe transaction
+     * @param chainId Chain ID
+     */
+    registerOrderSafe: ({ messageHash, chainId, }: {
+        messageHash: string;
+        chainId: number;
+    }) => Promise<{
+        success: boolean;
+    }>;
     /**
      * @deprecated use GraphQL API instead
      * Fetch existing open orders from the marketplace API

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypercerts-org/marketplace-sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "MIT",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -43,6 +43,7 @@
   "peerDependencies": {
     "@safe-global/api-kit": "^2.5.7",
     "@safe-global/protocol-kit": "^5.2.0",
+    "@safe-global/types-kit": "^1.0.4",
     "ethers": "^6.6.2"
   },
   "devDependencies": {