Rida på vågen Web 3.0

Utvecklaren Christophe Verdo pratar om onlinekursen ‘Mastering Web 3.0 with Waves’, som han nyligen har genomfört.

Berätta lite om dig själv. Vad fick dig att bli intresserad av denna kurs?

Jag har hållit på med webbprogrammering i cirka 15 år, huvudsakligen som frilansare.

När jag utvecklade en långsiktig registreringswebbapplikation för utvecklingsländer på uppdrag av en bankgrupp, stötte jag på utmaningen att integrera blockchain-certifiering i den. Vid den tidpunkten visste jag inte mycket om blockchain-certifiering, även om jag redan var intresserad av kryptotekniker - mest som investerare.

Det slutade med att denna funktion inte blev genomförd, men efter att ha funderat över att organisationer och banker är intresserade av en sådan lösning för sina applikationer, började jag undersöka frågan och snart lanserade jag projektet Signature Chain.

Jag har utvecklat dess beta-version, som redan är tillgänglig i huvudnätet. Vid den tiden fanns inte [programmeringsspråket Waves] Ride, och jag gjorde allt på det enklaste sättet, genom att använda överföringstransaktioner med inbäddad JSON. Men huvudsyftet var att lägga till mer avancerad funktionalitet efter lanseringen av Ride. Och det är den främsta anledningen till att jag gick med i kursen: nästa steg i projektets utveckling syftade till att skapa en decentraliserad applikation (dApp).

Vilka aspekter av kursen fann du enklast och vilka svårast?

Det enklaste var att vi hade gott om tid för alla uppgifter. Syftet med kursen är att lära sig något, inte att tävla med varandra. Förklaringarna var mycket tillgängliga, och illustrationerna var enkla, men uttömmande. Detta hjälpte till att visualisera och förstå olika ämnen.

När vi utförde uppgifterna uppmanades vi att tänka självständigt och ibland studera något på egen hand. Detta är det bästa sättet att lära sig något och förstå de idéer som diskuteras i klasserna.

Flera gånger förstod jag inte den teoretiska delen fullt ut förrän jag började skriva kod för att utföra uppgiften. Vi fick inte lov att göra ‘copy/paste’, all kod måste skrivas av oss själva, och det hjälpte också till förstå allt bättre.

Det svåraste var att frågorna i uppgiften med flera svarsalternativ inte alltid var tydliga. Min engelska är inte perfekt, och frågorna var skrivna av någon som inte är modersmålstalare, så ibland uppstod missförstånd.

Kanske kunde den del av kursen som handlar om orakler och NFT:er ha varit mer detaljerad. Men oavsett, huvudsyftet med kursen är att väcka intresse hos utvecklarna. För att helt förstå alla aspekter kommer man förstås behöva lägga ner tid på att experimentera och öva.

Berätta mer om lösningen som ni arbetade med under hela kursen – ‘Coupon Bazaar’? Kan vi också få se exempel på kod?

Ja, vi arbetade på ‘Coupon Bazaar’, det är en marknadsplats där folk kan sälja och köpa kuponger som ger rätt att köpa varor och tjänster till ett lägre pris. Varje kupong representeras av en digital tillgång som innebär en speciell rabatt från leverantören.

Det var nödvändigt att utveckla flera komponenter av applikationen. Först och främst behövdes ett system för registrering av leverantörer och hantering av kuponger. Sedan behövdes en verifieringsfunktion och möjlighet för användare att söka kuponger.

Under kursen la vi också till flera nya funktioner, inklusive ett röstningssystem och en funktion som gör det möjligt att verifiera och svarta listan leverantörer.

Först studerade vi skillnaden mellan smarta tillgångar, smarta konton och dApp-konton samt hur verifieringsfunktionerna fungerar. Verifieringsfunktionerna gör det möjligt att ändra det förvalda beteendet för ett konto. Som standard kontrollerar de transaktionssignaturer, men verifieringsfunktionen tillåter att ställa in andra "regler".

