5 Wege zur Verwendung von Chainlink-Funktionen in Ihren dezentralen Anwendungen
02. März 2023 — Harry Papacharissiou (übersetzt von Lukas Leys)
Chainlink Functions ist eine serverlose Entwicklerplattform für Web3, die es Smart Contracts ermöglicht, sich mit jeder API zu verbinden und einen dezentralisierten, überprüfbaren Konsens über das Ergebnis von beliebigem Code, den Sie ausführen möchten, zu erhalten.
Das ist deshalb extrem leistungsfähig, weil Smart Contracts, die traditionell auf einer Blockchain laufen, nicht ohne weiteres auf Daten und Systeme außerhalb von Blockchains zugreifen können und die Durchführung komplexer Berechnungen auf Blockchains teuer sein kann.
Nachfolgend finden Sie einige Anwendungsbeispiele, die von NFT-Giveaways bis hin zu Kryptozahlungen für Musikstreams reichen und zeigen sollen, wie Chainlink Functions dezentrale Anwendungen mit jeder API verbinden kann. Diese technischen Tutorials mit Codebeispielen wurden in Zusammenarbeit mit führenden Cloud- und Web2-Plattformen wie Meta, Twilio, AWS und Google Cloud erstellt, um die umfassende Konnektivität von Chainlink Functions zu demonstrieren und die neuen Möglichkeiten aufzuzeigen, wenn die weitreichende, funktionsreiche Welt von Web2 mit der hochautomatisierten und sicheren Infrastruktur von Web3 kombiniert wird.
Alle Beispiele sind auf dem Chainlink Labs GitHub zu finden und können noch heute direkt eingesetzt werden.
Meta: Soziale Medien mit dem Web3 verbinden
Social-Media-Plattformen wie Instagram und Facebook haben Milliarden von Nutzern, die dort mit Gleichgesinnten in Kontakt bleiben und Inhalte konsumieren können. Die meisten Unternehmen haben eine starke Online-Präsenz auf diesen Plattformen, und viele von ihnen wickeln einen Großteil ihres Geschäfts über diese Kanäle ab.
Ein Anwendungsfall, der die starke Konnektivität und Reichweite von Social-Media-Anwendungen mit den einzigartigen Eigenschaften der Web3-Welt kombiniert, sind Social-Media-Promotions und -Kampagnen. Millionen von Unternehmen auf der ganzen Welt nutzen die Reichweite von Social-Media-Plattformen wie Facebook und Instagram, um neue Produkteinführungen über Wettbewerbe, Kampagnen und Werbegeschenke zu verbreiten und zu fördern, wobei die Kunden besondere Preise gewinnen können, indem sie mit den von den Unternehmensseiten geteilten Inhalten interagieren.
Darüber hinaus wurden im Jahr 2022 digitale Sammlerstücke in Instagram integriert, die Künstlern die Möglichkeit bieten, ihre Kunst, Bilder, Videos und Musik in Form von NFTs mit ihrem Netzwerk zu teilen und zu präsentieren. Dies bietet eine Möglichkeit für Unternehmen und Kreative, neue Tools zu nutzen, um Einkommen zu erzielen und mehr Kontrolle über ihre Arbeit und die Beziehungen zu ihren Fans und Kunden zu haben.
Da die Integration digitaler Sammlerstücke auf Instagram nun eingeführt ist und von Millionen von Menschen genutzt wird, bietet die Kombination digitaler Sammlerstücke mit Social-Media-Wettbewerben und Werbegeschenken eine unglaubliche Gelegenheit, um zu zeigen, wie Social Media und Web3-Technologien wie Chainlink Functions gemeinsam genutzt werden können, um Unternehmen die Durchführung von Social-Media-Kampagnen und Wettbewerben zu ermöglichen, die digitale Sammlerstücke auf automatisierte, skalierbare und vertrauensminimierte Weise nutzen.
Der Anwendungsfall: Neue Produkteinführung NFT Giveaway
In diesem Anwendungsfall wirbt ein Unternehmen auf seiner Facebook- oder Instagram-Seite für die Einführung eines neuen Produkts oder einer neuen Dienstleistung und bietet seinen Kunden zur Feier des Tages eine begrenzte Anzahl einzigartiger digitaler Sammlerstücke in Form von NFTs an. Um in den Genuss eines dieser speziellen NFTs zu kommen, müssen die Kunden der Unternehmensseite eine private Nachricht mit ihrer Wallet-Adresse und dem spezifischen Hashtag für die Aktion schicken.
Sobald der Zeitrahmen für die Aktion abgelaufen ist, interagiert das Unternehmen mit einem Smart Contract, um die NFT-Prägung zu übernehmen. Der Smart Contract benötigt eine Liste der in Frage kommenden Wallet-Adressen als Eingabe, und sobald er die in Frage kommenden Wallet-Adressen erhält, prägt er für jede von ihnen ein NFT. In diesem Beispiel wird davon ausgegangen, dass es drei Gewinner gibt:
function fulfillRequest(bytes32 requestId, bytes memory response, bytes memory err) internal override {
latestResponse = response;
latestError = err;
emit OCRResponse(requestId, response, err);
address winner1;
address winner2;
address winner3;
assembly {
winner1 := mload(add(response, 20))
winner2 := mload(add(response, 40))
winner3 := mload(add(response, 60))
}
nft.mint(winner1);
nft.mint(winner2);
nft.mint(winner3);
}
Das Unternehmen verwendet Chainlink-Funktionen zusammen mit einem Smart Contract, um die Liste der in Frage kommenden Kunden-Wallet-Adressen zu finden. In diesem Fall initiiert der Smart Contract den Aufruf von Chainlink Functions und übergibt den auszuführenden JavaScript-Code. Dieser JavaScript-Code greift auf die Meta Messaging API zu, extrahiert und filtert Konversationen heraus, die den relevanten Hashtag enthalten, und ermittelt dann, welche Kunden für den Erhalt der NFTs in Frage kommen (in diesem Fall die ersten drei, die geantwortet haben).
async function getEligibleConversations(isoStartDate) {
const conversationsResponse = await Functions.makeHttpRequest({
url: `https://graph.facebook.com/v16.0/${secrets.FACEBOOK_PAGE_ID}/conversations?fields=messages.limit(1){message,from},updated_time&access_token=${secrets.FACEBOOK_GRAPH_API_KEY}`
})
if (conversationsResponse.status === 200) {
const conversationsObject = conversationsResponse.data;
const conversations = conversationsObject.data;
const eligibleConversations = conversations.filter(conversation => new Date(conversation.updated_time) > isoStartDate);
return eligibleConversations;
} else {
throw Error(conversationsResponse.statusText);
}
}
async function chooseWinners(eligibleConversations, numberOfWinners) {
let winnersArray = [];
const length = eligibleConversations.length;
for (let i = 0; i < length;) {
// we are getting only the latest received message from the conversation with the user
const current = eligibleConversations[i].messages.data[0].message;
if (current.includes("#giveaway")) {
const walletAddress = current.substr(current.indexOf("0x"), 42);
if (isAddress(walletAddress)) {
winnersArray.push({
walletAddress: walletAddress,
senderId: eligibleConversations[i].messages.data[0].from.id
});
if (winnersArray.length == numberOfWinners) {
return winnersArray;
}
}
}
++i;
}
throw Error("No eligible addresses");
}Sobald sie eine Liste von Wallet-Adressen erstellt hat, die für den Erhalt einer NFT in Frage kommen, verwendet die Funktion die Meta-API, um eine Nachricht an jeden ausgewählten Nutzer zu senden, in der er darüber informiert wird, dass er erfolgreich war. Von hier aus gibt sie die Liste der Adressen einfach in Form eines Byte-Arrays an den Smart Contract zurück. Sobald der Smart Contract die Ausgabe von Chainlink Functions erhält, verwendet er sie, um ein NFT auf jede der angegebenen Wallet-Adressen zu prägen.
async function sendNotification(recipientId) {
await Functions.makeHttpRequest({
method: 'POST',
url: `https://graph.facebook.com/v16.0/${secrets.FACEBOOK_PAGE_ID}/messages?recipient={'id':'${recipientId}'}&messaging_type=MESSAGE_TAG&message={'text':'Congratulations, you were successful in winning one of our special unique NFTs to celebrate the launch of our new product! Please check your wallet address that you specified in this conversation, you should now be able to see your NFT there, or in the Instagram Digital Collectibles album if you have linked the specified wallet address to your Instagram account.'}&tag=CONFIRMED_EVENT_UPDATE&access_token=${secrets.FACEBOOK_GRAPH_API_KEY}`
})
}
async function main() {
const isoStartDate = new Date(args[0]);
const numberOfWinners = args[1];
const testerAccounts = JSON.parse(args[2]);
const eligibleConversations = await getEligibleConversations(isoStartDate);
if (eligibleConversations === undefined || eligibleConversations.length === 0) {
throw Error("No eligible conversations");
}
// conversations are stored based on the latest update:
// 1. the newest
// 2. old
// 3. the oldest
//
// we want to find the fastest eligible address to award it with an NFT
const sortedEligibleConversations = eligibleConversations.reverse();
const chosenWinners = await chooseWinners(sortedEligibleConversations, numberOfWinners);
const winners = chosenWinners.map(({ walletAddress }) => Buffer.from(walletAddress.slice(2), 'hex'))
chosenWinners.forEach(async ({ senderId }) => {
if (testerAccounts.includes(senderId)) {
await sendNotification(senderId);
}
});
return winners;
}Im letzten Schritt erhält jeder Kunde, der das Gewinnspiel gewonnen hat, eine private Nachricht, die ihn über seinen Erfolg informiert. Sie können ihr neu geprägtes digitales Sammlerstück in ihrer Instagram-Galerie für digitale Sammlerstücke oder in ihrem Konto auf OpenSea einsehen:
Im Beispiel-Repository finden Sie den vollständigen Quellcode und eine vollständige Anleitung zur Bereitstellung und Ausführung dieses Anwendungsfalls.
Twilio: Generierung von Warnungen auf der Grundlage von On-Chain-Ereignissen
Twilio ist eine Cloud-Kommunikationsplattform, die eine Reihe von APIs und Tools anbietet, die es Entwicklern ermöglichen, Messaging-, Sprach- und Videofunktionen in ihre Anwendungen zu integrieren. Mit Twilio können Entwickler ganz einfach Echtzeit-Kommunikationsfunktionen zu ihren Web- und Mobilanwendungen hinzufügen, ohne dass eine komplexe Infrastruktur eingerichtet oder gewartet werden muss.
Da dezentrale Anwendungen nicht nativ auf Off-Chain-Daten und APIs zugreifen können, waren sie in ihrer Funktionalität und Fähigkeit, mit Off-Chain-Diensten zu interagieren, eingeschränkt. Mit Chainlink Functions können dApp-Entwickler nun problemlos komplexe benutzerdefinierte Workflows einrichten, die die Ausführung von beliebigem Code dezentralisieren, komplexe Berechnungen durchführen und auch Dienste wie die E-Mail-, WhatsApp- und SMS-Benachrichtigungsdienste von Twilio nutzen. Dies eröffnet eine Reihe neuer Funktionen und Anwendungsfälle, von der Benachrichtigung von Nutzern, wenn eine DeFi-Position in Gefahr ist, liquidiert zu werden, bis hin zum Versand automatischer E-Mail-Rechnungen auf der Grundlage von On-Chain-Zahlungen, die als Ergebnis einer digitalen Vereinbarung getätigt wurden.
Der Anwendungsfall: Digitale Vereinbarung über Streaming-Einnahmen zwischen Musikkünstlern und Plattenfirmen
In diesem Anwendungsfall geht es um eine digitale Vereinbarung zwischen einer Plattenfirma und einem Musikkünstler in Form eines Smart Contracts. Der Smart Contract wurde eingerichtet, um den Musikkünstler auf der Grundlage der Anzahl der Spotify-Musikstreams, die er im vergangenen Monat erhalten hat, nach einer vereinbarten Formel von X USD pro Y Streams auszuzahlen. Der Smart Contract verfügt über eine Funktion, die, wenn sie aufgerufen wird, eine benutzerdefinierte Logik ausführt, um die letzte Streaming-Zahl abzurufen und mit der zuletzt abgerufenen Zahl zu vergleichen, die erforderliche Zahlung zu berechnen und dann den erforderlichen Betrag in Form eines Stablecoins wie USDC an die Wallet-Adresse des angegebenen Künstlers auszuzahlen. Dieser Smart Contract kann als einzige Quelle der Wahrheit für die digitale Vereinbarung und ihren Zustand dienen, und die Daten können bei Bedarf von anderen Systemen integriert und referenziert werden.
Die Fähigkeit des Smart Contracts, die Spotify-Streams des Künstlers ausfindig zu machen und eine E-Mail-Benachrichtigung an den Künstler zu generieren, ist etwas, das Smart Contracts nicht selbst tun können. In diesem Beispiel verwendet der Smart Contract Chainlink-Funktionen, um sich mit einer Musikdaten-API zu verbinden und einen Konsens über die Anzahl der Spotify-Streams des Künstlers zu erzielen.
const URL = `https://sandbox.api.soundcharts.com/api/v2/artist/${artistId}/streaming/spotify/listeners`
const soundchartsResponse = await Functions.makeHttpRequest({
url: URL,
// Get a free sandbox API key from https://doc.api.soundcharts.com/api/v2/doc
headers: { "x-app-id": secrets.soundchartAppId, "x-api-key": secrets.soundchartApiKey },
})Er führt dann die Off-Chain-Berechnung durch, um den Zahlungsbetrag zu berechnen, generiert eine E-Mail-Benachrichtigung für den Künstler, um ihn über die Streams und den Zahlungsbetrag mithilfe der Twilio-E-Mail-API zu informieren, und sendet dann die letzte Hörerzahl zurück an den Smart Contract.
const emailData = {
personalizations: [
{
to: [
{
email: artistEmail,
name: artistName,
},
],
subject: "A payout is coming your way!",
},
],
content: [
{
type: "text/plain",
value: `Hey ${artistName}!
You've got ${latestListenerCount} listeners which is ${
latestListenerCount - lastListenerCount
} more than when we last checked!
So you can expect some cool crypto to be sent to your wallet soon!
Best,
TwiLink Records
`,
},
],
from: {
email: VERIFIED_SENDER,
name: "TwiLink Records",
},
reply_to: {
email: "sam.smith+noreply@example.com",
name: "Sam Smith",
},
}
Sobald der Smart Contract die Anzahl der Hörer erhält, berechnet er die erforderliche Zahlung von USDC, sendet sie an die gespeicherte Wallet-Adresse des Künstlers und speichert dann die aktuelle Anzahl der Streams in der digitalen Vereinbarung, die für die Berechnung des nächsten Monats verwendet wird.
Für diesen speziellen Anwendungsfall hat ein Prozess, der vertrauensminimierte Smart Contracts als digitale Vereinbarungen verwendet, mehrere Vorteile:
- Der Künstler weiß, dass er immer bezahlt wird und kann sicher sein, dass die Plattenfirma die Vertragsbedingungen nicht ändern kann.
- Der Prozess der Plattenfirma zur Bezahlung ihrer Künstler ist effizienter, da die Notwendigkeit manueller Zahlungen entfällt.
- Die Lösung lässt sich gut skalieren und ist automatisiert und effizient, unabhängig davon, wie viele Künstler bei der Plattenfirma an Bord sind.
In diesem Beispiel wird die Twilio-E-Mail als einfache Benachrichtigung für den Künstler verwendet. Sie kann aber auch in Verbindung mit einer vollständig gestalteten Rechnungs-E-Mail mit dem Twilio SendGrid Design-Editor verwendet werden, wodurch der On-Chain-Smart-Contract die volle Funktionalität für den Versand professionell aussehender Rechnungen an den Künstler erhält, da die Zahlungen in Echtzeit erfolgen.
Im Beispiel-Repository finden Sie den vollständigen Quellcode und eine vollständige Anleitung zur Bereitstellung und Ausführung dieses Anwendungsfalls.
Amazon Web Services (AWS): Integration von Web3 mit Cloud-Systemen und APIs
Cloud-Plattformen wie Amazon Web Services (AWS) bieten Entwicklern eine breite Palette an Cloud-basierten Computing-Diensten, darunter skalierbare und zuverlässige Infrastruktur, Speicherlösungen, Datenbankmanagement, Tools für maschinelles Lernen und serverloses Computing. Diese Dienste werden heute für einen Großteil der digitalen Welt genutzt, da sie sich einfach, effizient und kostengünstig in die Arbeitsabläufe von Entwicklern integrieren lassen.
Die Integration dieser Cloud-Dienste in die Welt von Web3 und Smart Contracts eröffnet eine Vielzahl potenzieller Anwendungsfälle, die die Fähigkeiten und die Skalierbarkeit von Web2-Cloud-Computing mit der hohen Sicherheit und den vertrauensmindernden Eigenschaften von dezentralen Web3-Anwendungen verbinden.
Der Anwendungsfall: Ein universeller Connector zur Nutzung von AWS-Daten-APIs
Bei diesem Anwendungsfall geht es um die Erstellung eines universellen Konnektors Chainlink Function, mit dem eine Verbindung zu allen AWS Data Exchange-Daten hergestellt werden kann, so dass Entwickler Daten von Drittanbietern in AWS zusammen mit Smart Contracts nahtlos integrieren können. Dies ermöglicht die Erstellung von fortschrittlichen Web3-Anwendungen, die die große Bandbreite der in AWS verfügbaren Datensätze nutzen können.
In diesem konkreten Beispiel wird der universelle Konnektor verwendet, um sich mit der Rearc Currency Exchange API zu verbinden und Währungsdaten zu erhalten, die dann an einen On-Chain-Smart-Contract zurückgegeben werden.
Der universelle Konnektor wurde als JavaScript-Funktion erstellt, die alle Knoten im dezentralen Orakelnetzwerk (DON) von Chainlink Functions ausführen müssen, bevor sie sich auf das Ergebnis des API-Aufrufs einigen können.
Die HTTP-Anfrage, die Functions ausführt, wird programmatisch erstellt, wobei eine Reihe von verschlüsselten Umgebungsvariablen, wie die Datensatz-ID, die Revisions-ID und die Asset-ID aus dem Rearc-Datensatz, übernommen werden.
Der Autorisierungs-Header wird unter Verwendung des AWS-Zugangsschlüssels und des geheimen Schlüssels sowie einer Signatur erstellt. Die Signatur wird im Anfrage-Header generiert, der eine verkettete Zeichenkette der Anfrage enthält, die dann mit dem SHA-256 Hashing-Algorithmus gehasht wird. Weitere Informationen zur Erzeugung von Signaturen für den Autorisierungs-Header finden Sie in der Amazon Simple Storage Service API-Referenz.
const signature = buildSignature(method, url, host, secrets.secretKey, secrets.securityToken, date, payload, region, service)
const config = {
url: `https://${host}${url}`,
headers: {
'x-amzn-dataexchange-data-set-id': secrets.dataSetID,
'x-amzn-dataexchange-revision-id': secrets.revisionID,
'x-amzn-dataexchange-asset-id': secrets.assetID,
'X-Amz-Date': date,
'Authorization': `AWS4-HMAC-SHA256 Credential=${secrets.accessKey}/${shortDate(date)}/${region}/${service}/aws4_request, SignedHeaders=${buildSignedHeaders(secrets.securityToken)}, Signature=${signature}`
}
}
const response = await Functions.makeHttpRequest(config)Zur Berechnung der Signatur wird der geheime AWS-Schlüssel verwendet, um einen Signierschlüssel abzuleiten. Der abgeleitete Signierschlüssel ist spezifisch für das Datum, den Service und die Region. Die endgültige Signatur ist der HMAC-SHA256-Hash der zu signierenden Zeichenfolge (verkettete Zeichenfolge der Anforderung), wobei der abgeleitete Signierschlüssel als Schlüssel verwendet wird.
/**
* To calculate a signature, a special string has to be signed. Canonical request is part of that string. This functions takes various request parts and returns special shaped string that will be hashed later on. Since queries are passed separately we need to remove them from url parameter (if there is any)
* @param {string} method - request method
* @param {string} url - absolute url of the request WITHOUT query parameters
* @param {string} host - host of the request url
* @param {string} securityToken - optional security token when temporary credentials are used
* @param {string} queries - encoded and sorted query parameters
* @param {string} date - current date (ISO 8601)
* @param {string} payload - request body for POST/PUT request, empty string for GET requests
* @returns canonical request string
*/
const buildCanonicalRequest = (method, url, host, securityToken, queries, date, payload) => {
url = url.split('?')[0]
return method + '\n'
+ encodeURI(url) + '\n'
+ queries + '\n'
+ 'host:' + host + '\n'
+ 'x-amz-date:' + date + '\n'
+ (securityToken ? 'x-amz-security-token:' + securityToken + '\n' : '')
+ '\n'
+ buildSignedHeaders(securityToken) + '\n'
+ crypto.createHash('sha256').update(payload).digest('hex')
}Sobald jeder Knoten im Chainlink Functions DON den AWS-API-Aufruf ausgeführt hat und das DON sich auf das Ergebnis geeinigt hat, wird es als uint256 kodiert und an den konsumierenden Smart Contract zurückgegeben. Der vollständige Quellcode für dieses Beispiel ist im AWS Data Exchange GitHub-Repository zu finden.
Dieses Beispiel zeigt nur eine von vielen Möglichkeiten der Integration von Smart Contracts mit AWS. Entwickler können den universellen Konnektor leicht modifizieren, um einige der anderen Funktionen von AWS unterzubringen, auf die über APIs zugegriffen werden kann, z.B. das Abfragen und Aktualisieren von Daten auf einem Amazon Relational Database Service (RDS) oder das Aktivieren eines Smart Contracts zum Ausführen einer auf AWS gehosteten Lambda-Funktion.
Google: Integration dezentraler Anwendungen mit BigQuery und Analytics
Google Analytics ist ein beliebter Webanalysedienst, mit dem Websitebetreiber den Datenverkehr und das Nutzerverhalten verfolgen und analysieren können. Er wurde zwar für die Verwendung mit herkömmlichen Websites konzipiert, kann aber auch mit dezentralen Anwendungen (dApps) und Smart Contracts verwendet werden.
Google BigQuery ist ein Cloud-natives Data Warehouse, das es Unternehmen ermöglicht, große Datensätze in Echtzeit zu analysieren und abzufragen.
Ein besonderes Beispiel für die Integration von Google Analytics und BigQuery mit Smart Contracts ist die Verwendung von Chainlink Functions und Chainlink Automation, um Live-Updates auf Blockchains über Website- oder dApp-Nutzerstatistiken bereitzustellen. Diese Demo wurde in Zusammenarbeit mit Googles Web3 Developer Advocate Allen Day erstellt.
Der Anwendungsfall: Verwendung von Analysedaten zum Auslösen von On-Chain-Logik
Dieser Anwendungsfall zeigt, wie ein Entwickler die von Google Analytics gesammelten Website-Daten nutzen kann, um die Logik in einem On-Chain-Smart-Contract zu steuern und zu beeinflussen. In diesem Beispiel wird ein Nutzer auf eine Website weitergeleitet, auf der er für einen Hund oder eine Katze stimmen kann, wobei seine Auswahl an Google Analytics gesendet wird. Die gesammelten Daten werden dann automatisch in einen Datensatz in Google Clouds BigQuery hochgeladen. Von hier aus wird Chainlink Automations verwendet, um regelmäßig eine Chainlink-Funktion aufzurufen, die die Gesamtzahl der Stimmen aus Google BigQuery abruft und sie dann auf der Blockchain zurückgibt. Der Smart Contract verwendet diese Analysedaten, um die Gesamtzahl der Stimmen zu verfolgen. Sobald der Abstimmungszeitraum beendet ist, wird eine Funktion im Smart Contract den Gewinner ermitteln.
Bevor eine Anfrage an die Google BigQuery API gestellt werden kann, muss Chainlink Functions ein Zugriffstoken anfordern:
const jwtClaimSetObj = {
"iss": iss,
"scope": "https://www.googleapis.com/auth/cloud-platform.read-only",
"aud": "https://oauth2.googleapis.com/token",
"exp": currentTimeInSeconds + 3500,
"iat": currentTimeInSeconds
}
const jwtBase64ClaimSet = Buffer.from(JSON.stringify(jwtClaimSetObj)).toString('base64')
const stringToSign = `${jwtBase64Headers}.${jwtBase64ClaimSet}`
const jwtBase64Signature = crypto.sign('RSA-SHA256', stringToSign, privateKey).toString('base64')
const jwtRequest = {
grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
assertion: `${jwtBase64Headers}.${jwtBase64ClaimSet}.${jwtBase64Signature}`
}
const jwtRequestString = querystring.stringify(jwtRequest)
const tokenResponse = await Functions.makeHttpRequest({
url: 'https://oauth2.googleapis.com/token',
method: 'post',
data: jwtRequestString
})Sobald dieser Token erhalten wurde, kann es in der aufgebauten Anfrage verwendet werden, um die Daten von Google BigQuery für jede Auswahl zu erhalten:
const getSQLQuery = (propertyId) => {
return `SELECT COUNT(DISTINCT user_pseudo_id) AS votes FROM \`${secrets.projectId}.analytics_${propertyId}.events_intraday_*\` WHERE event_name = 'page_view' OR event_name = 'user_engagement'`
}
const requestConfig = {
method: 'post',
url: `https://bigquery.googleapis.com/bigquery/v2/projects/${secrets.projectId}/queries`,
headers: {
"Authorization": `Bearer ${await getOauthToken(secrets.iss, secrets.key)}`,
"Accept": 'application/json',
"Content-Type": 'application/json'
},
data: {
"query": getSQLQuery(secrets.property1),
"useLegacySql": false
}
}
const request1 = Functions.makeHttpRequest(requestConfig)
requestConfig.data.query = getSQLQuery(secrets.property2)
const request2 = Functions.makeHttpRequest(requestConfig)
const responses = await Promise.all([ request1, request2 ])Die zurückgegebenen Ergebnisse werden dann kombiniert und auf der Blockchain an den konsumierenden Smart Contract zurückgeschickt:
let item1Votes
try {
item1Votes = parseInt(responses[0].data.rows[0].f[0].v)
} catch {
item1Votes = 0
}
let item2Votes
try {
item2Votes = parseInt(responses[1].data.rows[0].f[0].v)
} catch {
item2Votes = 0
}
console.log(`Item 1 votes: ${item1Votes}\nItem 2 votes: ${item2Votes}`)
return Buffer.concat([ Functions.encodeUint256(item1Votes), Functions.encodeUint256(item2Votes) ])Sobald der Abstimmungszeitraum beendet ist, wird mit der Funktion declareWinner bestimmt, welches der beiden Tiere der Gewinner ist:
function declareWinner() public onlyOwner {
if (charity1Votes == charity2Votes) {
winner = 'Charity #1 and #2 tied!';
}
if (charity1Votes > charity2Votes) {
winner = 'Charity #1 won!';
}
if (charity1Votes > charity2Votes) {
winner = 'Charity #2 won!';
}
emit WinnerDeclared(winner);
}Der vollständige Quellcode für dieses Beispiel ist im Google BigQuery Demo GitHub-Repository zu finden. Dieses einfache Beispiel beschränkt sich auf spezifische Analysedaten, die auf zwei Ereignissen basieren. Es dient jedoch als Vehikel zur Demonstration der Möglichkeiten, die durch die Kombination dezentraler Anwendungen mit Diensten wie Google Analytics und Google BigQuery erkundet werden können.
Dezentralisierte Versicherung: Nutzung von Off-Chain-Wetterdaten für parametrische Versicherungen
Bei der dezentralen Versicherung werden Blockchain-Technologie und Smart Contracts eingesetzt, um herkömmliche Versicherungsverträge zu ersetzen. Dank datengesteuerter Automatisierung, hochsicherer, fälschungssicherer digitaler Verträge in Form von Smart Contracts und sofortiger und automatisierter Schadensabwicklung bieten sie sowohl den Versicherungsunternehmen als auch ihren Kunden ein besseres Versicherungsprodukt.
Das größte Problem, um die Welt der parametrischen Versicherungen ins Web3 zu bringen, ist die Verfügbarkeit von qualitativ hochwertigen, verifizierbaren Daten. Mit Chainlink Functions können Entwickler ganz einfach ihren eigenen Off-Chain-Datenfeed erstellen, indem sie auf Daten aus verschiedenen Quellen zugreifen und diese aggregieren und dann Chainlink Functions dazu veranlassen, einen Konsens darüber zu erzielen, was das Ergebnis der Off-Chain-Datenaggregation ist, bevor das Endergebnis auf der Kette gemeldet wird.
Der Anwendungsfall: Parametrischer Versicherungsvertrag unter Verwendung mehrerer Datenquellen
Dieser Anwendungsfall zeigt, wie ein Entwickler Wetterdaten aus drei verschiedenen Datenquellen abrufen, die drei Ergebnisse außerhalb von Blockchains zusammenfassen und dann jeden Knoten im Chainlink Functions DON dazu bringen kann, einen Konsens über den von jedem Knoten zurückgegebenen Mittelwert zu erzielen, bevor dieser auf einer Blockchain veröffentlicht wird.
Diese Daten werden verwendet, um festzustellen, ob ein Versicherungsvertrag an einen Kunden ausgezahlt werden soll. Der Versicherungsvertrag ParametricInsuranceprüft, wie hoch die Temperatur in einer bestimmten Stadt (in diesem Fall New York) ist. Fällt die Temperatur an drei aufeinanderfolgenden Tagen unter 60 Grad Fahrenheit, zahlt der Vertrag den vereinbarten Wert an den Kunden aus. Der ParametricInsurance-Vertrag definiert die Vertragsbedingungen, wie den vereinbarten Wert und die parametrischen Parameter für die Auszahlung des Vertrags:
function fulfillRequest(
bytes32 requestId,
bytes memory response,
bytes memory err
) internal override {
latestResponse = response;
latestError = err;
emit OCRResponse(requestId, response, err);
// once callback happens, mark the timestamp
currentTempDateChecked = block.timestamp;
currentTemperature = uint256(bytes32(response));
// if current temperature is under temperature which considered as cold, number of cold days increment
if (currentTemperature > coldTemp) {
consecutiveColdDays = 0;
} else {
consecutiveColdDays += 1;
}
// pay the client and shut down the contract
if(consecutiveColdDays >= COLD_DAYS_THRESHOLD) {
payoutContract();
}
}Die Chainlink-Funktion von Parametric-insurance-example.js führt API-Aufrufe an drei verschiedene Wetterdatenquellen durch, aggregiert das Ergebnis und kommt dann zu einem Konsens über das mittlere Ergebnis jedes Knotens, bevor sie die Wetterdaten an den ParametricInsurance-Smart Contract zurückgibt.
const openWeatherRequest = Functions.makeHttpRequest({
url: `http://api.openweathermap.org/data/2.5/weather?lat=${cityLat}&lon=${cityLon}&appid=${secrets.openWeatherApiKey}&units=imperial`,
})
const worldWeatherRequest = Functions.makeHttpRequest({
url: `http://api.worldweatheronline.com/premium/v1/weather.ashx?key=${secrets.worldWeatherApiKey}&q=${cityName}&format=json`,
})
const ambeeDataRequest = Functions.makeHttpRequest({
url: `http://api.ambeedata.com/weather/latest/by-lat-lng?lat=${cityLat}&lng=${cityLon}`,
headers: { "x-api-key": `${secrets.ambeeWeatherApiKey}` }
})
// wait data returned by multiple APIs
const [openWeatherResponse, worldWeatherResponse, ambeeDataResponse] = await Promise.all([
openWeatherRequest,
worldWeatherRequest,
ambeeDataRequest])Der vollständige Quellcode für dieses Beispiel kann im Parametric Insurance GitHub Repository gefunden werden. Dieses Beispiel ist spezifisch für parametrische Versicherungen, aber die Idee zeigt, wie einfach es ist, Daten aus mehreren Quellen zu konsumieren, Berechnungen außerhalb der Kette durchzuführen, wie z.B. Aggregation, und dann das OCR-Konsensprotokoll von Chainlink Functions zu verwenden, um das Ergebnis der Berechnung weiter zu überprüfen, bevor es auf einer Blockchain bereitgestellt wird.
Fazit
Von sozialen Medien über Cloud Computing bis hin zu Versicherungsprotokollen — Chainlink Functions eröffnet eine Vielzahl von Anwendungsfällen für Smart Contracts, indem es Entwicklern ermöglicht, einfach und sicher auf Daten und Berechnungen außerhalb von Blockchains zuzugreifen.
Um weitere Anwendungsfälle zu sehen oder Ihre eigenen einzureichen, empfehlen wir Ihnen, Use Chainlink Functions zu besuchen, die Website, die von der Community eingereichte Anwendungsfälle und Beispiele für Chainlink Functions zeigt.
Die Bereitstellung aller Daten und APIs der Welt für dezentralisierte Anwendungen wird eine Explosion neuer Anwendungsfälle auslösen, ähnlich wie Chainlink Price Feeds der Katalysator für das Wachstum von DeFi war. Der Unterschied zu Chainlink Functions besteht jedoch darin, dass Chainlink nicht nur ein Preisdatenorakel ist, sondern ein Orakel für beliebige Daten, das es Entwicklern ermöglicht, auf beliebige Daten auf Blockchains zuzugreifen und aufregende Anwendungsfälle im gesamten Web3-Bereich zu erschließen.
