[SDK] Various improvement to data fetching in some erc721 modules

.changeset/quiet-dragons-worry.md

@@ -0,0 +1,5 @@
+---
+"@thirdweb-dev/sdk": minor
+---
+
+Improve data fetching for some ERC721 modules

packages/sdk/src/evm/core/classes/erc-721-batch-mintable.ts

@@ -73,13 +73,13 @@ export class Erc721BatchMintable implements DetectableFeature {
       to: AddressOrEns,
       metadatas: NFTMetadataOrUri[],
     ): Promise<Transaction<TransactionResultWithId<NFT>[]>> => {
-      const uris = await uploadOrExtractURIs(metadatas, this.storage);
-      const resolvedAddress = await resolveAddress(to);
+      const [uris, resolvedAddress] = await Promise.all([
+        uploadOrExtractURIs(metadatas, this.storage),
+        resolveAddress(to),
+      ]);
       const contractEncoder = new ContractEncoder(this.contractWrapper);
-      const encoded = await Promise.all(
-        uris.map(async (uri) =>
-          contractEncoder.encode("mintTo", [resolvedAddress, uri]),
-        ),
+      const encoded = uris.map((uri) =>
+        contractEncoder.encode("mintTo", [resolvedAddress, uri]),
       );
 
       return Transaction.fromContractWrapper({

packages/sdk/src/evm/core/classes/erc-721-mintable.ts

@@ -74,11 +74,14 @@ export class Erc721Mintable implements DetectableFeature {
       to: AddressOrEns,
       metadata: NFTMetadataOrUri,
     ): Promise<Transaction<TransactionResultWithId<NFT>>> => {
-      const uri = await uploadOrExtractURI(metadata, this.storage);
+      const [uri, toAddress] = await Promise.all([
+        uploadOrExtractURI(metadata, this.storage),
+        resolveAddress(to),
+      ]);
       return Transaction.fromContractWrapper({
         contractWrapper: this.contractWrapper,
         method: "mintTo",
-        args: [await resolveAddress(to), uri],
+        args: [toAddress, uri],
         parse: (receipt) => {
           const event = this.contractWrapper.parseLogs<TransferEvent>(
             "Transfer",

packages/sdk/src/evm/core/classes/erc-721-supply.ts

@@ -103,16 +103,16 @@ export class Erc721Supply implements DetectableFeature {
 
     // TODO use multicall3 if available
     // TODO can't call toNumber() here, this can be a very large number
-    return (
-      await Promise.all(
-        [...new Array(totalCount.toNumber()).keys()].map(async (i) => ({
-          tokenId: i,
-          owner: await this.erc721
-            .ownerOf(i)
-            .catch(() => constants.AddressZero),
-        })),
-      )
-    ).filter((o) => o.owner !== constants.AddressZero);
+    const arr = [...new Array(totalCount.toNumber()).keys()];
+    const owners = await Promise.all(
+      arr.map((i) => this.erc721.ownerOf(i).catch(() => constants.AddressZero)),
+    );
+    return arr
+      .map((i) => ({
+        tokenId: i,
+        owner: owners[i],
+      }))
+      .filter((o) => o.owner !== constants.AddressZero);
   }
 
   /**

packages/sdk/src/evm/core/classes/erc-721-with-quantity-signature-mintable.ts

@@ -147,30 +147,28 @@ export class Erc721WithQuantitySignatureMintable implements DetectableFeature {
       signedPayloads: SignedPayload721WithQuantitySignature[],
     ): Promise<Transaction<TransactionResultWithId[]>> => {
       const isLegacyNFTContract = await this.isLegacyNFTContract();
-
-      const contractPayloads = await Promise.all(
-        signedPayloads.map(async (s) => {
-          let message;
-
-          if (isLegacyNFTContract) {
-            message = await this.mapLegacyPayloadToContractStruct(s.payload);
-          } else {
-            message = await this.mapPayloadToContractStruct(s.payload);
-          }
-
-          const signature = s.signature;
-          const price = s.payload.price;
-          if (BigNumber.from(price).gt(0)) {
-            throw new Error(
-              "Can only batch free mints. For mints with a price, use regular mint()",
-            );
-          }
-          return {
-            message,
-            signature,
-          };
-        }),
-      );
+      const contractPayloads = (
+        await Promise.all(
+          signedPayloads.map((s) =>
+            isLegacyNFTContract
+              ? this.mapLegacyPayloadToContractStruct(s.payload)
+              : this.mapPayloadToContractStruct(s.payload),
+          ),
+        )
+      ).map((message, index) => {
+        const s = signedPayloads[index];
+        const signature = s.signature;
+        const price = s.payload.price;
+        if (BigNumber.from(price).gt(0)) {
+          throw new Error(
+            "Can only batch free mints. For mints with a price, use regular mint()",
+          );
+        }
+        return {
+          message,
+          signature,
+        };
+      });
       const contractEncoder = new ContractEncoder(this.contractWrapper);
       const encoded = contractPayloads.map((p) => {
         if (isLegacyNFTContract) {

packages/sdk/src/evm/core/classes/erc-721.ts

@@ -226,9 +226,13 @@ export class Erc721<
     address: AddressOrEns,
     operator: AddressOrEns,
   ): Promise<boolean> {
+    const [_address, _operator] = await Promise.all([
+      resolveAddress(address),
+      resolveAddress(operator),
+    ]);
     return await (this.contractWrapper as ContractWrapper<BaseERC721>).read(
       "isApprovedForAll",
-      [await resolveAddress(address), await resolveAddress(operator)],
+      [_address, _operator],
     );
   }
 
@@ -247,11 +251,14 @@ export class Erc721<
    */
   transfer = /* @__PURE__ */ buildTransactionFunction(
     async (to: AddressOrEns, tokenId: BigNumberish) => {
-      const from = await this.contractWrapper.getSignerAddress();
+      const [from, _to] = await Promise.all([
+        this.contractWrapper.getSignerAddress(),
+        resolveAddress(to),
+      ]);
       return Transaction.fromContractWrapper({
         contractWrapper: this.contractWrapper,
         method: "transferFrom(address,address,uint256)",
-        args: [from, await resolveAddress(to), tokenId],
+        args: [from, _to, tokenId],
       });
     },
   );

packages/sdk/src/evm/functions/getContractFromAbi.ts

@@ -30,9 +30,9 @@ export async function getContractFromAbi(
     params.network,
     params.sdkOptions,
   );
-  const [resolvedAddress, {chainId}] = await Promise.all([
+  const [resolvedAddress, { chainId }] = await Promise.all([
     resolveAddress(params.address),
-    provider.getNetwork()
+    provider.getNetwork(),
   ]);
 
   if (inContractCache(resolvedAddress, chainId)) {