Use provider for expected edition address (#224)

* Use provider for expected edition address

* retry logic

* 5 attempts

.changeset/shiny-bears-brush.md

@@ -0,0 +1,5 @@
+---
+'@soundxyz/sdk': patch
+---
+
+Use provider for expected edition address

packages/sdk/src/client/edition/create.ts

@@ -17,7 +17,7 @@ import {
 } from '../../errors'
 import { ContractCall, EditionConfig, MintConfig } from '../../types'
 import { editionInitFlags, MINTER_ROLE, NULL_ADDRESS, NULL_BYTES32, UINT32_MAX } from '../../utils/constants'
-import { getSaltAsBytes32, validateAddress } from '../../utils/helpers'
+import { getSaltAsBytes32, retry, validateAddress } from '../../utils/helpers'
 import { SoundClientInstance } from '../instance'
 
 export async function createEdition(
@@ -51,7 +51,10 @@ export async function createEdition(
 
   validateMintConfigs(mintConfigs)
 
-  const { signer, userAddress } = await this.expectSigner()
+  const [{ signer, userAddress }, { providerOrSigner }] = await Promise.all([
+    this.expectSigner(),
+    this.expectProviderOrSigner(),
+  ])
 
   const txnOverrides: Overrides = {
     gasLimit,
@@ -62,9 +65,13 @@ export async function createEdition(
   const formattedSalt = getSaltAsBytes32(customSalt || Math.random() * 1_000_000_000_000_000)
 
   // Precompute the edition address.
-  const [editionAddress, _] = await SoundCreatorV1__factory.connect(creatorAddress, signer).soundEditionAddress(
-    userAddress,
-    formattedSalt,
+  const [editionAddress, _] = await retry(
+    () =>
+      SoundCreatorV1__factory.connect(creatorAddress, providerOrSigner).soundEditionAddress(userAddress, formattedSalt),
+    {
+      attempts: 5,
+      delay: 500,
+    },
   )
 
   const editionInterface = SoundEditionV1_2__factory.createInterface()
@@ -267,11 +274,11 @@ export async function expectedEditionAddress(
     type: 'CREATOR_ADDRESS',
     address: creatorAddress,
   })
-  const { signerOrProvider } = await this.expectSignerOrProvider()
+  const { providerOrSigner } = await this.expectProviderOrSigner()
 
   const { addr: editionAddress, exists } = await SoundCreatorV1__factory.connect(
     creatorAddress,
-    signerOrProvider,
+    providerOrSigner,
   ).soundEditionAddress(deployer, getSaltAsBytes32(salt))
 
   return {

packages/sdk/src/client/instance.ts

@@ -110,6 +110,22 @@ export function SoundClientInstance({
     throw new MissingSignerOrProviderError()
   }
 
+  async function expectProviderOrSigner(): Promise<{ providerOrSigner: SignerOrProvider }> {
+    if (instance.provider) {
+      const provider = await getLazyOption(instance.provider)
+      return { providerOrSigner: provider }
+    }
+    if (instance.signer) {
+      const signer = await getLazyOption(instance.signer)
+
+      if (signer.provider) return { providerOrSigner: signer.provider }
+
+      return { providerOrSigner: signer }
+    }
+
+    throw new MissingSignerOrProviderError()
+  }
+
   function expectSoundAPI() {
     const soundAPI = instance.soundAPI
     if (!soundAPI) throw new MissingSoundAPI()
@@ -123,6 +139,7 @@ export function SoundClientInstance({
     expectSigner,
     expectProvider,
     expectSignerOrProvider,
+    expectProviderOrSigner,
     expectSoundAPI,
     getNetworkChainId,
   }

packages/sdk/src/utils/helpers.ts

@@ -63,3 +63,28 @@ export function curry<T extends (...args: any[]) => any>(fn: T): Curry<T> {
 export function exhaustiveGuard(_value: never): never {
   throw new Error(`Exhaustive guard reached with value ${_value}`)
 }
+
+export async function retry<T>(
+  fn: () => Promise<T>,
+  {
+    attempts,
+    delay,
+  }: {
+    attempts: number
+    delay: number
+  },
+): Promise<T> {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn()
+    } catch (error) {
+      if (i < attempts - 1) {
+        await new Promise<void>((resolve) => setTimeout(resolve, delay))
+      } else {
+        throw error
+      }
+    }
+  }
+
+  return fn()
+}