PrimalRaveVariantMintLimits

1access(all)
2contract PrimalRaveVariantMintLimits{ 
3	
4	// -----------------------------------------------------------------------
5	// Paths
6	// -----------------------------------------------------------------------
7	access(all)
8	let PrimalRaveVariantMintLimitsAdminStoragePath: StoragePath
9	
10	// -----------------------------------------------------------------------
11	// Contract Events
12	// -----------------------------------------------------------------------
13	access(all)
14	event AdminSetVariantMintLimit(variantId: UInt64, variantMintLimit: UInt64)
15	
16	access(all)
17	event AdminResourceCreated(uuid: UInt64, adminAddress: Address)
18	
19	access(all)
20	event AddressVariantMintsIncremented(
21		address: Address,
22		variantId: UInt64,
23		oldValue: UInt64?,
24		newValue: UInt64
25	)
26	
27	// -----------------------------------------------------------------------
28	// Contract State
29	// -----------------------------------------------------------------------
30	// The maximum number of mints an address can mint for a given variant
31	// If maxMints is nil, unlimited mints allowed for variant
32	// {variantId: maxMints}
33	access(contract)
34	var variantMintLimits:{ UInt64: UInt64}
35	
36	// The number of mints an address has minted for a given variant
37	// {userAddress: {variantId: mints}}
38	access(contract)
39	var addressVariantMints:{ Address:{ UInt64: UInt64}}
40	
41	// The total number of variants
42	access(contract)
43	var numberOfVariants: UInt64
44	
45	// -----------------------------------------------------------------------
46	// Admin Resource
47	// -----------------------------------------------------------------------
48	access(all)
49	resource Admin{ 
50		access(all)
51		fun setVariantMintLimits(variantMintLimitsDict:{ UInt64: UInt64}){ 
52			let keys = variantMintLimitsDict.keys
53			let values = variantMintLimitsDict.values
54			while keys.length > 0{ 
55				let key = keys.removeFirst()
56				let value = values.removeFirst()
57				PrimalRaveVariantMintLimits.variantMintLimits[key] = value
58				emit AdminSetVariantMintLimit(variantId: key, variantMintLimit: value)
59			}
60		}
61		
62		access(all)
63		fun setVariantMintsForAddress(address: Address, variantId: UInt64, numberOfMints: UInt64){ 
64			if let variantMintsByAddress:{ UInt64: UInt64} =
65				PrimalRaveVariantMintLimits.addressVariantMints[address]{ 
66				variantMintsByAddress[variantId] = numberOfMints
67				PrimalRaveVariantMintLimits.addressVariantMints[address] = variantMintsByAddress
68			} else{ 
69				// If variantMintsByAddress is nil, then address hasn't minted any variants yet, create a new entry
70				PrimalRaveVariantMintLimits.addressVariantMints[address] ={ variantId: numberOfMints}
71				return
72			}
73		}
74		
75		access(all)
76		fun setNumberOfVariants(numberOfVariants: UInt64){ 
77			PrimalRaveVariantMintLimits.numberOfVariants = numberOfVariants
78		}
79		
80		init(adminAddress: Address){ 
81			emit AdminResourceCreated(uuid: self.uuid, adminAddress: adminAddress)
82		}
83	}
84	
85	// -----------------------------------------------------------------------
86	// Helpers
87	// -----------------------------------------------------------------------
88	// Checks if an address can mint a variant
89	access(all)
90	fun checkAddressCanMintVariant(address: Address, variantId: UInt64): Bool{ 
91		pre{ 
92			variantId <= self.numberOfVariants:
93				"Variant ID must be less than or equal to the number of variants"
94		}
95		let variantMintLimit: UInt64? = self.variantMintLimits[variantId]
96		if variantMintLimit == nil{ 
97			return true
98		}
99		let variantMintsByAddress:{ UInt64: UInt64}? = self.addressVariantMints[address]
100		if variantMintsByAddress == nil{ 
101			return true
102		}
103		if let variantMintsByAddress:{ UInt64: UInt64} = variantMintsByAddress{ 
104			let mints = variantMintsByAddress[variantId]
105			if mints == nil{ 
106				return true
107			}
108			return mints! < variantMintLimit!
109		}
110		return false
111	}
112	
113	// Increments the number of mints an address has minted for a given variant
114	access(all)
115	fun incrementVariantMintsForAddress(address: Address, variantId: UInt64){ 
116		if let variantMintsByAddress:{ UInt64: UInt64} = self.addressVariantMints[address]{ 
117			// Get the number of mints for the variant
118			let mints = variantMintsByAddress[variantId]
119			// If the address hasn't minted the variant yet, create a new entry
120			if mints == nil{ 
121				variantMintsByAddress[variantId] = 1
122				self.addressVariantMints[address] = variantMintsByAddress
123			} else{ 
124				// Increment the number of mints for the variant
125				let newMintsValue = mints! + 1
126				variantMintsByAddress[variantId] = newMintsValue
127				self.addressVariantMints[address] = variantMintsByAddress
128			}
129		} else{ 
130			// If variantMintsByAddress is nil, then address hasn't minted any variants yet, create a new entry
131			self.addressVariantMints[address] ={ variantId: 1}
132			return
133		}
134	}
135	
136	// -----------------------------------------------------------------------
137	// Public Utility Functions
138	// -----------------------------------------------------------------------
139	access(all)
140	fun getVariantMintLimits():{ UInt64: UInt64}{ 
141		return self.variantMintLimits
142	}
143	
144	access(all)
145	fun getAllVariantMints():{ Address:{ UInt64: UInt64}}{ 
146		return self.addressVariantMints
147	}
148	
149	access(all)
150	fun getAllVariantMintsForAddress(address: Address):{ UInt64: UInt64}?{ 
151		return self.addressVariantMints[address]
152	}
153	
154	access(all)
155	fun getVariantMintsForAddress(address: Address, variantId: UInt64):{ UInt64: UInt64}?{ 
156		if let variantMintsByAddress:{ UInt64: UInt64} = self.addressVariantMints[address]{ 
157			let mints = variantMintsByAddress[variantId]
158			if mints == nil{ 
159				return nil
160			}
161			return{ variantId: mints!}
162		}
163		return nil
164	}
165	
166	// returns {variantId: {mints | limit: value}}
167	access(all)
168	fun getVariantMintsAndLimitsForAddress(address: Address):{ UInt64:{ String: UInt64?}}{ 
169		var i: UInt64 = 0
170		let ret:{ UInt64:{ String: UInt64?}} ={} 
171		while i < self.numberOfVariants{ 
172			i = i + 1
173			// Set the mint limit for the variant
174			let variantMintLimits = self.variantMintLimits
175			let limit = variantMintLimits[i]
176			ret[i] ={ "limit": limit}
177			
178			// Get variant mints dictionary
179			let variantMintsForAddress = self.getAllVariantMintsForAddress(address: address)
180			
181			// If the address hasn't minted any variants yet, mints is 0 for this variant
182			if variantMintsForAddress == nil{ 
183				ret[i] ={ "mints": 0, "limit": limit}
184				continue
185			}
186			
187			// Get the number of mints for this variant
188			let variantMints = (variantMintsForAddress!)[i]
189			if variantMints == nil{ 
190				ret[i] ={ "mints": 0, "limit": limit}
191				continue
192			} else{ 
193				ret[i] ={ "mints": variantMints, "limit": limit}
194			}
195		}
196		return ret
197	}
198	
199	// -----------------------------------------------------------------------
200	// Contract Init
201	// -----------------------------------------------------------------------
202	init(){ 
203		self
204			.PrimalRaveVariantMintLimitsAdminStoragePath = /storage/PrimalRaveVariantMintLimitsAdminStoragePath
205		self.variantMintLimits ={} 
206		self.addressVariantMints ={} 
207		self.numberOfVariants = 8
208		self.account.storage.save(
209			<-create Admin(adminAddress: self.account.address),
210			to: self.PrimalRaveVariantMintLimitsAdminStoragePath
211		)
212	}
213}
214