ipfs related cleanups (#104)

* Updates (#103)

* pass context in a few more places (#101)

* handle and return err (#102)

Co-authored-by: ricebin <ricebin@users.noreply.github.com>

* ipfs related cleanups
1. reuse httpclient when possible
2. pass context in more places
3. dont forget to check errors

Co-authored-by: Adam Majmudar <64697628+adam-maj@users.noreply.github.com>

cmd/thirdweb/common.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+
 	"github.com/thirdweb-dev/go-sdk/v2/thirdweb"
 )
 
@@ -171,7 +172,7 @@ func getCustom() (*thirdweb.SmartContract, error) {
 
 	log.Printf("Obtaining a Custom on chain %v, contract %v\n", chainRpcUrl, customContractAddress)
 
-	if contract, err := thirdwebSDK.GetContract(customContractAddress); err != nil {
+	if contract, err := thirdwebSDK.GetContract(context.Background(), customContractAddress); err != nil {
 		log.Println("Failed to create an Custom object")
 		return nil, err
 	} else {

cmd/thirdweb/nft_drop_commands.go

@@ -162,7 +162,7 @@ var nftDropClaimCmd = &cobra.Command{
 
 		awaitTx(tx.Hash())
 
-		unclaimed, err := nftDrop.TotalUnclaimedSupply()
+		unclaimed, err := nftDrop.TotalUnclaimedSupply(context.Background())
 		if err != nil {
 			panic(err)
 		}

cmd/thirdweb/storage_commands.go

@@ -1,12 +1,14 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"os"
 
 	"github.com/mitchellh/mapstructure"
 	"github.com/spf13/cobra"
+
 	"github.com/thirdweb-dev/go-sdk/v2/thirdweb"
 )
 
@@ -37,7 +39,7 @@ var storageUploadCmd = &cobra.Command{
 			},
 		}
 
-		uri, err := storage.Upload(assetToUpload, "", "")
+		uri, err := storage.Upload(context.Background(), assetToUpload, "", "")
 		if err != nil {
 			panic(err)
 		}
@@ -71,9 +73,12 @@ var storageUploadBatchCmd = &cobra.Command{
 			&thirdweb.NFTMetadataInput{Name: "Test NFT 3", Description: "Description 3"},
 		}
 		assetToUpload := []map[string]interface{}{}
-		err = mapstructure.Decode(asset, &assetToUpload)
+		if err := mapstructure.Decode(asset, &assetToUpload); err != nil {
+			panic(err)
+		}
 
 		uriWithBaseUris, err := storage.UploadBatch(
+			context.Background(),
 			assetToUpload,
 			0,
 			"",
@@ -106,8 +111,11 @@ var storageUploadImageCmd = &cobra.Command{
 		}
 		assetToUpload := map[string]interface{}{}
 		err = mapstructure.Decode(asset, &assetToUpload)
+		if err != nil {
+			panic(err)
+		}
 
-		uri, err := storage.Upload(assetToUpload, "", "")
+		uri, err := storage.Upload(context.Background(), assetToUpload, "", "")
 		if err != nil {
 			panic(err)
 		}
@@ -134,8 +142,11 @@ var storageUploadImageLinkCmd = &cobra.Command{
 		}
 		assetToUpload := map[string]interface{}{}
 		err = mapstructure.Decode(asset, &assetToUpload)
+		if err != nil {
+			panic(err)
+		}
 
-		uri, err := storage.Upload(assetToUpload, "", "")
+		uri, err := storage.Upload(context.Background(), assetToUpload, "", "")
 		if err != nil {
 			panic(err)
 		}

thirdweb/common.go

@@ -26,8 +26,8 @@ import (
 
 // NFT
 
-func fetchTokenMetadata(tokenId int, uri string, storage storage) (*NFTMetadata, error) {
-	if body, err := storage.Get(uri); err != nil {
+func fetchTokenMetadata(ctx context.Context, tokenId int, uri string, storage storage) (*NFTMetadata, error) {
+	if body, err := storage.Get(ctx, uri); err != nil {
 		return nil, err
 	} else {
 		metadata := &NFTMetadata{
@@ -41,23 +41,27 @@ func fetchTokenMetadata(tokenId int, uri string, storage storage) (*NFTMetadata,
 	}
 }
 
-func uploadOrExtractUri(metadata *NFTMetadataInput, storage storage) (string, error) {
+func uploadOrExtractUri(ctx context.Context, metadata *NFTMetadataInput, storage storage) (string, error) {
 	metadataToUpload := map[string]interface{}{}
-	mapstructure.Decode(metadata, &metadataToUpload)
-	return storage.Upload(metadataToUpload, "", "")
+	if err := mapstructure.Decode(metadata, &metadataToUpload); err != nil {
+		return "", err
+	}
+	return storage.Upload(ctx, metadataToUpload, "", "")
 }
 
-func uploadOrExtractUris(metadatas []*NFTMetadataInput, storage storage) ([]string, error) {
+func uploadOrExtractUris(ctx context.Context, metadatas []*NFTMetadataInput, storage storage) ([]string, error) {
 	// Why is this necessary?
 	data := []interface{}{}
 	for _, metadata := range metadatas {
 		data = append(data, metadata)
 	}
 
 	dataToUpload := []map[string]interface{}{}
-	mapstructure.Decode(data, &dataToUpload)
+	if err := mapstructure.Decode(data, &dataToUpload); err != nil {
+		return nil, err
+	}
 
-	baseUriWithUris, err := storage.UploadBatch(dataToUpload, 0, "", "")
+	baseUriWithUris, err := storage.UploadBatch(ctx, dataToUpload, 0, "", "")
 	if err != nil {
 		return nil, err
 	}
@@ -296,7 +300,9 @@ func approveErc20Allowance(
 			return err
 		}
 
-		contractToApprove.AwaitTx(tx.Hash())
+		if _, err := contractToApprove.AwaitTx(tx.Hash()); err != nil {
+			return err
+		}
 	}
 
 	return nil
@@ -439,7 +445,7 @@ func fetchSnapshotEntryForAddress(
 
 	snapshotUri, exists := (*merkleMetadata)[merkleRoot]
 	if exists {
-		body, err := storage.Get(snapshotUri)
+		body, err := storage.Get(ctx, snapshotUri)
 		if err != nil {
 			return nil, err
 		}
@@ -601,22 +607,22 @@ func isTokenApprovedForTransfer(
 
 // CUSTOM CONTRACTS
 
-func fetchContractMetadataFromAddress(address string, provider *ethclient.Client, storage storage) (string, error) {
-	metadataUri, err := resolveContractUriFromAddress(address, provider)
+func fetchContractMetadataFromAddress(ctx context.Context, address string, provider *ethclient.Client, storage storage) (string, error) {
+	metadataUri, err := resolveContractUriFromAddress(ctx, address, provider)
 	if err != nil {
 		return "", err
 	}
 
-	metadata, err := fetchContractMetadata(metadataUri, storage)
+	metadata, err := fetchContractMetadata(ctx, metadataUri, storage)
 	if err != nil {
 		return "", err
 	}
 
 	return metadata, nil
 }
 
-func resolveContractUriFromAddress(address string, provider *ethclient.Client) (string, error) {
-	bytecode, err := provider.CodeAt(context.Background(), common.HexToAddress(address), nil)
+func resolveContractUriFromAddress(ctx context.Context, address string, provider *ethclient.Client) (string, error) {
+	bytecode, err := provider.CodeAt(ctx, common.HexToAddress(address), nil)
 	if err != nil {
 		return "", err
 	}
@@ -637,8 +643,8 @@ func extractIPFSHashFromBytecode(bytecode []byte) (string, error) {
 	return fmt.Sprintf("ipfs://%v", ipfsHash), nil
 }
 
-func fetchContractMetadata(uri string, storage storage) (string, error) {
-	body, err := storage.Get(uri)
+func fetchContractMetadata(ctx context.Context, uri string, storage storage) (string, error) {
+	body, err := storage.Get(ctx, uri)
 	if err != nil {
 		return "", err
 	}
@@ -697,7 +703,7 @@ func fetchTokenMetadataForContract(
 		uri, err = contract.Uri(&bind.CallOpts{Context: ctx}, big.NewInt(int64(tokenId)))
 	}
 
-	return fetchTokenMetadata(tokenId, uri, storage)
+	return fetchTokenMetadata(ctx, tokenId, uri, storage)
 }
 
 func handleTokenApproval(

thirdweb/contract_deployer.go

@@ -224,6 +224,7 @@ func (deployer *ContractDeployer) deployContract(ctx context.Context, contractTy
 	}
 
 	contractUri, err := deployer.storage.Upload(
+		ctx,
 		metadataToUpload,
 		deployer.helper.getAddress().String(),
 		deployer.helper.GetSignerAddress().String(),

thirdweb/contract_events.go

@@ -18,22 +18,21 @@ import (
 // This interface provides a way to query past events or listen for future events on any contract.
 // It's currently support on all pre-built and custom contracts!
 //
-//
 // Example
 //
-// 	// First get an instance of your contract
-// 	contract, _ := sdk.GetContract("0x...");
+//	// First get an instance of your contract
+//	contract, _ := sdk.GetContract("0x...");
 //
-// 	// Now, get all Transfer events from a specific block range
-// 	contract.Events.GetEvents("Transfer", thirdweb.EventQueryOptions{
-// 	  FromBlock: 100000000,
-// 	  ToBlock:   100000001,
-// 	})
+//	// Now, get all Transfer events from a specific block range
+//	contract.Events.GetEvents("Transfer", thirdweb.EventQueryOptions{
+//	  FromBlock: 100000000,
+//	  ToBlock:   100000001,
+//	})
 //
-// 	// And setup a listener to listen for future Transfer events
-// 	contract.Events.AddEventListener("Transfer", func (event thirdweb.ContractEvent) {
-// 	  fmt.Printf("%#v\n", event)
-// 	})
+//	// And setup a listener to listen for future Transfer events
+//	contract.Events.AddEventListener("Transfer", func (event thirdweb.ContractEvent) {
+//	  fmt.Printf("%#v\n", event)
+//	})
 type ContractEvents struct {
 	abi      *abi.ABI
 	contract *bind.BoundContract
@@ -53,8 +52,8 @@ type ContractEvent struct {
 }
 
 type EventSubscription struct {
-  Err 				func () <- chan error
-	Unsubscribe func ()
+	Err         func() <-chan error
+	Unsubscribe func()
 }
 
 func newContractEvents(contractAbi string, helper *contractHelper) (*ContractEvents, error) {
@@ -82,17 +81,17 @@ func newContractEvents(contractAbi string, helper *contractHelper) (*ContractEve
 //
 // Example
 //
-// 	// Define a listener function to be called whenever a new Transfer event is received
-// 	listener := func (event thirdweb.ContractEvent) {
-// 	  fmt.Printf("%#v\n", event)
-// 	} 
+//	// Define a listener function to be called whenever a new Transfer event is received
+//	listener := func (event thirdweb.ContractEvent) {
+//	  fmt.Printf("%#v\n", event)
+//	}
 //
-// 	// Add a new listener for the Transfer event
-// 	subscription := contract.Events.AddEventListener(context.Background(), "Transfer", listener)
+//	// Add a new listener for the Transfer event
+//	subscription := contract.Events.AddEventListener(context.Background(), "Transfer", listener)
 //
-// 	// Unsubscribe from the Transfer event at some time in the future, closing the listener
-// 	subscription.Unsubscribe()
-func (events *ContractEvents) AddEventListener(ctx context.Context, eventName string, listener func (event ContractEvent)) (EventSubscription) {
+//	// Unsubscribe from the Transfer event at some time in the future, closing the listener
+//	subscription.Unsubscribe()
+func (events *ContractEvents) AddEventListener(ctx context.Context, eventName string, listener func(event ContractEvent)) EventSubscription {
 	ticker := time.NewTicker(2 * time.Second)
 	done := make(chan bool)
 	errors := make(chan error)
@@ -106,9 +105,9 @@ func (events *ContractEvents) AddEventListener(ctx context.Context, eventName st
 
 		for {
 			select {
-			case <- done:
+			case <-done:
 				return
-			case <- ticker.C:
+			case <-ticker.C:
 				currentBlockNumber, err := events.helper.GetProvider().BlockNumber(ctx)
 				if err != nil {
 					errors <- err
@@ -118,7 +117,7 @@ func (events *ContractEvents) AddEventListener(ctx context.Context, eventName st
 				if currentBlockNumber >= nextBlockToCheck {
 					recentEvents, err := events.GetEvents(ctx, eventName, EventQueryOptions{
 						FromBlock: nextBlockToCheck,
-						ToBlock: &currentBlockNumber,
+						ToBlock:   &currentBlockNumber,
 					})
 					if err != nil {
 						errors <- err
@@ -136,10 +135,10 @@ func (events *ContractEvents) AddEventListener(ctx context.Context, eventName st
 	}()
 
 	subscription := EventSubscription{
-		Err: func () (<-chan error) {
+		Err: func() <-chan error {
 			return errors
 		},
-		Unsubscribe: func () {
+		Unsubscribe: func() {
 			done <- true
 		},
 	}
@@ -157,21 +156,21 @@ func (events *ContractEvents) AddEventListener(ctx context.Context, eventName st
 //
 // Example
 //
-// 	// First we define a filter to only get Transfer events where the "from" address is "0x..."
-// 	// Note that you can only add filters for indexed parameters on events
-// 	filters := map[string]interface{} {
-// 	  "from": common.HexToAddress("0x...")
-// 	}
-//
-// 	// Now we can define the query options, including the block range and the filter
-// 	queryOptions := thirdweb.EventQueryOptions{
-// 	  FromBlock: 100000000, // Defaults to block 0 if you don't specify this field
-// 	  ToBlock:   100000001, // Defaults to latest block if you don't specify this field
-// 	  Filters:   filters,	
-// 	}
-//
-// 	// Now we can query for the Transfer events
-// 	events, _ := contract.Events.GetEvents("Transfer", queryOptions)
+//	// First we define a filter to only get Transfer events where the "from" address is "0x..."
+//	// Note that you can only add filters for indexed parameters on events
+//	filters := map[string]interface{} {
+//	  "from": common.HexToAddress("0x...")
+//	}
+//
+//	// Now we can define the query options, including the block range and the filter
+//	queryOptions := thirdweb.EventQueryOptions{
+//	  FromBlock: 100000000, // Defaults to block 0 if you don't specify this field
+//	  ToBlock:   100000001, // Defaults to latest block if you don't specify this field
+//	  Filters:   filters,
+//	}
+//
+//	// Now we can query for the Transfer events
+//	events, _ := contract.Events.GetEvents("Transfer", queryOptions)
 func (events *ContractEvents) GetEvents(ctx context.Context, eventName string, options EventQueryOptions) ([]ContractEvent, error) {
 	eventSignature, ok := events.abi.Events[eventName]
 	if !ok {
@@ -188,12 +187,12 @@ func (events *ContractEvents) GetEvents(ctx context.Context, eventName string, o
 					// If a filter is provided, check if the type is correct
 					if reflect.TypeOf(value) != input.Type.GetType() {
 						return nil, fmt.Errorf(
-							"Filter for indexed input '%s' is of wrong type, expected type '%s'", 
-							input.Name, 
+							"Filter for indexed input '%s' is of wrong type, expected type '%s'",
+							input.Name,
 							input.Type.GetType().String(),
 						)
 					}
-	
+
 					// If the type is correct, add the filter to the query
 					query = append(query, []interface{}{value})
 				} else {
@@ -203,7 +202,7 @@ func (events *ContractEvents) GetEvents(ctx context.Context, eventName string, o
 			}
 		}
 	}
-	
+
 	topics, err := abi.MakeTopics(query...)
 	if err != nil {
 		return nil, err
@@ -238,8 +237,10 @@ func (events *ContractEvents) GetEvents(ctx context.Context, eventName string, o
 
 func (events *ContractEvents) transformEvent(eventName string, log types.Log) (ContractEvent, error) {
 	parsedLog := map[string]interface{}{}
-	events.contract.UnpackLogIntoMap(parsedLog, eventName, log)
-	event := ContractEvent{ eventName, parsedLog, log }
+	if err := events.contract.UnpackLogIntoMap(parsedLog, eventName, log); err != nil {
+		return ContractEvent{}, err
+	}
+	event := ContractEvent{eventName, parsedLog, log}
 
 	return event, nil
-}
+}