@bosonprotocol/core-sdk 1.25.0-alpha.2 → 1.25.0-alpha.21

package/src/voucher/handler.ts

@@ -5,12 +5,20 @@ import {
   decodeGetAvailablePreMints,
   decodeGetRangeByOfferId,
   decodeIsApprovedForAll,
+  decodeIsTrustedForwarder,
+  decodeOwner,
   encodeBurnPremintedVouchers,
+  encodeCallExternalContract,
   encodeGetAvailablePreMints,
   encodeGetRangeByOfferId,
   encodeIsApprovedForAll,
+  encodeIsTrustedForwarder,
+  encodeOwner,
   encodePreMint,
-  encodeTransferFrom
+  encodeSetApprovalForAllToContract,
+  encodeSetContractURI,
+  encodeTransferFrom,
+  encodeWithdrawToProtocol
 } from "./interface";
 
 export async function burnPremintedVouchers(args: {
@@ -24,6 +32,29 @@ export async function burnPremintedVouchers(args: {
   });
 }
 
+export async function owner(args: {
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: encodeOwner()
+  });
+  return decodeOwner(result);
+}
+
+export async function isTrustedForwarder(args: {
+  forwarder: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<boolean> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: encodeIsTrustedForwarder(args.forwarder)
+  });
+  return decodeIsTrustedForwarder(result);
+}
+
 export async function getAvailablePreMints(args: {
   offerId: BigNumberish;
   contractAddress: string;
@@ -93,3 +124,49 @@ export async function isApprovedForAll(args: {
   const [isApproved] = decodeIsApprovedForAll(result);
   return isApproved;
 }
+
+export async function setContractURI(args: {
+  contractURI: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return await args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeSetContractURI(args.contractURI)
+  });
+}
+
+export async function callExternalContract(args: {
+  to: string;
+  data: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCallExternalContract(args.to, args.data)
+  });
+}
+
+export async function setApprovalForAllToContract(args: {
+  operator: string;
+  approved: boolean;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeSetApprovalForAllToContract(args.operator, args.approved)
+  });
+}
+
+export async function withdrawToProtocol(args: {
+  tokenList: string[];
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeWithdrawToProtocol(args.tokenList)
+  });
+}

package/src/voucher/interface.ts

@@ -61,3 +61,91 @@ export function encodeTransferFrom(
     tokenId
   ]);
 }
+
+export function encodeCallExternalContract(to: string, data: string) {
+  return bosonVoucherIface.encodeFunctionData("callExternalContract", [
+    to,
+    data
+  ]);
+}
+
+export function encodeSetApprovalForAllToContract(
+  operator: string,
+  approved: boolean
+) {
+  return bosonVoucherIface.encodeFunctionData("setApprovalForAllToContract", [
+    operator,
+    approved
+  ]);
+}
+
+export function encodeWithdrawToProtocol(tokenList: string[]) {
+  return bosonVoucherIface.encodeFunctionData("withdrawToProtocol", [
+    tokenList
+  ]);
+}
+
+export function encodeSetContractURI(contractURI: string) {
+  return bosonVoucherIface.encodeFunctionData("setContractURI", [contractURI]);
+}
+
+const ownableIface = new Interface([
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+]);
+
+export function encodeOwner() {
+  return ownableIface.encodeFunctionData("owner");
+}
+
+export function decodeOwner(result: string): string {
+  const [owner] = ownableIface.decodeFunctionResult("owner", result);
+  return owner;
+}
+
+const eRC2771ContextIface = new Interface([
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "forwarder",
+        type: "address"
+      }
+    ],
+    name: "isTrustedForwarder",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+]);
+
+export function encodeIsTrustedForwarder(forwarder: string) {
+  return eRC2771ContextIface.encodeFunctionData("isTrustedForwarder", [
+    forwarder
+  ]);
+}
+
+export function decodeIsTrustedForwarder(result: string): boolean {
+  const [isTrustedForwarder] = eRC2771ContextIface.decodeFunctionResult(
+    "isTrustedForwarder",
+    result
+  );
+  return isTrustedForwarder;
+}

package/src/voucher/mixin.ts

@@ -4,6 +4,7 @@ import { BigNumberish } from "@ethersproject/bignumber";
 import { handler } from ".";
 import { accounts } from "..";
 import { getOfferById } from "../offers/subgraph";
+import { encodeValidate, Order as SeaportOrder } from "../seaport/handler";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 
 export class VoucherMixin extends BaseCoreSDK {
@@ -144,4 +145,79 @@ export class VoucherMixin extends BaseCoreSDK {
       web3Lib: this._web3Lib
     });
   }
+
+  public async setApprovalForAllToContract(
+    operator: string,
+    approved: boolean,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ) {
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    return handler.setApprovalForAllToContract({
+      operator,
+      approved,
+      contractAddress: overrides.contractAddress || seller.voucherCloneAddress,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async setContractURI(
+    contractURI: string,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    return handler.setContractURI({
+      contractURI,
+      contractAddress: overrides.contractAddress || seller.voucherCloneAddress,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async validateSeaportOrders(
+    openseaConduit: string,
+    seaportContract: string,
+    orders: SeaportOrder[],
+    overrides: Partial<{
+      contractAddress: string;
+      approveIfNeeded: boolean;
+    }> = { approveIfNeeded: true }
+  ) {
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    if (overrides.approveIfNeeded) {
+      // Check the openseaConduit is approved for preminted tokens
+      const isApprovedForAll = await this.isApprovedForAll(openseaConduit, {
+        owner: seller.voucherCloneAddress,
+        contractAddress: overrides.contractAddress || seller.voucherCloneAddress
+      });
+      if (!isApprovedForAll) {
+        const txApproval = await this.setApprovalForAllToContract(
+          openseaConduit,
+          true,
+          overrides
+        );
+        await txApproval.wait();
+      }
+    }
+    return handler.callExternalContract({
+      to: seaportContract,
+      data: encodeValidate(orders),
+      contractAddress: overrides.contractAddress || seller.voucherCloneAddress,
+      web3Lib: this._web3Lib
+    });
+  }
 }