Merge pull request #85 from dapperlabs/seanp/add-atlas-transactions-and-parser

Add atlas user transaction for pack sales and cadence parser

Author: bspowell

atlas/embed.go

@@ -0,0 +1,11 @@
+package atlas
+
+import (
+	_ "embed"
+)
+
+// Transactions is a list of all the transactions we export with imports mapped
+var (
+	//go:embed transactions/user/buy_packs_primary_sale.cdc
+	UserBuyPacksPrimarySale []byte
+)

atlas/transactions/user/buy_packs_primary_sale.cdc

@@ -0,0 +1,72 @@
+import FungibleToken from 0x{{.FungibleTokenContractAddress}}
+import NonFungibleToken from 0x{{.NonFungibleTokenContractAddress}}
+import DapperUtilityCoin from 0x{{.DapperUtilityCoinContractAddress}}
+import {{.NFTProductName}}, AllDay from 0x{{.NFTContractAddress}}
+import NFTStorefront from 0x{{.NFTStorefrontV1ContractAddress}}
+
+/// Transaction facilitates the purchase of listed NFT.
+/// It takes the storefront address, listing resource that need
+/// to be purchased & a address that will takeaway the commission.
+///
+/// Buyer of the listing (,i.e. underling NFT) would authorize and sign the
+/// transaction and if purchase happens then transacted NFT would store in
+/// buyer's collection.
+
+transaction() {
+    let paymentVault: @{FungibleToken.Vault}
+    let {{.NFTProductName}}Collection: &{NonFungibleToken.CollectionPublic}
+    let storefront: &NFTStorefront.Storefront
+    let listings: [&{NFTStorefront.ListingPublic}]
+
+    prepare(universalDucPayer: auth(Storage, Capabilities) &Account) {
+        let sellerAddress: Address = 0x{{.StorefrontAddress}}
+        let buyerAddress: Address = 0x{{.RecipientAddress}}
+        let listingIds: [UInt64] = [{{.ListingIds}}]
+        let buyer = getAccount(buyerAddress)
+
+        assert(sellerAddress != buyerAddress, message : "Buyer and seller can not be same")
+        // Access the storefront public resource of the seller to purchase the listing.
+        self.storefront = getAccount(sellerAddress)
+            .capabilities.borrow<&NFTStorefront.Storefront>(
+                NFTStorefront.StorefrontPublicPath
+            )
+            ?? panic("Could not borrow Storefront from provided address")
+
+        var salePrice: UFix64 = 0.0
+        self.listings = []
+        for listingID in listingIds {
+            let listing = self.storefront.borrowListing(listingResourceID: listingID)
+                ?? panic("No Listing with that ID in Storefront")
+            self.listings.append(
+                listing
+            )
+            salePrice = salePrice + listing.getDetails().salePrice
+        }
+
+        // Borrow a provider reference to the buyers vault
+		let provider = universalDucPayer.storage.borrow<auth(FungibleToken.Withdraw) &DapperUtilityCoin.Vault>(from: /storage/dapperUtilityCoinVault)
+		?? panic("Cannot borrow DUC vault from buyer account storage")
+
+        // withdraw the purchase tokens from the vault
+        self.paymentVault <- provider.withdraw(amount: salePrice)
+
+        // Access the buyer's NFT collection to store the purchased NFT.
+        self.{{.NFTProductName}}Collection = buyer.capabilities.borrow<&{NonFungibleToken.CollectionPublic}>({{.NFTProductName}}.CollectionPublicPath)
+        ?? panic("Could not borrow Storefront from provided address")
+
+    }
+
+    execute {
+        // Purchase the NFTs
+        for listing in self.listings {
+            let listingSalePrice: UFix64 = listing.getDetails().salePrice
+            let listingPaymentVault <-self.paymentVault.withdraw(amount: listingSalePrice)
+            let item <- listing.purchase(
+                payment: <-listingPaymentVault
+            )
+
+            self.{{.NFTProductName}}Collection.deposit(token: <-item)
+        }
+        destroy self.paymentVault
+    }
+}

utils/parse_cadence_template.go

@@ -0,0 +1,68 @@
+package utils
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+)
+
+func getQuotedAddressRegexExpressionReplacer(contractName string) string {
+	const regexPattern = `"(?:(?:\./|(?:\.\./)+)?(?:[a-zA-Z0-9_\-]+/)*%s(\.cdc)?)"`
+	return fmt.Sprintf(regexPattern, contractName)
+}
+
+func getRegexExpressionReplacer(contractName string) string {
+	const regexPattern = `%s`
+	return fmt.Sprintf(regexPattern, contractName)
+}
+
+// ParseCadenceTemplateV3 parses the Cadence template and replaces placeholders
+func ParseCadenceTemplateV3(template []byte, data ...interface{}) ([]byte, error) {
+	if err := validateStruct(data); err != nil {
+		return nil, err
+	}
+	updatedTemplate, err := replacePlaceholders(string(template), data)
+	if err != nil {
+		return nil, err
+	}
+
+	return []byte(updatedTemplate), nil
+}
+
+// validateStruct ensures the provided data is a struct
+func validateStruct(data []interface{}) error {
+	for _, item := range data {
+		if item == nil {
+			continue
+		}
+		if reflect.ValueOf(item).Kind() != reflect.Struct {
+			return fmt.Errorf("data must be a struct")
+		}
+	}
+	return nil
+}
+
+// replacePlaceholders replaces the placeholders in the template with actual values
+func replacePlaceholders(template string, data []interface{}) (string, error) {
+	for index, item := range data {
+		if item == nil {
+			continue
+		}
+		val := reflect.ValueOf(item)
+		for i := 0; i < val.NumField(); i++ {
+			field := val.Type().Field(i)
+			fieldName := field.Name
+			fieldValue := val.Field(i).String()
+			if index == 0 {
+				replacer := regexp.MustCompile(getQuotedAddressRegexExpressionReplacer(fieldName))
+				template = replacer.ReplaceAllString(template, "0x"+fieldValue)
+			} else {
+				replacer := regexp.MustCompile(getRegexExpressionReplacer(fieldName))
+				template = replacer.ReplaceAllString(template, fieldValue)
+			}
+		}
+
+	}
+
+	return template, nil
+}