R2F0ZS5pbyBBTUEgbWV0IENoYWlucG9ydCAtIExhYXQgamUgbWV0IMOpw6luIGtsaWsgdHVzc2VuIGtldGVucyBzcHJpbmdlbg==

<p><img src="https://gimg2.gateimg.com/image/article/1675754748IMG_20230207_133609.jpg" alt=""><br><strong>Tijd: 30 september 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hosted een AMA (Vraag-Me-Alles) sessie met de CMO van Chainport, Maximiliano Stochyk in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Officiële Website: <a href="http://chainport.io/" rel="nofollow noopener noreferrer" target="_blank">http://chainport.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/chain_port</a></strong><br><strong>Volg Chainport op <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/chainport" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong></p>
<p><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16757549291.jpg" alt=""><br><strong>Maximiliano Stochyk - CMO van Chainport</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio469381"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20jezelf20voorstellen20aan20onze20community728756"><a name="Q1: Kun je jezelf voorstellen aan onze community?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je jezelf voorstellen aan onze community?</h3><p><strong>Maximiliano</strong>: Hey, ik ben Maximiliano, Head of Marketing bij ChainPort. Ik ben begonnen met investeren in Crypto in 2014.</p>
<h3 id="h3-Q220Kunt20u20ons20in203520zinnen20kort20vertellen20wat20ChainPort20is767577"><a name="Q2: Kunt u ons in 3-5 zinnen kort vertellen wat ChainPort is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons in 3-5 zinnen kort vertellen wat ChainPort is?</h3><p><strong>Maximiliano</strong>: ChainPort is een blockchain-brug van de volgende generatie met een harde beveiliging die je in staat stelt om met één klik over ketens te springen.<br><img src="https://gimg2.gateimg.com/image/article/16757551152.png" alt=""><br>Het levert vandaag de belofte van volledige interoperabiliteit tussen blockchains en doet dit in een eenvoudige veilige interface.</p>
<h3 id="h3-Q320Laten20we20nu20praten20over20de20mijlpalen20die20je20tot20nu20toe20hebt20bereikt20en20over20je20aankomende20plannen574762"><a name="Q3: Laten we nu praten over de mijlpalen die je tot nu toe hebt bereikt en over je aankomende plannen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Laten we nu praten over de mijlpalen die je tot nu toe hebt bereikt en over je aankomende plannen?</h3><p><strong>Maximiliano</strong>: ChainPort is een van de grootste bruggen in de ruimte op basis van TVL op DefiLlama.com, we hebben veel geweldige dingen bereikt in het afgelopen jaar sinds we zijn gelanceerd in juni 2021!</p>
<p>We ondersteunen momenteel meer dan 9 chains, waaronder Ethereum, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain, Avalanche, Polygon, Fuse, Fantom, Moonriver, Aurora en Dogechain!</p>
<p>Onze TVL staat op ongeveer $70M, maar met een ATH van bijna $500M, is onze volume aanzienlijk en bedraagt meer dan $615M in de afgelopen maanden, wat geweldig is!</p>
<p>We zijn erin geslaagd om adoptie te krijgen en we zijn nog maar net begonnen, er komen de komende maanden grote updates, waaronder Stablecoin-ondersteuning, nieuwe ketens, ChainPort privébewaarder en meer!</p>
<h3 id="h3-Q420Kun20je20je20product20en20de20functies20ervan20uitleggen20aan20onze20community26039"><a name="Q4: Kun je je product en de functies ervan uitleggen aan onze community?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je je product en de functies ervan uitleggen aan onze community?</h3><p><strong>Maximiliano</strong>: Fondssegregatie - Wij zijn de enige volledig bewarende brug in de ruimte, we ontdekten dat dit de beste manier is om te gaan nadat we hebben ontdekt dat gedecentraliseerde bruggen voorlopig niet te vertrouwen zijn vanwege de technologie die betrokken is bij het veilig bedienen van een brug.</p>
<p>Snelheid - We zijn in staat om elk token van de ene keten naar de andere over te zetten binnen 3 minuten, we zijn de snelste brug in de ruimte.</p>
<p>Live Menselijke Ondersteuning - Wij bieden ondersteuning voor alle projecten/gemeenschappen die gebruik maken van Chainport, eigenlijk live menselijke ondersteuning, dus als een gebruiker problemen heeft met het overzetten, kunnen ze rechtstreeks contact met ons opnemen.<br><img src="https://gimg2.gateimg.com/image/article/16757551513.png" alt=""><br>Permissionless - Geen noodzaak om te betalen voor een vermelding, goedkeuring te krijgen, etc… iedereen kan komen met hun token en het overzetten naar een van onze ondersteunde ketens, gratis. Alleen gas kosten.</p>
<h3 id="h3-Q520PORTX20is20hier20Kun20je20ons20meer20vertellen20over20je20eigen20token440772"><a name="Q5: PORTX is hier. Kun je ons meer vertellen over je eigen token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: PORTX is hier. Kun je ons meer vertellen over je eigen token?</h3><p><strong>Maximiliano</strong>: Ja, dus PORTX is onze inheemse token <a href="https://chainport.io/token" rel="nofollow noopener noreferrer" target="_blank">https://chainport.io/token</a></p>
<p>We hebben vorige week gelanceerd! Je kunt PORTX krijgen op Gate.io</p>
<p>ChainPort’s inheemse utility token is de PORTX-token, het is centraal voor het ecosysteem van ChainPort en lange termijn duurzaamheid, en vertegenwoordigt eenheid van waarde en een medium van uitwisseling dat op vele manieren kan worden gebruikt.</p>
<p>Ik nodig iedereen uit om zich aan te sluiten bij onze TG-gemeenschap om het laatste nieuws te lezen @chainport en <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/chain_port</a></p>
<p>Omdat we een brug zijn, zullen we worden vermeld op alle belangrijke DEXs op verschillende ketens en ook op CEX-lijsten!</p>
<p>We hebben ze niet allemaal aangekondigd, dus blijf de komende dagen opletten!</p>
<p>Geweldig nieuws komt eraan en je kunt ook ons ChainPort News kanaal volgen hier: t.me/chainport_news</p>
<h3 id="h3-Q620Wat20zijn20de20belangrijkste20voordelen20van20het20langdurig20vasthouden20van20PORTX792216"><a name="Q6: Wat zijn de belangrijkste voordelen van het langdurig vasthouden van PORTX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Wat zijn de belangrijkste voordelen van het langdurig vasthouden van PORTX?</h3><p><strong>Maximiliano</strong>: Vergoedingverdeling - ChainPort’s vergoedingsmechanisme zorgt voor langdurige duurzaamheid voor een cross-chain brug. Het mechanisme verandert ChainPort en de PORTX-token in feite in een ecosysteem met prikkels voor houders en cryptoprojecten. Door ChainPort om te vormen tot een volwaardig ecosysteem, wordt het de facto de brug van keuze voor wie tokens wil overzetten.</p>
<p>Basisportkosten - tot 95% omgezet in PORTX</p>
<p>20% Projectbeloning - Een doorlopende stimulans voor projecten om ChainPort tot hun officiële brug naar keuze te maken. Kan worden geclaimd in PORTX.</p>
<p>20% Participatiebeloningen - Voor elke portefeuille die wordt gemaakt, ontvangt de gebruiker punten die hen zullen belonen met PORTX.</p>
<p>20% Verwijzings-/Affiliatiebeloningen - verdeeld onder in aanmerking komende partijen die het overgezette token hebben doorverwezen, of poorten die zijn gemaakt vanuit een geïntegreerde ChainPort-modal of via de API.</p>
<p>15% PORTX Buyback - Een deel hiervan zal worden gebruikt om PORTX op de markt terug te kopen. Een deel of het geheel van dit bedrag kan worden gebruikt om tokens uit liquiditeit te verwijderen (verbranden).</p>
<p>10% Liquiditeit - Toegevoegd op de verschillende DEXs als liquiditeit voor altijd. De helft in PORTX en de helft in stablecoins.</p>
<p>10% APY voor Stakers - Dit gedeelte beloont PORTX-stakers op het officiële ChainPort-fee manager contract.</p>
<p>5% ChainPort Toekomstige Ontwikkeling - zal worden gebruikt voor de toekomstige ontwikkeling van ChainPort.</p>
<h3 id="h3-Q720Met20betrekking20tot20de20Routekaart20kunt20u20ons20alstublieft20op20de20hoogte20stellen20van20de20volgende20mijlpalen20in20de20Routekaart20die20u20heeft20voor20de20komende20maanden638703"><a name="Q7: Met betrekking tot de Routekaart, kunt u ons alstublieft op de hoogte stellen van de volgende mijlpalen in de Routekaart die u heeft voor de komende maanden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Met betrekking tot de Routekaart, kunt u ons alstublieft op de hoogte stellen van de volgende mijlpalen in de Routekaart die u heeft voor de komende maanden?</h3><p><strong>Maximiliano</strong>: We werken aan veel nieuwe ketens. We hebben net Dogechain, Aurora geïntroduceerd als EVM en we zullen <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> als onze eerste non-evm-keten hebben in de komende weken. Dit is een grote mijlpaal, dit zou moeten gebeuren na de Cardano-fork!</p>
<p>Volgende zullen we doorgaan met het toevoegen van meer EVM- ketens en niet-EVM- ketens zoals <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> en meer!</p>
<p>Je kunt onze routekaart hier controleren: <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">https://twitter.com/chain_port/</a><a href="https://twitter.com/chain_port/<a href=&quot;https://www.gate.io/trade/SNT_USDT&quot; target=&quot;_blank&quot;>Status</a>/1570093736150941697" rel="nofollow noopener noreferrer" target="_blank">Status</a>/1570093736150941697</p>
<h3 id="h3-Q820Wie20zijn20jullie20grootste20partners20en20investeerders545451"><a name="Q8: Wie zijn jullie grootste partners en investeerders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Wie zijn jullie grootste partners en investeerders?</h3><p><strong>Maximiliano</strong>: ChainPort heeft meer dan $14M opgehaald in private en publieke rondes, geleid door DAO Maker, Shima Capital en LD Capital. De vroege investeerders in het project omvatten meer dan 50 toonaangevende VCs die zich richten op blockchain. Investeerders zijn onder andere ZBS Capital, Master Ventures, Double Peak, Halvings Cap, Metrix Capital, Fundamental Labs, Tribe Capital, Poolz, Kairon Labs, Maven Capital, Lucid Blue, CoinX, Ghaf Capital, Existential Capital en anderen.</p>
<p>Je kunt hier meer vinden: <a href="https://www.chainport.io/blog/chainport-raised-14m-in-private-public-rounds-to-expand-its-cross-chain-bridge" rel="nofollow noopener noreferrer" target="_blank">https://www.chainport.io/blog/chainport-raised-14m-in-private-public-rounds-to-expand-its-cross-chain-bridge</a></p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<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 op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>