{-# STDLIB_VERSION 3 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}
let ownerPublicKey = base58'H8ndsHjBha6oJBQQx33zqbP5wi8sQP7hwgjzWUv3q95M'
@Verifier(tx)
func verify() = {
    match tx {
        case: SetScriptTransaction=>sigVerify(tx.bodyBytes, tx.proofs[0], ownerPublicKey)
        case: DataTransaction=>true
        case _ => false
    }
}

Sedan började vi lägga till kuponger. Vi använde en av de viktigaste funktionerna i dApp som gör att vi kan skriva data av alla typer till blockkedjan i form av nyckel-värde-par – datatransaktion. Vi kombinerade det med en ny transaktion, invokeScript, som används för att anropa en funktion i dApp utanför blockkedjan.

Typ av datatransaktioner som vi använde under kursens gång är att lägga till kuponger på marknadsplatsen:

letdatajson = {
    "title":        "t-shirt med, rösta 1",
    "coupon_price": 10000000,
    "old_price":    1000000000,
    "new_price":    100000000,
    "address":      "Universum",
    "description":  "Jag vill att du ska göra kärlek, inte krig, jag vet att du har hört det förut",
    "image":        "https://bit.ly/2EXTghg"
}
it('add item', asyncfunction(){
    letts = invokeScript({
       dApp: dappAddress,
           call:{
               function:"addItem",
               args:[
                    { type:"string", value: datajson.title },
                    { type:"integer", value: datajson.coupon_price },
                    { type:"string", value: JSON.stringify(datajson) }
               ]},
               payment: []
           }, accountSupplierSeed)
    lettx = awaitbroadcast(ts)
    awaitwaitForTx(tx.id)
})

För att bearbeta dessa data med addItem-funktionen och utveckla köp- och andra alternativ använde vi en anropbar funktion som användaren kan kalla utanför blockkedjan. Som ett resultat kan den utföra olika uppgifter, exempelvis initiera överföring av medel, lagra eller uppdatera data i dApp-lagringen etc.

Här är ett exempel på en anropbar funktion som används i funktionen addItem:

@Callable(i)
funcaddItem(title: String, price: Int, data: String) = {
    letsupplierAddress = toBase58String(i.caller.bytes)
    letitem = getKeyItem(supplierAddress, title)
    if( price <= 0) thenthrow("inköpsbeloppet kan inte vara mindre än varans pris")
    elseif( getValueItemSupplier(item) !=NONE ) thenthrow("en vara finns redan")
    else{
        WriteSet([
           DataEntry(getKeyItemSupplier(item), supplierAddress),
           DataEntry(getKeyItemPrice(item), price),
           DataEntry(getKeyItemData(item), data)
        ])
    }
}

Senare utvecklade vi ett röstningssystem som tillåter användare att rösta för att främja eller ta bort specifika produkter. För att förhindra extern påverkan på röstningsprocessen använder det en 'Commit-Reveal'-strategi.

Commit-fasen används för att samla in krypterade röster med hjälp av en hash-funktion och 'salt'.

Reveal-fasen används för att samla in krypterade röster och jämföra deras hashes.

Här är ett exempel på en anropbar funktion som används här:

@Callable(i)
funcvoteCommit(item: String, hash: String) = {
    letuser = toBase58String(i.caller.bytes)
    letcommits = getValueCommitsCount(item)
    letstatus = getValueItemStatus(item)
    if( commits >=VOTERS) thenthrow("max antal röstare har nåtts")
    elseif(getValueCommit(item, user) !=NONE) thenthrow("användaren har redan deltagit")
    elseif(getKeyItemSupplier(item) ==NONE) thenthrow("varan existerar inte")
    elseif(status !=NONE && status !=VOTING) thenthrow("röstning är inte möjlig")
    else{
        WriteSet([
           DataEntry(getKeyCommit(item, user), hash),
           DataEntry(getKeyCommitsCount(item), commits +1),
           DataEntry(getKeyItemStatus(item),if(commits ==VOTERS) thenREVEAL elseVOTING)
        ])
    }
}
>

Vad mer har du lärt dig från kursen?

Kursen inkluderade även tokenisering och icke-fungibla tokens (NFT) – tokens som representerar något unikt och därför inte är utbytbara.

Det sista lektionen handlade om oraklar. Eftersom blockkedjan inte kan ta emot data från den externa världen behöver vi oraklar för att skicka in dessa data.

För vår marknadsplats behövdes oraklar för att verifiera och, vid behov, svartlista en leverantör som till exempel inte accepterade en såld kupong.

Här är ett exempel:

funcgetExtValueItemWhiteListStatus(item:String) = {
    item +"_verifier_status"
}
 
letverifier = "3Mx9qgMyMhHt7WUZr6PsaXNfmydxMG7YMxv"
letVERIFIED = "verified"
letBLACKLISTED = "blacklist"
@Callable(i)
funcsetstatus(supplier: String, status: String) = {
    letaccount = toBase58String(i.caller.bytes)
    if( account !=verifier ) thenthrow("only oracle verifier are able to manage whitelist")
    elseif( status !=VERIFIED && status !=BLACKLISTED) thenthrow("wrong status")
    else{
        WriteSet([
           DataEntry(getExtValueItemWhiteListStatus(supplier), status)
        ])
    }
}

Vad var mest användbart för dig?

Den mest användbara delen var uppgifterna. Tack vare dem blev föreläsningsmaterialet tydligare, och de nya kunskaperna befästes genom trial and error. Den praktiska jobbet med IDE, utforskaren och oraklarna.

Hur planerar du att använda det du lärt dig i praktiken?

Från början förväntade jag mig att kursen skulle ta mitt projekt till en ny nivå. Idén var att nu skriva kod sign-web.app i RIDE. Den nuvarande versionen har redan funktioner för dokumentcertifiering, men tack vare RIDE kommer den att kunna förbättras avsevärt. Den nya versionen blir mer flexibel och lättförståelig, med fler funktioner, inklusive certifiering av elektroniska brev, avtal mellan flera parter osv.

Kursen gav också inspiration och jag fick många nya idéer. Jag är säker på att resultaten kommer att visas även i framtiden.

Källa: habr.com