TG91aXMgVnVpdHRvbiBnYWF0IGRpZ2l0YWFsOiBJY29uaXNjaGUga29mZmVyIG51IGVlbiBXZWIzIHZlcnphbWVsb2JqZWN0

2023-06-28, 09:36

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR99026"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Louis Vuitton heeft zijn Via Treasure Trunk collectie gelanceerd.</p>
<p>Via Treasure Trunks geven hun houders toegang tot de digitale activa en diensten van Louis Vuitton.</p>
<p>Mensen kunnen de Soulbound-tokens (SBT’s) die Louis Vuitton aanbiedt aan zijn klanten niet overdragen of verkopen.</p>
<h2 id="h2-Introductie373959"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Web 3 blijft zich uitbreiden met veel bedrijven uit verschillende sectoren die zich bij de strijd aansluiten. De gaming, fashion, luchtvaart en accommodatie sectoren blijven hun aanwezigheid op de blockchain vergroten. Louis Vuitton, het populaire Franse luxehuis, heeft nieuwe digitale producten geïntroduceerd om zijn klanten te betrekken en zijn merk te promoten. In dit artikel verkennen we Louis Vuitton’s recente NFT-collectie.</p>
<h2 id="h2-De20modeindustrie20leidt20de20Phygitalrevolutie447435"><a name="De mode-industrie leidt de Phygital-revolutie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De mode-industrie leidt de Phygital-revolutie</h2><p>Recente ontwikkelingen in de mode-industrie tonen aan dat verschillende grote bedrijven in de sector deel uitmaken van de phygital revolutie, omdat ze streven naar verbetering van hun inspanningen op het gebied van klantbetrokkenheid. Zeker, <a href="/web3" target="_blank" class="blog_inner_link">web3</a> luxe merken kunnen gebruik maken van NFT-mode om contact te leggen met hun wereldwijde klanten en hun aanbiedingen te promoten.</p>
<p>De phygital revolutie betekent dat deze merken zowel de digitale als fysieke versies van hun populaire producten kunnen leveren. De groeiende verbinding tussen de fysieke wereld en het digitale universum heeft grote bedrijven verleid om te investeren in innovatie en ontwikkeling om nieuwe producten en diensten te creëren die het leven van hun klanten transformeren en meer inkomsten genereren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2659/%E8%A7%A3%E9%94%81%E6%9C%AA%E6%9D%A5-%E6%8E%A2%E7%B4%A2web1-web2%E5%8F%8Aweb3%E5%85%A5%E5%8F%A3" target="_blank">Het ontgrendelen van de toekomst: Het verkennen van de ingangen naar Web1, Web2 en Web3</a></p>
<p>Zoals we hebben opgemerkt, is Louis Vuitton een van die bedrijven die een nieuwe wending heeft gegeven aan het web3-ecosysteem. Zo heeft het bijvoorbeeld de soulbound tokens (SBTs) ontworpen, ontwikkeld en gelanceerd, waarmee de houders toegang hebben tot de unieke creaties van het designhuis Maison Louis Vuitton.</p>
<p>In feite is Louis Vuitton een <a href="https://www.gate.io/learn/articles/what-is-the-metaverse/39" target="_blank">metaverse</a> modemerk dat vooruitgaat met fysieke producten na de lancering van VIA Treasure Trunk, een NFT van zijn bekende LV-koffer. Deze NFT geeft zijn houders open toegang tot verschillende beperkte editie producten en diensten zoals unieke meeslepende ervaringen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16879448284191687944709_.pic.jpg" alt=""><br>Louis Vuitton’s LV Soft Trunk - Stockx</p>
<p>Onlangs kondigde Louis Vuitton Web3 de release aan van een ultralimiet NFT-collectie ter waarde van €39.000, ongeveer $41.600 per stuk. Deze exclusieve NFT-collectie, een paar honderd stuks, zal verkocht worden als ‘soulbound’, wat betekent dat de eigenaars ze niet aan andere mensen kunnen overdragen. Hoewel de eigenaars ze niet aan anderen kunnen verkopen, geven deze NFT’s hen het recht om andere digitale items te ‘maken’ die ze kunnen verhandelen.</p>
<p>Verkennen <a href="https://www.gate.io/nft/collection/16778/Metawear-Fashion-Dome" target="_blank">de Metawear Fashion collectie</a></p>
<h2 id="h2-Waarom20heeft20de20Treasure20Trunks20zoveel20waarde771260"><a name="Waarom heeft de Treasure Trunks zoveel waarde?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft de Treasure Trunks zoveel waarde?</h2><p>Deze NFT’s zijn gebaseerd op de populaire en gekoesterde LV Trunk, een kenmerkende koffer in trunks-stijl, die sinds 1858 deel uitmaakt van de merkreputatie sinds de lancering op de markt. Zijn unieke stapelbare structuur en vierkante vorm onderscheiden het van de koffers met afgeronde bovenkant die in de jaren 1800 en begin 1900 gangbaar waren. Ook is de LV-trunk een product van meesterschap en vakmanschap, getoond door het iconische LV-monogrampatroon en grote aandacht voor unieke details.</p>
<p>De LV Trunk is zowel functioneel als luxueus en biedt een stijlvolle en veilige manier om persoonlijke bezittingen te vervoeren. Daarom vertegenwoordigen zowel de echte LV Trunk als de Treasure Trunks het erfgoed van het merk en de toewijding van het bedrijf om tijdloze luxe te bieden.</p>
<h2 id="h2-Voordelen20van20de20Treasure20Trunk34761"><a name="Voordelen van de Treasure Trunk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voordelen van de Treasure Trunk</h2><p>De Treasure Trunk is een belangrijk symbool van web3 in de mode, waarmee de houders fysieke replica’s van de digitale Treasure Trunks kunnen krijgen. Ze verlenen ook rechten aan hun houders om toegang te krijgen tot de beperkte producten van het merk die het gedurende het jaar op regelmatige tijdstippen zal uitbrengen.</p>
<p>Deze collectie, die onderdeel uitmaakt van Via, het project van Louis Vuitton, heeft als doel om klanten te verbinden met de nieuwste productaanbiedingen en een unieke, meeslepende ervaring. De houders van NFT-mode krijgen digitale sleutels waarmee ze toegang krijgen tot Louis Vuitton’s VIP-aanbiedingen. Sterker nog, de sleutels geven hun houders exclusieve toegang tot het digitale verzamelportaal van Louis Vuitton.</p>
<p>Evenzo biedt Treasure Trunks, net als andere niet-vervangbare tokens, de algemene voordelen van NFT’s. Het bezitten van digitale activa zoals Treasure Trunks geeft hetzelfde gevoel als het bezitten van fysieke goederen. Dit komt doordat de blockchain onveranderlijke, transparante en voor iedereen toegankelijke bewijs van eigendom van zowel digitale als fysieke activa biedt. Daarom omarmen web3 luxe merken de ‘phygital’ evolutie - de combinatie van digitale en fysieke werelden.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1287/Meta-sets-to-open-clothing-store-for-avatar-in-its-metaverse" target="_blank">Meta stelt kledingwinkel voor avatar in zijn metaverse open</a></p>
<h2 id="h2-Hoe20kan20ik20de20Via20Treasure20Trunk20van20Louis20Vuitton20verkrijgen828124"><a name="Hoe kan ik de Via Treasure Trunk van Louis Vuitton verkrijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kan ik de Via Treasure Trunk van Louis Vuitton verkrijgen?</h2><p>Klanten van Louis Vuitton kregen op 8 juni 2023 toegang tot de schatkist Trunk NFT’s. Deze metaverse mode NFT is echter alleen toegankelijk voor mensen die in het Verenigd Koninkrijk, Duitsland, de Verenigde Staten, Canada, Frankrijk, Australië en Japan wonen.</p>
<p>Allereerst moeten de klanten hun accounts openen op de website van Louis Vuitton. Opmerkelijk is dat de eerste groep klanten die zich op de wachtlijst hadden geregistreerd op 14 juni werden uitgenodigd voor een privévoorbeeldpagina van VIA. Als gevolg daarvan kochten de geselecteerde genodigden hun Treasure Trunk op 16 juni.</p>
<p>Het is momenteel niet duidelijk wanneer het bedrijf de volgende lading NFT’s zal uitbrengen. Aangezien er de afgelopen jaren een toename is geweest in web3-adoptie, stelt Louis Vuitton zijn klanten in staat om te betalen voor de digitale verzamelitems met behulp van cryptocurrencies.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/463/the-comparison-and-application-of-the-metaverse-and-web-3.0" target="_blank">De Vergelijking en Toepassing van De Metaverse en Web 3.0</a></p>
<h2 id="h2-Luxe20merken20omarmen20Web3203244"><a name="Luxe merken omarmen Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Luxe merken omarmen Web3</h2><p>De mode-industrie past zich aan aan web3 omdat het geweldige kansen voor hen creëert. Veel luxe merken gebruiken de blockchaintechnologie om NFT’s te maken van hun beste kledingstukken, hoodies, hoeden en tassen, onder andere. Sommigen van hen vestigen virtuele kantoren en winkels in de metaverse. Gucci, Prada, <a href="https://www.gate.io/blog_detail/1685/how-are-institutional-investors-participating-in-crypto" target="_blank">Nike</a> en <a href="https://www.gate.io/blog_detail/637/d-g-to-launch-nfts-on-polygon-marketplace" target="_blank">Dolce &amp; Gabbana</a> zijn enkele voorbeelden van luxe merken die al gebruik maken van web3 om hun producten te promoten en hun merk te positioneren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/958/nike-unveils-crypto-kicks-an-ethereum-based-metaverse-sneakers." target="_blank">Nike onthult Crypto Kicks, Ethereum-gebaseerde metaverse sneakers</a></p>
<h2 id="h2-Conclusie703891"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De vooruitgang van web3-technologie heeft geleid tot de onderlinge verbondenheid van het digitale universum en de fysieke wereld. Als gevolg hiervan hebben sommige activa die in de fysieke wereld bestaan digitale replica’s. Louis Vuitton heeft zijn LV-koffer getokeniseerd, waardoor klanten zowel de fysieke als de digitale versie kunnen verwerven. De zielgebonden token van Louis Vuitton geeft zijn houders exclusief recht op toegang tot zijn digitale portaal waar ze meer virtuele activa kunnen verwerven.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>