Z2F0ZUxpdmUgQU1BIFJlY2FwLUhhc2hQYWNr

2024-06-20, 04:08

<p><img src="https://gimg2.gateimg.com/image/article/1718856360pack.png" alt=""></p>
<h2 id="h2-Q120Wat20zijn20de20geplande20hulpprogrammas20voor20PACK377205"><a name="Q1. Wat zijn de geplande hulpprogramma’s voor PACK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Wat zijn de geplande hulpprogramma’s voor PACK?</h2><p>In de kern is $PACK een loyaliteitstoken dat is ontworpen om gebruikers te belonen voor hun deelname aan het HashPack-platform en voor het verbinden met ons NFT- en DeFi-ecosysteem.</p>
<p>Voor deze AMA kunnen we vier belangrijke functies van $PACK delen:<br>(1)PackBack Rewards<br>De eerste functie van PACK die beschikbaar zal zijn bij de lancering van de token is ons PackBack beloningssysteem. Vanaf dag één zullen gebruikers die de in-wallet swap-functionaliteit binnen HashPack gebruiken ook PACK als beloning ontvangen.</p>
<p>(2)$PACK Store Aankopen<br>Het tweede nut van PACK dat we gepland hebben, zijn exclusieve PACK aankopen in de HashPack Store. Met de komst van $PACK in de Store streven we ernaar om de verscheidenheid aan dingen die in de winkel worden aangeboden uit te breiden, terwijl we het doel behouden om de gebruikerservaring te verbeteren door de items die erin staan.</p>
<p>(3)$PACK Governance<br>De derde functie van PACK zal de mogelijkheid zijn voor houders om deel te nemen aan governance. Voor de duidelijkheid, deze functie zal worden uitgerold na de lancering en zal dus niet onmiddellijk beschikbaar zijn. PACK-houders en HashPack Concierge Collectible-houders kunnen deelnemen aan governance en stemmen over HashPack-initiatieven.</p>
<p>(4)$PACK Samenwerkingen<br>HashPack is altijd een team geweest dat gericht is op de gemeenschap. We hebben altijd benadrukt hoe belangrijk samenwerking met gemeenschapsprojecten is en de lancering van $PACK biedt ons spannende kansen. De eerste $PACK-samenwerking die we in de toekomst zullen zien, is de integratie van $PACK in het Earthlings-spel.</p>
<p>Onlangs zijn we ook een partnerschap aangegaan met SentX, <a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">Hedera</a>‘s toonaangevende NFT-marktplaats. U kunt uw NFT’s verhandelen op SentX met $PACK! Het is onze visie om $PACK wijdverbreid te gebruiken in het hele ecosysteem.</p>
<p>Dit is nog maar het begin. We hebben nog veel meer gepland voor de toekomst van $PACK!</p>
<h2 id="h2-Q220Wat20zijn20de20tokenomics20van20PACK56830"><a name="Q2. Wat zijn de tokenomics van PACK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Wat zijn de tokenomics van PACK?</h2><p>De maximale voorraad $PACK is 1 miljard tokens, die allemaal zullen worden geslagen tijdens het Token Generation Event (TGE) of ‘genesis’. Bij genesis zullen 800 miljoen tokens worden vergrendeld in door HashPack beheerde vestingcontracten en zullen er 200 miljoen in omloop komen. De vergrendelde tokens zullen volgens het vooraf bepaalde vestingsschema hieronder worden uitgegeven gedurende de komende zes jaar.</p>
<h2 id="h2-Q320Wat20is20de20huidige20circulerende20voorraad286742"><a name="Q3. Wat is de huidige circulerende voorraad?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3. Wat is de huidige circulerende voorraad?</h2><p>De initiële circulerende voorraad is 200 miljoen PACK.</p>
<p>Wat is de positie van HashPack binnen het Hedera-ecosysteem?<br>HashPack Wallet is de interface naar het Hedera-ecosysteem. Na de lancering van onze MVP in 2020 hebben we de eerste ondertekeningsoplossing op <a href="/price/hedera-hbar" target="_blank" class="blog_inner_link">Hedera</a> genaamd HashConnect gebouwd, wat het hele DeFi- en NFT-ruimte op gang bracht. Door onze inspanningen zagen we marktplaatsen, DEXes, stakingplatforms en vele andere gebruiksmogelijkheden tot leven komen op Hedera, wat in een paar maanden tijd een TVL van meer dan $100 miljoen USD heeft opgebouwd.</p>
<p>Voortbouwend op onze successen hebben we talloze functies uitgebracht en talloze projecten en teams ondersteund, alles met als doel DeFi en NFT’s op Hedera zo toegankelijk, leuk en veilig mogelijk te maken.</p>
<h2 id="h2-V420Wat20onderscheidt20HashPack20van20andere20portefeuilles397465"><a name="V4. Wat onderscheidt HashPack van andere portefeuilles?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4. Wat onderscheidt HashPack van andere portefeuilles?</h2><p>Het HashPack-team richt zich op het leveren van producten en diensten die voldoen aan de behoeften en problemen waarmee onze gemeenschap wordt geconfronteerd. We hebben altijd geprobeerd zoveel mogelijk waarde te bieden, terwijl we een gebruikerservaring leveren die concurreert met de besten in de branche.</p>
<p>Enkele van onze prestaties zijn:<br>(1) Gebouwd de eerste beveiligde dApp-verbinding bibliotheek, HashConnect, waardoor gebruikers veilig kunnen interacteren met dApps zonder hun privésleutels bloot te stellen aan Hedera.</p>
<p>(2) Heeft de NFT-metadatastandaarden (HIP-412) geschreven waarop het hele NFT-ecosysteem is gebouwd. HashPack blijft actief betrokken bij het HIP-proces en ondersteunt de ontwikkeling van het Hedera-platform.</p>
<p>(3)Geïntroduceerde Secure Trade, waardoor vertrouwensloze atomische peer-to-peer transacties mogelijk zijn voor elke combinatie van NFT’s en fungible tokens.</p>
<p>(4)Samengewerkt met veel community dApps en projecten, bewustzijn vergroten en tools ontwikkelen om de gebruikerservaring op Hedera eenvoudig en veilig te maken voor alle gebruikers.</p>
<p>(5)Geïntroduceerd tal van functies die zijn overgenomen door projecten en communityleden om de Web3-ervaring op Hedera te verbeteren.</p>
<p>(5) Diensten voor meer dan 95% van de maandelijkse actieve gebruikers in het Hedera-ecosysteem.</p>
<h2 id="h2-Q520Kunt20u20een20beetje20praten20over20de20geschiedenis20van20HashPack655966"><a name="Q5. Kunt u een beetje praten over de geschiedenis van HashPack?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5. Kunt u een beetje praten over de geschiedenis van HashPack?</h2><p>Het is bijna drie jaar geleden dat we aan onze reis begonnen zijn!</p>
<p>HashPack is ontstaan uit de gemeenschap. In maart 2021 ontmoetten de vier medeoprichters, May Chan, Jacob D’Rozario, Tyler Coté en Nick Hanna, elkaar op de beruchte Club HBAR Discord-server. Zes maanden later hebben we onze bètatest uitgevoerd en in oktober 2021 openbaar gelanceerd.</p>
<p>Onze visie vanaf dag één:<br>“HashPack is toegewijd aan het ontwikkelen van producten en diensten die wrijving verminderen en adoptie van het Hedera-netwerk stimuleren.”</p>
<p>Naarmate HashPack begon te groeien, hebben we rechtstreeks mensen aangenomen uit de Hedera-gemeenschap. We verwelkomden Marc Ugas Reinon, David Adele, Patrick Woo-Sam en SooYoung Kim om ons te helpen onze visie te realiseren. HashPack zou vandaag de dag niet zijn wat het is zonder hun hulp!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Team van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>