Improve erc-20 methods

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

@@ -57,17 +57,18 @@ export class Erc20BatchMintable implements DetectableFeature {
    */
   to = /* @__PURE__ */ buildTransactionFunction(
     async (args: TokenMintInput[]) => {
-      const encoded: string[] = [];
       const contractEncoder = new ContractEncoder(this.contractWrapper);
-
-      for (const arg of args) {
-        encoded.push(
-          contractEncoder.encode("mintTo", [
-            await resolveAddress(arg.toAddress),
-            await this.erc20.normalizeAmount(arg.amount),
+      const _items = await Promise.all(
+        args.map((item) =>
+          Promise.all([
+            resolveAddress(item.toAddress),
+            this.erc20.normalizeAmount(item.amount),
           ]),
-        );
-      }
+        ),
+      );
+      const encoded = _items.map(([address, amount]) =>
+        contractEncoder.encode("mintTo", [address, amount]),
+      );
 
       return Transaction.fromContractWrapper({
         contractWrapper: this.contractWrapper,

packages/sdk/src/evm/core/classes/erc-20-burnable.ts

@@ -62,10 +62,10 @@ export class Erc20Burnable implements DetectableFeature {
       return Transaction.fromContractWrapper({
         contractWrapper: this.contractWrapper,
         method: "burnFrom",
-        args: [
-          await resolveAddress(holder),
-          await this.erc20.normalizeAmount(amount),
-        ],
+        args: await Promise.all([
+          resolveAddress(holder),
+          this.erc20.normalizeAmount(amount),
+        ]),
       });
     },
   );

packages/sdk/src/evm/core/classes/erc-20-history.ts

@@ -55,14 +55,24 @@ export class TokenERC20History {
         balances[to] = balances[to].add(amount);
       }
     });
+    const _promises = Object.entries(balances).map(async ([addr, value]) => {
+      const result = await fetchCurrencyValue(
+        this.contractWrapper.getProvider(),
+        this.contractWrapper.address,
+        value,
+      );
+      return { [addr]: result };
+    });
+    const balanceData = (await Promise.all(_promises)).reduce(
+      (result, currentObject) => {
+        return { ...result, ...currentObject };
+      },
+      {},
+    );
     return Promise.all(
       Object.keys(balances).map(async (addr) => ({
         holder: addr,
-        balance: await fetchCurrencyValue(
-          this.contractWrapper.getProvider(),
-          this.contractWrapper.address,
-          balances[addr],
-        ),
+        balance: balanceData[addr],
       })),
     );
   }

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

@@ -66,10 +66,10 @@ export class Erc20Mintable implements DetectableFeature {
     return Transaction.fromContractWrapper({
       contractWrapper: this.contractWrapper,
       method: "mintTo",
-      args: [
-        await resolveAddress(to),
-        await this.erc20.normalizeAmount(amount),
-      ],
+      args: await Promise.all([
+        resolveAddress(to),
+        this.erc20.normalizeAmount(amount),
+      ]),
     });
   }
 

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

@@ -63,8 +63,10 @@ export class Erc20SignatureMintable implements DetectableFeature {
     async (signedPayload: SignedPayload20) => {
       const mintRequest = signedPayload.payload;
       const signature = signedPayload.signature;
-      const message = await this.mapPayloadToContractStruct(mintRequest);
-      const overrides = await this.contractWrapper.getCallOverrides();
+      const [message, overrides] = await Promise.all([
+        this.mapPayloadToContractStruct(mintRequest),
+        this.contractWrapper.getCallOverrides(),
+      ]);
       // TODO: Transaction Sequence Pattern
       await setErc20Allowance(
         this.contractWrapper,
@@ -89,23 +91,24 @@ export class Erc20SignatureMintable implements DetectableFeature {
    */
   mintBatch = /* @__PURE__ */ buildTransactionFunction(
     async (signedPayloads: SignedPayload20[]) => {
-      const contractPayloads = await Promise.all(
-        signedPayloads.map(async (s) => {
-          const 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) => 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) => {
         return contractEncoder.encode("mintWithSignature", [
@@ -208,17 +211,19 @@ export class Erc20SignatureMintable implements DetectableFeature {
       payloadsToSign.map((m) => Signature20PayloadInput.parseAsync(m)),
     );
 
-    const chainId = await this.contractWrapper.getChainID();
+    const [chainId, name] = await Promise.all([
+      this.contractWrapper.getChainID(),
+      // ERC20Permit (EIP-712) spec differs from signature mint 721, 1155.
+      this.contractWrapper.read("name", []),
+    ]);
     const signer = this.contractWrapper.getSigner();
     invariant(signer, "No signer available");
-
-    // ERC20Permit (EIP-712) spec differs from signature mint 721, 1155.
-    const name = await this.contractWrapper.read("name", []);
-
-    return await Promise.all(
-      parsedRequests.map(async (m) => {
-        const finalPayload = await Signature20PayloadOutput.parseAsync(m);
-        const signature = await this.contractWrapper.signTypedData(
+    const _finalPayloads: PayloadWithUri20[] = await Promise.all(
+      parsedRequests.map((m) => Signature20PayloadOutput.parseAsync(m)),
+    );
+    const _signatures = await Promise.all(
+      _finalPayloads.map((payload) =>
+        this.contractWrapper.signTypedData(
           signer,
           {
             name,
@@ -227,14 +232,14 @@ export class Erc20SignatureMintable implements DetectableFeature {
             verifyingContract: this.contractWrapper.address,
           },
           { MintRequest: MintRequest20 },
-          await this.mapPayloadToContractStruct(finalPayload),
-        );
-        return {
-          payload: finalPayload,
-          signature: signature.toString(),
-        };
-      }),
+          payload,
+        ),
+      ),
     );
+    return parsedRequests.map((_, index) => ({
+      payload: _finalPayloads[index],
+      signature: _signatures[index] as string,
+    }));
   }
 
   /** ******************************
@@ -251,14 +256,17 @@ export class Erc20SignatureMintable implements DetectableFeature {
   private async mapPayloadToContractStruct(
     mintRequest: PayloadWithUri20,
   ): Promise<ITokenERC20.MintRequestStructOutput> {
-    const normalizedPrice = await normalizePriceValue(
-      this.contractWrapper.getProvider(),
-      mintRequest.price,
-      mintRequest.currencyAddress,
-    );
+    const [normalizedPrice, _decimals] = await Promise.all([
+      normalizePriceValue(
+        this.contractWrapper.getProvider(),
+        mintRequest.price,
+        mintRequest.currencyAddress,
+      ),
+      this.contractWrapper.read("decimals", []),
+    ]);
     const amountWithDecimals = utils.parseUnits(
       mintRequest.quantity,
-      await this.contractWrapper.read("decimals", []),
+      _decimals,
     );
     return {
       to: mintRequest.to,