[SDK] Perf improvement: Remove request waterfall from multiple methods

.changeset/cyan-trainers-lie.md

@@ -0,0 +1,5 @@
+---
+"@thirdweb-dev/sdk": patch
+---
+
+Remove request waterfall from various methods

packages/sdk/src/evm/contracts/prebuilt-implementations/multiwrap.ts

@@ -238,14 +238,11 @@ export class Multiwrap extends StandardErc721<MultiwrapContract> {
       wrappedTokenMetadata: NFTMetadataOrUri,
       recipientAddress?: AddressOrEns,
     ): Promise<Transaction<TransactionResultWithId<NFT>>> => {
+      const signerAddress = await this.contractWrapper.getSignerAddress();
       const [uri, tokens, recipient] = await Promise.all([
         uploadOrExtractURI(wrappedTokenMetadata, this.storage),
         this.toTokenStructList(contents),
-        resolveAddress(
-          recipientAddress
-            ? recipientAddress
-            : await this.contractWrapper.getSignerAddress(),
-        ),
+        resolveAddress(recipientAddress ? recipientAddress : signerAddress),
       ]);
 
       return Transaction.fromContractWrapper({

packages/sdk/src/evm/contracts/prebuilt-implementations/signature-drop.ts

@@ -268,7 +268,7 @@ export class SignatureDrop extends StandardErc721<SignatureDropContract> {
    * ```
    *
    * @param queryParams - optional filtering to only fetch a subset of results.
-   * @returns The NFT metadata and their ownersfor all NFTs queried.
+   * @returns The NFT metadata and their owners for all NFTs queried.
    */
   public async getAllClaimed(queryParams?: QueryAllParams): Promise<NFT[]> {
     const start = BigNumber.from(queryParams?.start || 0).toNumber();

packages/sdk/src/evm/core/classes/account-permissions.ts

@@ -744,21 +744,27 @@ export class AccountPermissions implements DetectableFeature {
           return !item.makeAdmin;
         })
         .map((item) => item.signer);
-      await Promise.all(
-        allSigners.map(async (item) => {
-          if (!allToMakeSigners.includes(item.signer)) {
-            const data = (
-              await this.sendSignerPermissionRequest(
+
+      const requests = await Promise.all(
+        allSigners.map((item) =>
+          !allToMakeSigners.includes(item.signer)
+            ? this.sendSignerPermissionRequest(
                 item.signer,
                 DEFAULT_PERMISSIONS,
                 AdminFlag.None,
               )
-            ).encode();
-            removeSignerData.push(data);
-          }
-        }),
+            : null,
+        ),
       );
 
+      allSigners.map((item, index) => {
+        const request = requests[index];
+        if (!allToMakeSigners.includes(item.signer) && request) {
+          const data = request.encode();
+          removeSignerData.push(data);
+        }
+      });
+
       for (const member of resolvedSnapshot) {
         // Add new admin
         if (member.makeAdmin) {

packages/sdk/src/evm/core/classes/contract-roles.ts

@@ -210,21 +210,21 @@ export class ContractRoles<TContract extends IPermissions, TRole extends Role>
    * @internal
    */
   public async verify(roles: TRole[], address: AddressOrEns): Promise<void> {
-    await Promise.all(
-      roles.map(async (role) => {
-        const [members, resolvedAddress] = await Promise.all([
-          this.get(role),
-          resolveAddress(address),
-        ]);
-        if (
-          !members
-            .map((a) => a.toLowerCase())
-            .includes(resolvedAddress.toLowerCase())
-        ) {
-          throw new MissingRoleError(resolvedAddress, role);
-        }
-      }),
-    );
+    const [resolvedAddress, fetchedRoles]: [string, string[][]] =
+      await Promise.all([
+        resolveAddress(address),
+        Promise.all(roles.map((role) => this.get(role))),
+      ]);
+    roles.map(async (role, index) => {
+      const members = fetchedRoles[index];
+      if (
+        !members
+          .map((a) => a.toLowerCase())
+          .includes(resolvedAddress.toLowerCase())
+      ) {
+        throw new MissingRoleError(resolvedAddress, role);
+      }
+    });
   }
 
   /** **************************

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

@@ -291,18 +291,20 @@ export class Erc721TieredDrop implements DetectableFeature {
   public async generateBatch(
     payloadsToSign: TieredDropPayloadInput[],
   ): Promise<TieredDropPayloadWithSignature[]> {
+    const signer = this.contractWrapper.getSigner();
+    invariant(signer, "No signer available");
     const parsedPayloads = await Promise.all(
       payloadsToSign.map((payload) =>
         TieredDropPayloadSchema.parseAsync(payload),
       ),
     );
     const chainId = await this.contractWrapper.getChainID();
-    const signer = this.contractWrapper.getSigner();
-    invariant(signer, "No signer available");
-
-    return await Promise.all(
-      parsedPayloads.map(async (payload) => {
-        const signature = await this.contractWrapper.signTypedData(
+    const contractStructs = await Promise.all(
+      parsedPayloads.map((payload) => this.mapPayloadToContractStruct(payload)),
+    );
+    const signatures = await Promise.all(
+      contractStructs.map((message) =>
+        this.contractWrapper.signTypedData(
           signer,
           {
             name: "SignatureAction",
@@ -311,12 +313,14 @@ export class Erc721TieredDrop implements DetectableFeature {
             verifyingContract: this.contractWrapper.address,
           },
           { GenericRequest: GenericRequest },
-          await this.mapPayloadToContractStruct(payload),
-        );
-
-        return { payload, signature: signature.toString() };
-      }),
+          message,
+        ),
+      ),
     );
+    return parsedPayloads.map((payload, index) => {
+      const signature = signatures[index];
+      return { payload, signature: signature.toString() };
+    });
   }
 
   public async verify(

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

@@ -313,7 +313,7 @@ export class Erc721WithQuantitySignatureMintable implements DetectableFeature {
   }
 
   /**
-   * Genrate a batch of signatures that can be used to mint many dynamic NFTs.
+   * Generate a batch of signatures that can be used to mint many dynamic NFTs.
    *
    * @remarks See {@link Erc721WithQuantitySignatureMintable.generate}
    *
@@ -324,59 +324,58 @@ export class Erc721WithQuantitySignatureMintable implements DetectableFeature {
   public async generateBatch(
     payloadsToSign: PayloadToSign721withQuantity[],
   ): Promise<SignedPayload721WithQuantitySignature[]> {
-    const isLegacyNFTContract = await this.isLegacyNFTContract();
-
-    const parsedRequests = await Promise.all(
-      payloadsToSign.map((m) => Signature721WithQuantityInput.parseAsync(m)),
-    );
+    const [isLegacyNFTContract, parsedRequests, chainId] = await Promise.all([
+      this.isLegacyNFTContract(),
+      Promise.all(
+        payloadsToSign.map((m) => Signature721WithQuantityInput.parseAsync(m)),
+      ),
+      this.contractWrapper.getChainID(),
+    ]);
 
     const metadatas = parsedRequests.map((r) => r.metadata);
     const uris = await uploadOrExtractURIs(metadatas, this.storage);
 
-    const chainId = await this.contractWrapper.getChainID();
     const signer = this.contractWrapper.getSigner();
     invariant(signer, "No signer available");
 
-    return await Promise.all(
-      parsedRequests.map(async (m, i) => {
-        const uri = uris[i];
-        const finalPayload = await Signature721WithQuantityOutput.parseAsync({
+    const finalPayloads = await Promise.all(
+      parsedRequests.map((m, index) =>
+        Signature721WithQuantityOutput.parseAsync({
           ...m,
-          uri,
-        });
-        let signature;
-
-        if (isLegacyNFTContract) {
-          signature = await this.contractWrapper.signTypedData(
-            signer,
-            {
-              name: "TokenERC721",
-              version: "1",
-              chainId,
-              verifyingContract: this.contractWrapper.address,
-            },
-            { MintRequest: MintRequest721 },
-            await this.mapLegacyPayloadToContractStruct(finalPayload),
-          );
-        } else {
-          signature = await this.contractWrapper.signTypedData(
-            signer,
-            {
-              name: "SignatureMintERC721",
-              version: "1",
-              chainId,
-              verifyingContract: await this.contractWrapper.address,
-            },
-            { MintRequest: MintRequest721withQuantity }, // TYPEHASH
-            await this.mapPayloadToContractStruct(finalPayload),
-          );
-        }
-        return {
-          payload: finalPayload,
-          signature: signature.toString(),
-        };
-      }),
+          uri: uris[index],
+        }),
+      ),
+    );
+    const contractStructs = await Promise.all(
+      finalPayloads.map((finalPayload) =>
+        isLegacyNFTContract
+          ? this.mapLegacyPayloadToContractStruct(finalPayload)
+          : this.mapPayloadToContractStruct(finalPayload),
+      ),
+    );
+    const signatures = await Promise.all(
+      contractStructs.map((struct) =>
+        this.contractWrapper.signTypedData(
+          signer,
+          {
+            name: isLegacyNFTContract ? "TokenERC721" : "SignatureMintERC721",
+            version: "1",
+            chainId,
+            verifyingContract: this.contractWrapper.address,
+          },
+          {
+            MintRequest: isLegacyNFTContract
+              ? MintRequest721
+              : MintRequest721withQuantity,
+          },
+          struct,
+        ),
+      ),
     );
+    return signatures.map((signature, index) => ({
+      payload: finalPayloads[index],
+      signature: signature.toString(),
+    }));
   }
 
   /** ******************************

packages/sdk/src/evm/core/classes/multichain-registry.ts

@@ -149,12 +149,14 @@ export class MultichainRegistry {
     ): Promise<Transaction<TransactionResult>> => {
       const deployerAddress = await this.registryRouter.getSignerAddress();
       const contractEncoder = new ContractEncoder(this.registryLogic);
-
+      const contractAddresses = await Promise.all(
+        contracts.map((item) => resolveAddress(item.address)),
+      );
       const encoded: string[] = await Promise.all(
-        contracts.map(async (contract) =>
+        contracts.map(async (contract, index) =>
           contractEncoder.encode("remove", [
             deployerAddress,
-            await resolveAddress(contract.address),
+            contractAddresses[index],
             contract.chainId,
           ]),
         ),

packages/sdk/src/evm/core/sdk.ts

@@ -2338,25 +2338,26 @@ export class ContractDeployer extends RPCConnectionHandler {
           });
         });
       }
-
-      transactions = (
-        await Promise.all(
-          transactions.map(async (tx) => {
-            const addresses = (
-              await Promise.all(
-                tx.addresses.map(async (address) => {
-                  const isDeployed = await isContractDeployed(
-                    address,
-                    provider,
-                  );
-                  return isDeployed ? null : address;
-                }),
-              )
-            ).filter(Boolean);
-            return addresses.length > 0 ? tx : null;
-          }),
-        )
-      ).filter(Boolean) as DeploymentTransaction[];
+      const isDeployedArr = await Promise.all(
+        transactions.map((tx) =>
+          Promise.all(
+            tx.addresses.map((address) =>
+              isContractDeployed(address, provider),
+            ),
+          ),
+        ),
+      );
+      transactions = transactions
+        .map((tx, index) => {
+          const addresses = tx.addresses
+            .map((address, txIndex) => {
+              const isDeployed = isDeployedArr[index][txIndex];
+              return isDeployed ? null : address;
+            })
+            .filter(Boolean);
+          return addresses.length > 0 ? tx : null;
+        })
+        .filter(Boolean) as DeploymentTransaction[];
 
       transactions.push({
         contractType: "proxy",