O desenvolvedor Christophe Verdo fala sobre o curso online ‘’, que ele recentemente concluiu.
Fale um pouco sobre você. O que chamou sua atenção nesse curso?
Trabalho com desenvolvimento web há cerca de 15 anos, principalmente como freelancer.
Ao desenvolver um aplicativo web de registro de longo prazo para países em desenvolvimento a pedido de um grupo bancário, me deparei com a tarefa de integrar certificação em blockchain. Naquele momento, eu não sabia muito sobre certificação em blockchain, embora já tivesse interesse em tecnologias cripto – principalmente como investidor.
No final, essa funcionalidade não foi implementada, mas, pensando que organizações e bancos estavam interessados em tal solução para suas aplicações, comecei a estudar o assunto e logo lancei o projeto .
Desenvolvi sua versão beta, que já está disponível na rede principal. Naquela época, o [idioma de programação Waves] Ride ainda não existia, e eu fazia tudo da maneira mais simples, usando transações de transferência com JSON embutido. Mas o principal objetivo era adicionar funcionalidades mais avançadas após o lançamento do Ride. E essa foi a principal razão pela qual me juntei ao curso: a próxima fase de desenvolvimento do projeto previa a criação de um aplicativo descentralizado (dApp).
Quais aspectos do curso você achou mais fáceis e quais foram os mais desafiadores?
A parte mais fácil foi que tivemos tempo suficiente para todas as tarefas. O propósito do curso era aprender algo, e não competir entre nós. As explicações eram muito acessíveis, e as ilustrações – simples, mas abrangentes. Isso ajudou a visualizar e entender diferentes tópicos.
Ao realizar as tarefas, fomos incentivados a pensar independentemente e, por vezes, a estudar algo por conta própria. Essa é a melhor maneira de aprender algo e entender as ideias abordadas nas aulas.
Várias vezes, eu não compreendia completamente a parte teórica até começar a escrever código, completando a tarefa. Não era permitido fazer ‘copy/paste’, todo o código precisava ser escrito por conta própria, e isso também ajudou a entender melhor tudo.
O mais desafiador foi que as perguntas nas questões de resposta múltipla nem sempre eram claras. Meu inglês não é perfeito, e as perguntas foram escritas por alguém que não é nativo, o que ocasionou, às vezes, mal-entendidos.
Talvez a parte do curso dedicada a oráculos e NFTs pudesse ser mais detalhada. No entanto, a principal missão do curso é despertar o interesse dos desenvolvedores. Depois, para entender completamente todos os seus aspectos, será necessário, claro, gastar um tempo experimentando e praticando.
Pode contar mais sobre a solução na qual você trabalhou durante todo o curso – 'Coupon Bazaar'? Também poderíamos ver exemplos de código?
Sim, trabalhamos no 'Coupon Bazaar', que é um marketplace onde as pessoas compram e vendem cupons que dão direito a adquirir produtos e serviços a preços mais baixos. Cada cupom é apresentado como um ativo digital que implica um desconto especial do fornecedor.
Precisávamos desenvolver vários componentes do aplicativo. Primeiro, era necessário criar um sistema para registrar fornecedores e gerenciar cupons. Depois, precisávamos de uma função de verificação e a capacidade de os usuários pesquisarem cupons.
Durante o curso, também adicionamos várias novas funcionalidades, incluindo um sistema de votação e uma função que permite verificar e colocar fornecedores na lista negra.
Primeiro, estudamos a diferença entre ativos inteligentes, contas inteligentes e contas dApp, e a base do funcionamento das funções de verificação. As funções do verificador permitem alterar o comportamento padrão da conta. Por padrão, elas verificam as assinaturas das transações, mas a função do verificador permite estabelecer outras "regras".
{-# 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
}
}Em seguida, começamos a adicionar cupons. Utilizamos uma das funções mais importantes do dApp, que permite gravar no blockchain dados de qualquer tipo na forma de pares "chave-valor" – uma transação de dados. Integramos isso a uma nova transação, invokeScript, usada para chamar a função invocável no dApp de fora do blockchain.
O tipo de transação de dados que utilizamos durante o curso foi a adição de cupons ao marketplace:
letdatajson = {
"title": "camiseta com , vote 1",
"coupon_price": 10000000,
"old_price": 1000000000,
"new_price": 100000000,
"address": "Universo",
"description": "Eu quero que você faça amor, não guerra, eu sei que você já ouviu isso antes",
"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)
})Para processar esses dados na função addItem e desenvolver a função de compra e outras opções, usamos uma função chamável que o usuário pode invocar fora da blockchain. Como resultado, ela pode executar várias tarefas, como iniciar a transferência de fundos, registrar ou atualizar dados no armazenamento de dados dApp, etc.
Aqui está um exemplo da função chamável usada na função addItem:
@Callable(i)
funcaddItem(title: String, price: Int, data: String) = {
letsupplierAddress = toBase58String(i.caller.bytes)
letitem = getKeyItem(supplierAddress, title)
if( price <= 0) thenthrow("o valor da compra não pode ser menor que o preço do item")
elseif( getValueItemSupplier(item) !=NONE ) thenthrow("um item já existe")
else{
WriteSet([
DataEntry(getKeyItemSupplier(item), supplierAddress),
DataEntry(getKeyItemPrice(item), price),
DataEntry(getKeyItemData(item), data)
])
}
}Posteriormente, desenvolvemos um sistema de votação que permite votar pela promoção ou remoção de certos produtos. Para evitar influências externas no processo de votação, ele utiliza o esquema ‘Commit-Reveal’.
A fase 'commit' é usada para coletar votos criptografados usando uma função hash e 'sal'.
A fase 'reveal' é usada para coletar os votos criptografados e comparar seus hashes.
Aqui está um exemplo da função chamável usada aqui:
@Callable(i)
funcvoteCommit(item: String, hash: String) = {
letuser = toBase58String(i.caller.bytes)
letcommits = getValueCommitsCount(item)
letstatus = getValueItemStatus(item)
if( commits >=VOTERS) thenthrow("número máximo de eleitores alcançado")
elseif(getValueCommit(item, user) !=NONE) thenthrow("o usuário já participou")
elseif(getKeyItemSupplier(item) ==NONE) thenthrow("item não existe")
elseif(status !=NONE && status !=VOTING) thenthrow("votação não é possível")
else{
WriteSet([
DataEntry(getKeyCommit(item, user), hash),
DataEntry(getKeyCommitsCount(item), commits +1),
DataEntry(getKeyItemStatus(item),if(commits ==VOTERS) thenREVEAL elseVOTING)
])
}
}
>O que mais você aprendeu com o curso?
O curso também incluiu a tokenização e tokens não fungíveis (NFT) – tokens que representam algo único e, portanto, não intercambiáveis.
A última aula foi dedicada aos oráculos. Como a blockchain não pode obter dados do mundo externo, precisamos de oráculos para enviar esses dados para a blockchain.
Para nosso marketplace, os oráculos eram necessários para verificar e, se necessário, colocar na lista negra o fornecedor que, por exemplo, não aceitou o cupom vendido.
Aqui está um exemplo:
funcgetExtValueItemWhiteListStatus(item:String) = {
item +"_verifier_status"
}
letverifier = "3Mx9qgMyMhHt7WUZr6PsaXNfmydxMG7YMxv"
letVERIFIED = "verificado"
letBLACKLISTED = "lista negra"
@Callable(i)
funcsetstatus(supplier: String, status: String) = {
letaccount = toBase58String(i.caller.bytes)
if( account !=verifier ) thenthrow("somente o verificador oracle pode gerenciar a lista branca")
elseif( status !=VERIFIED && status !=BLACKLISTED) thenthrow("status incorreto")
else{
WriteSet([
DataEntry(getExtValueItemWhiteListStatus(supplier), status)
])
}
}
O que foi mais útil para você?
A parte mais útil foram as tarefas. Graças a elas, o material das aulas se tornava mais claro, e o conhecimento recém-adquirido foi consolidado por meio de tentativas e erros. O trabalho prático com , e .
Como você planeja aplicar o que aprendeu na prática?
Desde o início, eu esperava que o curso ajudasse a levar meu projeto a um novo nível. A ideia era agora escrever o código em RIDE. A versão existente já possui funções de certificação de documentos, mas, graças ao RIDE, poderá ser significativamente aprimorada. A nova versão será mais flexível e compreensível, trazendo mais funções, incluindo a certificação de e-mails, acordos entre várias partes, etc.
O curso também me deu muito para pensar, e eu tenho muitas novas ideias. Estou confiante de que os resultados aparecerão no futuro.
Fonte: habr.com
