Get Real-Time Weather Data With the Sui Weather Oracle

Sui · 2023-11-27T17:53:03.000Z

The new Sui Weather Oracle gives builders weather data for over 1,000 cities around the world and serves as a unique randomness generator, suitable for games and betting apps requiring a trustworthy random result. Consisting of a Sui-based smart contract and a backend service pulling weather data from the OpenWeather API, anyone can integrate weather data into their app. The SUI Weather Oracle provides information such as temperature, humidity, and wind for any of its supported cities. The oracle can be used by other smart contracts or applications that need reliable and decentralized weather information for various purposes, such as travel, insurance, agriculture, gambling, or gaming. The Sui Weather Oracle enables weather tracking and other apps using OpenWeather API data. However, using weather for its randomness presents an intriguing use case. Weather is one of the most unpredictable and complex phenomena in nature. Weather forecasters do an admirable job of predicting rain or sunny skies, for the most part, but the minutiae, such as specific temperatures or wind speeds, is beyond the current science to nail down. As a fundamental concept in many fields of science, mathematics, and engineering, randomness can be used to generate secure cryptographic keys, test hypotheses, or simulate complex systems. However, generating true randomness is not easy, as most physical or computational processes are deterministic or biased in some way. Using weather data as an oracle input provides random outputs that are uniformly distributed and independent of any previous output. Oracle data in apps Oracles on Sui and other blockchains serve as conduits to offchain data, including sports scores, stock prices, and weather. Displaying this data directly in an app, the most obvious use, lets builders create stock portfolio management tools, weather trackers, and real-time football rankings. Data usage in this manner can become more complex, of course, with apps using sports scores to inform fantasy leagues as one example. Games may be based directly on oracle data. For example, an oracle can provide the odds and outcomes of various wagers for contests such as sports matches, political elections, or lottery draws. The players can then place bets on the outcomes based on the odds provided by the oracle. Things get more interesting when builders use oracles offering unpredictable data to generate randomness. For example, an oracle can use real-world events, such as weather data, sports results, or stock prices, to create random outcomes for a game. Alternatively, an oracle can use cryptographic methods, such as hash functions or digital signatures, to produce random numbers that are secure and provable. The fact that the oracle data comes from a verifiable source independent from the app makes the randomness outcomes trustworthy. Weather data can be used as a seed for randomness to determine the results of character actions in a game. (Image source: RPGMaker) Randomness based on unpredictable data from an oracle could be incorporated into game mechanics. For example, in a roleplaying game, an oracle can determine the success or failure of a character's action, such as casting a spell, hacking a computer, or persuading an NPC. The oracle can also affect the game world, such as changing the weather, spawning enemies, or triggering events. The game can use the oracle's data to create a fair and consistent randomness that is not influenced by the game developer or the player. The Sui Weather Oracle Oracles will enable a new generation of apps on Sui, bridging real-world data to its high-performance platform. Given the accessibility of the OpenWeather API and the usefulness of its data, a weather oracle makes for a good addition to Sui. Use cases The Sui Weather Oracle is useful for many applications that require weather data, such as: Randomness: Weather data can be used as a source of randomness for various purposes, such as generating random numbers, selecting winners, or creating unique NFTs. For example, a random number generator. can use the temperature, humidity, or wind speed of a specific location at a specific time as a seed. Betting and gaming: Apps can use Sui Weather Oracle data to enable weather prediction wagers, weather-themed games, or weather-based rewards. For example, a game could let users bet on a city's weather, or an app could offer users NFTs based on the weather of different locations. Other use cases: Apps for insurance, travel, education, or research could use weather data. For example, apps could factor in weather data to calculate the risk of natural disasters, plan a travel itinerary, teach students about weather patterns, or aid in setting up scientific experiments. Structure The Sui Weather Oracle, delivering up-to-date weather information for 1,000 cities across the globe, consists of three components: an external service, an internal service, and a smart contract. The external service, the OpenWeather API, provides current weather data from various sources. The internal service is the weather oracle back-end, which fetches the weather data from the OpenWeather API every 10 minutes and updates the weather conditions for each city. The smart contract is the Sui Weather Oracle contract, which stores the weather data on the Sui blockchain and lets users access it in a secure and transparent manner. Users can also leverage the weather data for various decentralized applications that rely on the weather, such as gaming. Earning storage rebates The Sui Weather Oracle mitigates the cost of storing its real-time data on the network through the storage rebate mechanism. Sui supports onchain storage in its infrastructure and tokenomics model by adding a storage fee to its gas fees. The fund created from storage fees helps reimburse network operators for maintaining the hardware to store data and process transactions. As a means of keeping the quantity of onchain data under control, deleting onchain data renders a storage fund rebate. The Sui Weather Oracle stores and updates the weather data on the blockchain. The admin pays a one-time fee to create the initial list of CityWeatherOracle objects, and receives a rebate for updating the weather data for each city. The rebate is proportional to the amount of data updated, and the frequency of updates. This way, the admin can store and update the weather data on the blockchain at a low cost. Leveraging Sui Object Display The Sui Weather Oracle uses the Sui Object Display standard to dynamically update the icon for each city based on the current weather condition, showing rain clouds or a sun, for example. The Sui Object Display standard is a template engine that allows the onchain management of the offchain display for any type of object. It uses a template string that can be substituted with the data of the object, such as the weather ID of the city. The offchain display is handled by a back-end service that serves an icon for each one of the supported cities to the Sui explorer. The icon is chosen from a predefined set of icons that represent different weather conditions, such as sunny, cloudy, rainy, and snowy. The Sui Object Display standard can be leveraged to serve icons representing different weather conditions. ( Image by coolvector on Freepik) Sui Weather Oracle smart contract The Sui Weather Oracle smart contract provides real-time and historical weather data for 1,000 locations around the world and supports minting weather NFTs based on the weather data of a city. The smart contract also uses the Sui Object Display standard, enabling the dynamic and customizable display of the weather data and the weather NFTs on the blockchain. The smart contract has four main functions: add_city , remove_city, update, and mint. The oracle::weather module defines the following: AdminCap , a struct that represents the administrator capability of the oracle owner. struct AdminCap has key, store { id: UID } WEATHER , a struct that sets up a Publisher. struct WEATHER has drop {} WeatherOracle , a struct, represents the oracle itself. It has fields id, address, name, and description that store the oracle's identifier, owner's address, name, and description respectively. struct WeatherOracle has key { id: UID, address: address, name: String, description: String, } CityWeatherOracle , a struct that represents the weather data for a specific city. It has fields id, geoname_id, name, country, latitude, positive_latitude, longitude, positive_longitude, weather_id, temp, pressure, humidity, visibility, wind_speed, wind_deg, wind_gust, clouds, and dt that store the city's unique ID, geoname ID, name, country, latitude, longitude, weather ID, temperature, pressure, humidity, visibility, wind speed, wind direction, wind gust, cloudiness, and timestamp respectively. struct CityWeatherOracle has key, store { id: UID, geoname_id: u32, name: String, country: String, latitude: u32, positive_latitude: bool, longitude: u32, positive_longitude: bool, weather_id: u16, temp: u32, pressure: u32, humidity: u8, visibility: u16, wind_speed: u16, wind_deg: u16, wind_gust: Option<u16>, clouds: u8, dt: u32 } An init function that initializes the contract during the deployment, creating a new instance of WeatherOracle and sharing it publicly, and creating a new instance of AdminCap and transferring it to the sender. fun init(otw: WEATHER, ctx: &mut TxContext) { package::claim_and_keep(otw, ctx); let cap = AdminCap { id: object::new(ctx) }; transfer::share_object(WeatherOracle { id: object::new(ctx), address: tx_context::sender(ctx), name: string::utf8(b"SuiMeteo"), description: string::utf8(b"A weather oracle for posting weather updates (temperature, pressure, humidity, visibility, wind metrics and cloud state) for major cities around the world. Currently the data is fetched from https://openweathermap.org. SuiMeteo provides the best available information, but it does not guarantee its accuracy, completeness, reliability, suitability, or availability. Use it at your own risk and discretion."), }); transfer::public_transfer(cap, tx_context::sender(ctx)); } The add_city public function, which lets the owner of the AdminCap add a new city to the oracle service by providing its geoname_ID, name, country, latitude, and longitude. The function creates a new instance of CityWeatherOracle with default weather data and adds it to the oracle as a dynamic field, using the geoname_ID as the key. public fun add_city( _: &AdminCap, oracle: &mut WeatherOracle, geoname_id: u32, name: String, country: String, latitude: u32, positive_latitude: bool, longitude: u32, positive_longitude: bool, ctx: &mut TxContext ) { dof::add(&mut oracle.id, geoname_id, CityWeatherOracle { id: object::new(ctx), geoname_id, name, country, latitude, positive_latitude, longitude, positive_longitude, weather_id: 0, temp: 0, pressure: 0, humidity: 0, visibility: 0, wind_speed: 0, wind_deg: 0, wind_gust: option::none(), clouds: 0, dt: 0 } ); } The remove_city public function, which lets the owner of the AdminCap remove an existing city from the oracle service by providing its geoname_ID. The function removes the corresponding instance of CityWeatherOracle from the oracle's dynamic fields and deletes the object. public fun remove_city(_: &AdminCap, oracle: &mut WeatherOracle, geoname_id: u32) { let CityWeatherOracle { id, geoname_id: _, name: _, country: _, latitude: _, positive_latitude: _, longitude: _, positive_longitude: _, weather_id: _, temp: _, pressure: _, humidity: _, visibility: _, wind_speed: _, wind_deg: _, wind_gust: _, clouds: _, dt: _ } = dof::remove(&mut oracle.id, geoname_id); object::delete(id); } The update public function, which allows the oracle owner to update the weather data for an existing city by providing its geoname_ID and the new weather data. The function mutates the corresponding instance of CityWeatherOracle with the new weather data. public fun update( _: &AdminCap, oracle: &mut WeatherOracle, geoname_id: u32, weather_id: u16, temp: u32, pressure: u32, humidity: u8, visibility: u16, wind_speed: u16, wind_deg: u16, wind_gust: Option<u16>, clouds: u8, dt: u32 ) { let city_weather_oracle_mut = dof::borrow_mut<u32, CityWeatherOracle>(&mut oracle.id, geoname_id); city_weather_oracle_mut.weather_id = weather_id; city_weather_oracle_mut.temp = temp; city_weather_oracle_mut.pressure = pressure; city_weather_oracle_mut.humidity = humidity; city_weather_oracle_mut.visibility = visibility; city_weather_oracle_mut.wind_speed = wind_speed; city_weather_oracle_mut.wind_deg = wind_deg; city_weather_oracle_mut.wind_gust = wind_gust; city_weather_oracle_mut.clouds = clouds; city_weather_oracle_mut.dt = dt; } Integrating the Sui Weather Oracle Using the Sui Weather Oracle in a Move project requires adding it as a dependency in the project's Move.toml file: [package] name = "..."version = "..." [dependencies] Sui = { git = "<https://github.com/MystenLabs/sui.git>", subdir = "crates/sui-framework/packages/sui-framework", rev = "..." } oracle = { git = "<https://github.com/MystenLabs/apps>", subdir = "weather-oracle", rev = "db04fbd17d6ba91ade45c32f609b949fb47d209b" } [addresses] ... oracle = "0x8378b3bd39931aa74a6aa3a820304c1109d327426e4275183ed0b797eb6660a8" Creating this dependency lets builders import the oracle::weather module into Move code and make use of the Weather Oracle and its functions. The Sui Weather Oracle provides real-time weather data, such as temperature, humidity, and wind speed, for different cities around the world. The city_weather_oracle_temp function retrieves the temperature of a city in Kelvin multiplied by 1,000, given its geoname_ID. For example, the following code retrieves the current temperature of Paris, France (2988507): use oracle::weather::{WeatherOracle}; fun get_temp(weather_oracle: &WeatherOracle): u32 { let geoname_id = 2988507; // Paris, France oracle::weather::city_weather_oracle_temp(weather_oracle, geoname_id) } Bridging data to Sui The rise of big data over the last few decades has created vast repositories representing all manner of real world phenomenon and activity, from ocean currents to traffic flows in Manhattan. Responsible use of this data results in apps that make a positive impact on people's lives, whether it's helping predict forest fire danger or making popular concert tickets available in a fair distribution. The spread of oracles on Sui will increase the relevance of apps to people's daily lives, making the network an indispensable part of modern digital infrastructure.

Le nouveau Sui Weather Oracle fournit aux constructeurs des données météorologiques pour plus de 1 000 villes à travers le monde et sert de générateur aléatoire unique, adapté aux jeux et aux applications de paris nécessitant un résultat aléatoire fiable. Composé d'un contrat intelligent basé sur Sui et d'un service backend extrayant les données météorologiques de l'API OpenWeather, n'importe qui peut intégrer des données météorologiques dans son application.
Le SUI Weather Oracle fournit des informations telles que la température, l'humidité et le vent pour chacune de ses villes prises en charge. L'oracle peut être utilisé par d'autres contrats ou applications intelligents qui ont besoin d'informations météorologiques fiables et décentralisées à diverses fins, telles que les voyages, les assurances, l'agriculture, les jeux de hasard ou les jeux.
 Sui Weather Oracle permet le suivi météorologique et d'autres applications utilisant les données de l'API OpenWeather.
Cependant, utiliser la météo pour son caractère aléatoire présente un cas d’utilisation intrigant. La météo est l’un des phénomènes naturels les plus imprévisibles et les plus complexes. Les prévisionnistes font un travail admirable en prédisant la pluie ou le ciel ensoleillé, pour la plupart, mais les détails, tels que les températures spécifiques ou la vitesse du vent, sont au-delà de la science actuelle.
En tant que concept fondamental dans de nombreux domaines scientifiques, mathématiques et techniques, le hasard peut être utilisé pour générer des clés cryptographiques sécurisées, tester des hypothèses ou simuler des systèmes complexes. Cependant, générer un véritable caractère aléatoire n’est pas facile, car la plupart des processus physiques ou informatiques sont déterministes ou biaisés d’une manière ou d’une autre. L’utilisation de données météorologiques comme entrée Oracle fournit des sorties aléatoires uniformément distribuées et indépendantes de toute sortie précédente.
Données Oracle dans les applications
Les oracles sur Sui et d'autres blockchains servent de conduits aux données hors chaîne, notamment les résultats sportifs, les cours des actions et la météo. L'affichage de ces données directement dans une application, l'utilisation la plus évidente, permet aux constructeurs de créer des outils de gestion de portefeuille d'actions, des suivis météorologiques et des classements de football en temps réel. L’utilisation des données de cette manière peut bien sûr devenir plus complexe, avec par exemple les applications utilisant les résultats sportifs pour informer les ligues fantastiques.
Les jeux peuvent être basés directement sur des données Oracle. Par exemple, un oracle peut fournir les cotes et les résultats de divers paris sur des compétitions telles que des matchs sportifs, des élections politiques ou des tirages de loterie. Les joueurs peuvent ensuite parier sur les résultats en fonction des cotes fournies par l'oracle.
Les choses deviennent plus intéressantes lorsque les constructeurs utilisent des oracles offrant des données imprévisibles pour générer du hasard. Par exemple, un oracle peut utiliser des événements du monde réel, tels que des données météorologiques, des résultats sportifs ou le cours des actions, pour créer des résultats aléatoires pour un jeu. Alternativement, un oracle peut utiliser des méthodes cryptographiques, telles que des fonctions de hachage ou des signatures numériques, pour produire des nombres aléatoires sécurisés et prouvables. Le fait que les données Oracle proviennent d’une source vérifiable indépendante de l’application rend les résultats aléatoires dignes de confiance.
 Les données météorologiques peuvent être utilisées comme source de hasard pour déterminer les résultats des actions des personnages dans un jeu. (Source de l'image : RPGMaker)
Le hasard basé sur des données imprévisibles provenant d’un oracle pourrait être intégré aux mécanismes de jeu. Par exemple, dans un jeu de rôle, un oracle peut déterminer le succès ou l'échec d'une action d'un personnage, comme lancer un sort, pirater un ordinateur ou persuader un PNJ. L'oracle peut également affecter le monde du jeu, comme changer la météo, faire apparaître des ennemis ou déclencher des événements. Le jeu peut utiliser les données de l'oracle pour créer un caractère aléatoire juste et cohérent qui n'est pas influencé par le développeur du jeu ou le joueur.
L’Oracle météorologique Sui
Oracles permettra une nouvelle génération d'applications sur Sui, reliant les données du monde réel à sa plate-forme haute performance. Compte tenu de l'accessibilité de l'API OpenWeather et de l'utilité de ses données, un oracle météo constitue un bon complément à Sui.
Cas d'utilisation
Le Sui Weather Oracle est utile pour de nombreuses applications nécessitant des données météorologiques, telles que :
Caractère aléatoire : les données météorologiques peuvent être utilisées comme source de caractère aléatoire à diverses fins, telles que générer des nombres aléatoires, sélectionner des gagnants ou créer des NFT uniques. Par exemple, un générateur de nombres aléatoires. peut utiliser la température, l’humidité ou la vitesse du vent d’un endroit spécifique à un moment précis comme graine.
Paris et jeux : les applications peuvent utiliser les données Sui Weather Oracle pour activer les paris sur les prévisions météorologiques, les jeux sur le thème de la météo ou les récompenses basées sur la météo. Par exemple, un jeu pourrait permettre aux utilisateurs de parier sur la météo d'une ville, ou une application pourrait proposer aux utilisateurs des NFT basés sur la météo de différents endroits.
Autres cas d'utilisation : les applications destinées à l'assurance, aux voyages, à l'éducation ou à la recherche peuvent utiliser des données météorologiques. Par exemple, les applications pourraient prendre en compte les données météorologiques pour calculer le risque de catastrophe naturelle, planifier un itinéraire de voyage, enseigner aux étudiants les conditions météorologiques ou aider à mettre en place des expériences scientifiques.
Structure
Le Sui Weather Oracle, qui fournit des informations météorologiques à jour pour 1 000 villes à travers le monde, se compose de trois éléments : un service externe, un service interne et un contrat intelligent. Le service externe, l'API OpenWeather, fournit des données météorologiques actuelles provenant de diverses sources. Le service interne est le back-end de Weather Oracle, qui récupère les données météorologiques de l'API OpenWeather toutes les 10 minutes et met à jour les conditions météorologiques pour chaque ville. Le contrat intelligent est le contrat Sui Weather Oracle, qui stocke les données météorologiques sur la blockchain Sui et permet aux utilisateurs d'y accéder de manière sécurisée et transparente. Les utilisateurs peuvent également exploiter les données météorologiques pour diverses applications décentralisées qui dépendent de la météo, telles que les jeux.
Bénéficier de remises sur le stockage
Sui Weather Oracle atténue le coût de stockage de ses données en temps réel sur le réseau grâce au mécanisme de remise de stockage. Sui prend en charge le stockage en chaîne dans son modèle d'infrastructure et de tokenomics en ajoutant des frais de stockage à ses frais de gaz. Le fonds créé à partir des frais de stockage permet de rembourser les opérateurs de réseaux pour la maintenance du matériel permettant de stocker les données et de traiter les transactions. Afin de garder sous contrôle la quantité de données en chaîne, la suppression des données en chaîne donne lieu à une remise sur les fonds de stockage.
Le Sui Weather Oracle stocke et met à jour les données météorologiques sur la blockchain. L'administrateur paie des frais uniques pour créer la liste initiale des objets CityWeatherOracle et reçoit une remise pour la mise à jour des données météorologiques de chaque ville. La remise est proportionnelle à la quantité de données mises à jour et à la fréquence des mises à jour. De cette façon, l’administrateur peut stocker et mettre à jour les données météorologiques sur la blockchain à faible coût.
Tirer parti de l'affichage des objets Sui
Le Sui Weather Oracle utilise la norme Sui Object Display pour mettre à jour dynamiquement l'icône de chaque ville en fonction des conditions météorologiques actuelles, affichant des nuages ​​de pluie ou un soleil, par exemple. Le standard Sui Object Display est un moteur de template qui permet la gestion onchain de l'affichage offchain pour tout type d'objet. Il utilise une chaîne de modèle qui peut être remplacée par les données de l'objet, telles que l'identifiant météo de la ville. L'affichage hors chaîne est géré par un service back-end qui fournit une icône pour chacune des villes prises en charge à l'explorateur Sui. L'icône est choisie parmi un ensemble prédéfini d'icônes qui représentent différentes conditions météorologiques, telles que ensoleillé, nuageux, pluvieux et enneigé.
 La norme Sui Object Display peut être exploitée pour servir des icônes représentant différentes conditions météorologiques. (Image de coolvector sur Freepik) Contrat intelligent Sui Weather Oracle
Le contrat intelligent Sui Weather Oracle fournit des données météorologiques historiques et en temps réel pour 1 000 emplacements dans le monde et prend en charge la création de NFT météorologiques basés sur les données météorologiques d'une ville. Le contrat intelligent utilise également le standard Sui Object Display, permettant l'affichage dynamique et personnalisable des données météorologiques et des NFT météo sur la blockchain. Le contrat intelligent a quatre fonctions principales :
ajouter_ville
, remove_city, update et mint.
Le
oracle :: météo
 Le module définit les éléments suivants :
Cap Administrateur
, une structure qui représente la capacité d'administrateur du propriétaire d'Oracle.
struct AdminCap a la clé, stocke { id : UID }
MÉTÉO
, une structure qui configure un éditeur.
struct WEATHER a drop {}
MétéoOracle
, une structure, représente l'oracle lui-même. Il contient des champs identifiant, adresse, nom et description qui stockent respectivement l'identifiant de l'oracle, l'adresse, le nom et la description du propriétaire.
struct WeatherOracle a la clé {     id : UID,     adresse : adresse,     nom : chaîne,     description : chaîne, }
VilleMétéoOracle
, une structure qui représente les données météorologiques d'une ville spécifique. Il contient des champs id, geoname_id, nom, pays, latitude, positive_latitude, longitude, positive_longitude, Weather_id, temp, pression, humidité, visibilité, vent_vitesse, vent_deg, vent_gust, nuages ​​et dt qui stockent l'identifiant unique de la ville, l'identifiant de géonom, le nom. , pays, latitude, longitude, identifiant météo, température, pression, humidité, visibilité, vitesse du vent, direction du vent, rafale de vent, nébulosité et horodatage respectivement.
struct CityWeatherOracle a la clé, stocker {     id : UID,     geoname_id : u32,     name : String,     country : String,     latitude: u32,     positive_latitude: bool,     longitude : u32,     positive_longitude: bool,     weather_id : u16,      température : u32,    pression : u32 ,     humidité : u8,     visibilité : u16,     vitesse_vent : u16,     deg_vent : u16,     rafale_vent : Option<u16>,     nuages : u8,     dt : u32 }
Un
chaleur
 fonction qui initialise le contrat lors du déploiement, créant une nouvelle instance de WeatherOracle et la partageant publiquement, et créant une nouvelle instance d'AdminCap et la transférant à l'expéditeur.
fun init(otw : WEATHER, ctx : &mut TxContext) {     package::claim_and_keep(otw, ctx); let cap = AdminCap { id: object::new(ctx) }; transfer::share_object(WeatherOracle {         id: object::new(ctx),         adresse : tx_context::sender(ctx),         nom : string::utf8(b"SuiMeteo"),         description : string::utf8(b"A) Oracle météo pour publier des mises à jour météorologiques (température, pression, humidité, visibilité, mesures du vent et état des nuages) pour les grandes villes du monde. Actuellement, les données sont extraites de https://openweathermap.org et fournissent les meilleures informations disponibles, mais. il ne garantit pas son exactitude, son exhaustivité, sa fiabilité, son adéquation ou sa disponibilité. Utilisez-le à vos propres risques et discrétion."),    } ); transfer::public_transfer(cap, tx_context::sender(ctx)); }
Le
ajouter_ville
 fonction publique, qui permet au propriétaire d'AdminCap d'ajouter une nouvelle ville au service Oracle en fournissant son geoname_ID, son nom, son pays, sa latitude et sa longitude. La fonction crée une nouvelle instance de CityWeatherOracle avec les données météorologiques par défaut et l'ajoute à l'oracle en tant que champ dynamique, en utilisant le geoname_ID comme clé.
public fun add_city(     _ : &AdminCap,      oracle : &mut WeatherOracle,       geoname_id : u32,     name: String,     country: String,     latitude: u32,     positive_latitude: bool,     longitude : u32,     positive_longitude: bool     ctx, : &mut TxContext ) {     dof:: add(&mut oracle.id, geoname_id,          CityWeatherOracle {             id: object::new(ctx),             geoname_id,             nom,              pays,              latitude,             latitude_positive,              longitude,               longitude_positive,             weather_id : 0,             temp : 0,             pression : 0,             humide ville : 0 ,             visibilité : 0,             vitesse du vent : 0,             wind_deg : 0,             wind_gust: option::none(),             nuages : 0,             dt : 0        }     ); }
Le
supprimer_ville
 fonction publique, qui permet au propriétaire d'AdminCap de supprimer une ville existante du service Oracle en fournissant son geoname_ID. La fonction supprime l'instance correspondante de CityWeatherOracle des champs dynamiques de l'oracle et supprime l'objet.
public fun remove_city(_ : &AdminCap, oracle : &mut WeatherOracle, geoname_id : u32) {     let CityWeatherOracle { id, geoname_id : _, nom : _, pays : _, latitude : _, positive_latitude : _, longitude : _, positive_longitude : _ , Weather_id : _, temp : _, pression : _, humidité : _, visibilité : _, vitesse_vent : _, vent_deg : _, vent_gust : _, nuages : _, dt : _ } = dof::remove(&mut oracle. id, geoname_id); objet :: supprimer (identifiant); }
Le
mise à jour
 fonction publique, qui permet au propriétaire de l'oracle de mettre à jour les données météorologiques d'une ville existante en fournissant son geoname_ID et les nouvelles données météorologiques. La fonction mute l'instance correspondante de CityWeatherOracle avec les nouvelles données météorologiques.
mise à jour publique amusante (     _ : &AdminCap,     oracle : &mut WeatherOracle,     geoname_id : u32,     weather_id : u16,     temp: u32,     pression : u32,     humidité : u8,     visibilité : u16,     wind_speed : u16,     wind_ deg : u16,    wind_gust : Option<u16 >,     nuages : u8,     dt : u32 ) {     let city_weather_oracle_mut = dof::borrow_mut<u32, CityWeatherOracle>(&mut oracle.id, geoname_id); city_weather_oracle_mut.weather_id = météo_id; city_weather_oracle_mut.temp = temp; city_weather_oracle_mut.pression = pression ; city_weather_oracle_mut.humidity = humidité ; city_weather_oracle_mut.visibility = visibilité ; city_weather_oracle_mut.wind_speed = vent_speed; city_weather_oracle_mut.wind_deg = vent_deg; city_weather_oracle_mut.wind_gust = vent_gust; city_weather_oracle_mut.clouds = nuages ; city_weather_oracle_mut.dt = dt; }
Intégration de l'Oracle Météo Sui
L'utilisation de Sui Weather Oracle dans un projet Move nécessite de l'ajouter en tant que dépendance dans le fichier du projet.
Déplacer.toml
 déposer:
[package] name = "..."version = "..." [dépendances] Sui = { git = "<https://github.com/MystenLabs/sui.git>", subdir = "crates/sui- framework/packages/sui-framework", rev = "..." } oracle = { git = "<https://github.com/MystenLabs/apps>", subdir = "weather-oracle", rev = "db04fbd17d6ba91ade45c32f609b949fb47d209b " } [adresses] ... oracle = "0x8378b3bd39931aa74a6aa3a820304c1109d327426e4275183ed0b797eb6660a8"
La création de cette dépendance permet aux constructeurs d'importer le
oracle :: météo
 module dans le code Move et utilisez Weather Oracle et ses fonctions. Le Sui Weather Oracle fournit des données météorologiques en temps réel, telles que la température, l'humidité et la vitesse du vent, pour différentes villes du monde. La fonction city_weather_oracle_temp récupère la température d'une ville en Kelvin multipliée par 1 000, compte tenu de son geoname_ID.
Par exemple, le code suivant récupère la température actuelle de Paris, France (2988507) :
utilisez oracle::weather::{WeatherOracle} ; fun get_temp(weather_oracle: &WeatherOracle): u32 {     let geoname_id = 2988507; // Paris, France     oracle::weather::city_weather_oracle_temp(weather_oracle, geoname_id) }
Relier les données à Sui
L’essor du Big Data au cours des dernières décennies a créé de vastes référentiels représentant toutes sortes de phénomènes et d’activités du monde réel, des courants océaniques aux flux de circulation à Manhattan. L'utilisation responsable de ces données donne naissance à des applications qui ont un impact positif sur la vie des gens, qu'il s'agisse d'aider à prédire le danger d'incendie de forêt ou de rendre disponibles des billets de concert populaires dans une distribution équitable.
La diffusion des oracles sur Sui augmentera la pertinence des applications dans la vie quotidienne des gens, faisant du réseau un élément indispensable de l'infrastructure numérique moderne.

Découvrez-en plus sur le créateur

Dernières actualités