田辺 明美

田辺 明美

1678972620

Mac でデフォルトのブラウザを変更する方法

このチュートリアルでは、Mac でデフォルトのブラウザを変更する方法を学びます。Mac の既定のブラウザーを任意のブラウザーに変更する

有名なトラックパッドと Retina ディスプレイとは別に、Apple のファーストパーティ アプリは Mac コンピュータのハイライトです。便利な Notes アプリでも、Apple シリコン Mac の新しい合理化された Safari アプリでもかまいません。しかし、Mac の既定のアプリが気に入らない場合はどうすればよいでしょうか? Windows から切り替える場合はどうなりますか? 心配しないで。Mac の既定のブラウザーを変更する方法を説明します。

デフォルト ブラウザの変更は、理想的にはシンプルで簡単なプロセスです。ただし、macOS のオプションは設定アプリ内にあり、通常は見つけられない場所にあります。この記事を読むまでは。Mac を手に取り、以下の手順に従ってデフォルトのブラウザをお気に入りのブラウザに設定します。

MAC のデフォルト ブラウザを変更する理由

すでに述べたように、Safari は、最初に Mac を入手したときのデフォルトのブラウザです。Safari は Apple 独自のアプリであるため、これは明らかです。新しい Safari はカスタマイズ可能で、Apple シリコン Mac 向けに十分に最適化されていますが、多くのユーザーはそのデザインを気に入らないかもしれません。

蓋を閉じたまま MacBook をスリープ状態にしないようにする

Users who are switching from Windows or other operating systems may also find the features of Safari limiting. Furthermore, if you use Chrome extensions or specific features only found on certain web browsers, you would want to carry them over to your Mac. This is why you would want to get another browser on your Mac.

If you’re invested in the Google ecosystem, all it takes is a few clicks to set Chrome as the default browser on your Mac. Here’s how to switch from Safari to Chrome, Firefox, or just about any browser of your choice on a Mac.

HOW TO CHANGE THE DEFAULT BROWSER ON YOUR MAC

The steps we’ve mentioned below apply to Macs running macOS Ventura and newer. If you’re running an older version of macOS, we suggest updating to the latest version so that the instructions align with your OS. Once you’ve updated, you can follow the steps below.

ステップ 1: お使いの Mac に任意のブラウザーをダウンロードしてインストールします。

Google Chrome、Mozilla Firefox、Microsoft Edge、または任意の他のブラウザをダウンロードできます。混乱している場合は、バッテリーを節約するこれらの Web ブラウザーを調べてください。

ステップ 2: インストールが完了したら、Mac のホーム画面に移動します。左上隅にある Apple ロゴをクリックし、[システム設定] を選択します。

ステップ 3: 左ペインの [デスクトップとドック] メニューに移動します。

ステップ 4:  [Windows & Apps] セクションが表示されるまで、右側を下にスクロールします。

ステップ 5: ここに、「既定の Web ブラウザー」オプションがあります。その横にあるドロップダウンメニューをクリックします。

ステップ 6: メニューからお好みの Web ブラウザーを選択します。

これで、Chrome が Mac の既定のブラウザに設定されました。もちろん、他のブラウザも動作します。しかし、既定のブラウザを変更する設定が [デスクトップとドック] セクションに隠されているのはなぜですか? さて、それが macOS であり、その悪ふざけです!

Mac のデフォルト ブラウザを変更できないのはなぜですか

手順に従っても、Mac の既定のブラウザーを変更できませんか? ここにいくつかの簡単な解決策があります。

  • デフォルトのブラウザを変更しようとしたときに、インストールしたブラウザがドロップダウン メニューに表示されない場合は、Mac を再起動してから、次の手順を試してください。
  • 信頼できるソースからブラウザをダウンロードしてください。
  • Mac に適したバージョンのブラウザをインストールします。つまり、Apple シリコンを搭載した Mac を使用しているか、Intel チップを搭載した Mac を使用しているかに基づいて、対応するバージョンをダウンロードします。
  • ブラウザをアンインストールしてから再度インストールして、リストに表示されるかどうかを確認してください。
  • 別のブラウザーをダウンロードし、それを既定のブラウザーとして設定してみて、動作するかどうかを確認してください。

MAC のデフォルト Web ブラウザの変更に関する FAQ

1. Safari は Mac に最適な Web ブラウザーですか?

Safari は Apple によって作成されているため、Mac 用に最適化されています。Apple シリコンを搭載した Mac をお持ちの場合、Safari はバッテリーの消費を最小限に抑えながら最高のパフォーマンスを提供する可能性があります。そのため、パフォーマンスに基づいて Mac で使用するのに最適なブラウザーかもしれませんが、機能に関しては必ずしも最高であるとは限りません。

2. Google Chrome は M1 および M2 Mac 用に最適化されていますか?

はい、Google は Apple シリコン Mac 用のバージョンの Chrome をリリースしたので、M1 または M2 Mac を使用している場合はカバーされます。

選択したブラウザを使用

必要がなければ、強制的に Safari を使用する必要はありません。ガイドに従って、Mac の既定のブラウザーを任意のブラウザーに変更するだけで、自宅にいるように感じることができます。では、Mac で使用している Web ブラウザとその理由は何ですか? 以下のコメントでお知らせください。

ソース: https://www.guidingtech.com

#browser #mac

What is GEEK

Buddha Community

Mac でデフォルトのブラウザを変更する方法
田辺 明美

田辺 明美

1678972620

Mac でデフォルトのブラウザを変更する方法

このチュートリアルでは、Mac でデフォルトのブラウザを変更する方法を学びます。Mac の既定のブラウザーを任意のブラウザーに変更する

有名なトラックパッドと Retina ディスプレイとは別に、Apple のファーストパーティ アプリは Mac コンピュータのハイライトです。便利な Notes アプリでも、Apple シリコン Mac の新しい合理化された Safari アプリでもかまいません。しかし、Mac の既定のアプリが気に入らない場合はどうすればよいでしょうか? Windows から切り替える場合はどうなりますか? 心配しないで。Mac の既定のブラウザーを変更する方法を説明します。

デフォルト ブラウザの変更は、理想的にはシンプルで簡単なプロセスです。ただし、macOS のオプションは設定アプリ内にあり、通常は見つけられない場所にあります。この記事を読むまでは。Mac を手に取り、以下の手順に従ってデフォルトのブラウザをお気に入りのブラウザに設定します。

MAC のデフォルト ブラウザを変更する理由

すでに述べたように、Safari は、最初に Mac を入手したときのデフォルトのブラウザです。Safari は Apple 独自のアプリであるため、これは明らかです。新しい Safari はカスタマイズ可能で、Apple シリコン Mac 向けに十分に最適化されていますが、多くのユーザーはそのデザインを気に入らないかもしれません。

蓋を閉じたまま MacBook をスリープ状態にしないようにする

Users who are switching from Windows or other operating systems may also find the features of Safari limiting. Furthermore, if you use Chrome extensions or specific features only found on certain web browsers, you would want to carry them over to your Mac. This is why you would want to get another browser on your Mac.

If you’re invested in the Google ecosystem, all it takes is a few clicks to set Chrome as the default browser on your Mac. Here’s how to switch from Safari to Chrome, Firefox, or just about any browser of your choice on a Mac.

HOW TO CHANGE THE DEFAULT BROWSER ON YOUR MAC

The steps we’ve mentioned below apply to Macs running macOS Ventura and newer. If you’re running an older version of macOS, we suggest updating to the latest version so that the instructions align with your OS. Once you’ve updated, you can follow the steps below.

ステップ 1: お使いの Mac に任意のブラウザーをダウンロードしてインストールします。

Google Chrome、Mozilla Firefox、Microsoft Edge、または任意の他のブラウザをダウンロードできます。混乱している場合は、バッテリーを節約するこれらの Web ブラウザーを調べてください。

ステップ 2: インストールが完了したら、Mac のホーム画面に移動します。左上隅にある Apple ロゴをクリックし、[システム設定] を選択します。

ステップ 3: 左ペインの [デスクトップとドック] メニューに移動します。

ステップ 4:  [Windows & Apps] セクションが表示されるまで、右側を下にスクロールします。

ステップ 5: ここに、「既定の Web ブラウザー」オプションがあります。その横にあるドロップダウンメニューをクリックします。

ステップ 6: メニューからお好みの Web ブラウザーを選択します。

これで、Chrome が Mac の既定のブラウザに設定されました。もちろん、他のブラウザも動作します。しかし、既定のブラウザを変更する設定が [デスクトップとドック] セクションに隠されているのはなぜですか? さて、それが macOS であり、その悪ふざけです!

Mac のデフォルト ブラウザを変更できないのはなぜですか

手順に従っても、Mac の既定のブラウザーを変更できませんか? ここにいくつかの簡単な解決策があります。

  • デフォルトのブラウザを変更しようとしたときに、インストールしたブラウザがドロップダウン メニューに表示されない場合は、Mac を再起動してから、次の手順を試してください。
  • 信頼できるソースからブラウザをダウンロードしてください。
  • Mac に適したバージョンのブラウザをインストールします。つまり、Apple シリコンを搭載した Mac を使用しているか、Intel チップを搭載した Mac を使用しているかに基づいて、対応するバージョンをダウンロードします。
  • ブラウザをアンインストールしてから再度インストールして、リストに表示されるかどうかを確認してください。
  • 別のブラウザーをダウンロードし、それを既定のブラウザーとして設定してみて、動作するかどうかを確認してください。

MAC のデフォルト Web ブラウザの変更に関する FAQ

1. Safari は Mac に最適な Web ブラウザーですか?

Safari は Apple によって作成されているため、Mac 用に最適化されています。Apple シリコンを搭載した Mac をお持ちの場合、Safari はバッテリーの消費を最小限に抑えながら最高のパフォーマンスを提供する可能性があります。そのため、パフォーマンスに基づいて Mac で使用するのに最適なブラウザーかもしれませんが、機能に関しては必ずしも最高であるとは限りません。

2. Google Chrome は M1 および M2 Mac 用に最適化されていますか?

はい、Google は Apple シリコン Mac 用のバージョンの Chrome をリリースしたので、M1 または M2 Mac を使用している場合はカバーされます。

選択したブラウザを使用

必要がなければ、強制的に Safari を使用する必要はありません。ガイドに従って、Mac の既定のブラウザーを任意のブラウザーに変更するだけで、自宅にいるように感じることができます。では、Mac で使用している Web ブラウザとその理由は何ですか? 以下のコメントでお知らせください。

ソース: https://www.guidingtech.com

#browser #mac

Cash jons

1614246541

Download MBOX to PST Converter for Mac » Convert MBOX to PST Accurately

Wonderful MBOX to PST transformation expresses that you frequently don’t hear in a similar sentence. Getting an ideal MBOX to PST Converter resembles a slippery dream. Numerous clients are ordinary giving a shot to locate the most ideal approach to accomplish this fantasy. Lamentably, the greater part of the apparatuses that guarantee you to help in accomplishing that fantasy is simply fabrications. They neglect to convey their guarantees, consequently, bringing about a deficient and degenerate Converter measure.

MBOX to PST Conversion with Easy and Accurate

To accomplish this fantasy, you’ll need a transformation arrangement that has the capacity of assuming the difficulties of the advanced email data sets. The transformation arrangement is sponsored by the privileged mechanical progressions. Try not to stress it is a lot more straightforward than it sounds. Also, this article will help you discover one such arrangement. Peruse on and rethink the manner in which you take on your information movement measure.

Mail Extractor Pro: The Tool That’ll Help You Achieve that Dream

The fast advancement in the mechanical world has influenced the interaction of information relocation decidedly. It has Converted the manner in which you approach the way toward moving your information. Outsider programming arrangement appeared because of this very turn of events and is presently the most prescribed answer for convert the Mbox file to pst. Your job is to locate the best outsider converter there is and you are set.

Mail Extractor Pro from MBOX to PST Converter for Mac Software is the best outsider converter apparatus undoubtedly. Suggested by top specialists and easygoing clients the same, the instrument has the correct equilibrium of the relative multitude of fundamental highlights less the intricacy that typically comes free with the apparatus. It is vigorous, exact, precise yet still exceptionally simple to utilize.

Convert Everything including the Unicode Data

What is a transformation interaction that isn’t exact? A fiasco. The fundamental assignment of your converter instrument is to Converter over your information data with exactness and accuracy. You are indeed changing your information starting with one arrangement over then onto the next. Thus, you can’t agree to a transformation arrangement with less exactness.

You can pass judgment on the exactness of any converter device by its capacity to deal with complex Unicode information present in the information documents. Unicode information is perplexing in nature as it is not encoded like your typical text-based information. In this way, it is somewhat difficult to Converter over and numerous converter instruments neglect to manage them.

This converter device causes you to convert everything present in your information document including the Unicode information, giving you an ideal MBOX to PST transformation.

Interface assists a ton with the cycle

The interface is the media of correspondence of any product application. Simpler it is to utilize; simpler it will be for you to make yourself clear to the application.

With this converter device, you get free streaming astutely planned interface. It doesn’t have any perplexing and pointless highlights in plain view that may befuddle you. It just shows the highlights needed to take care of business. It even furnishes you with guidelines to assist you with your Mac MBOX to PST Converter measure.

Download the MBOX to PST converter for Mac free preliminary variant of the device now.

#mbox to pst converter for mac #mac mbox to pst converter #mac mbox to pst #mbox to pst

Neal Bode

Neal Bode

1598511081

How To Install Golang On Mac Example From Scratch

Install Golang on Mac is very easy. You can download the binary from the official website or install it using homebrew. Golang provides binary distributions for Mac OS X, Windows, and Linux. Then set up your Golang environment. If you are using a different OS, you can download the Go source code and install it from the source.

How To Install Golang On Mac

  1. Download the latest version of Go for your platform here:  https://golang.org/dl/.
  2. Follow the instructions for your platform to install the Go tools:  https://golang.org/doc/install#install. It is recommended to use the default installation settings.
  3. On Mac OS X and Linux, by default Go is installed to directory /usr/local/go, and the GOROOT environment variable is set to /usr/local/go/bin.
  4. You may need to restart any open Terminal sessions for the change to take effect.
  5. Also, we need to install the  VSCode, because there are some tools which we will install inside VSCode which will help us during the developing Go project.

#golang #mac #vscode #go #linux #mac os x

Thierry Perret

Thierry Perret

1651550028

Comment écrire Des DApps Sur Corda

Le lancement du bitcoin le 3 janvier 2009 a mis en mouvement des tendances telles que les actifs numériques et les monnaies numériques, et depuis lors, davantage de chaînes de blocs comme Ethereum et Solana ont été créées. Malgré des fonctionnalités et des cas d'utilisation différents, ces blockchains ont une chose en commun ; ils ont été conçus pour fonctionner démocratiquement sans régulateurs. Par conséquent, ce modèle n'est pas adapté aux industries réglementées, dans lesquelles les données doivent rester confidentielles et partagées entre des parties de confiance. Pour cette raison, des blockchains privées existent.

Une blockchain privée est une blockchain autorisée. Une blockchain privée contient des entités appelées opérateurs de réseau qui contrôlent le réseau et peuvent configurer les autorisations et les contrôles d'accès des autres nœuds. Pour maintenir la confidentialité et la confiance, seules les entités participant à une transaction en auront connaissance, tandis que les autres ne pourront pas y accéder.

Quelques exemples de plates-formes numériques qui utilisent des chaînes de blocs privées incluent Hyperledger Fabric , Ripple et Corda de R3 . Dans cet article, nous allons explorer Corda et apprendre à créer des CorDapps. Commençons!

Présentation de Corda

Corda est une technologie de registre distribué peer-to-peer (P2P) autorisée qui facilite le développement d'applications sur les marchés réglementés. Avec Corda, les parties peuvent librement découvrir et effectuer des transactions les unes avec les autres dans un seul réseau ouvert tout en ayant confiance dans l'identification des participants au réseau.

À long terme, Corda aspire à être un grand livre partagé distribué dans le monde entier. Pour ce faire, les nombreuses solutions qui utilisent le logiciel Corda doivent respecter un ensemble de normes et de critères communs. Certains de ces critères, souvent appelés principes de l'état final, sont les suivants :

  • Identité assurée : les parties auront confiance dans l'identité des participants au réseau. L'identification dans Corda est représentée par un certificat délivré par une autorité compétente
  • Confidentialité : les seules personnes qui ont accès aux informations de transaction sont celles qui sont impliquées dans la transaction et celles qui doivent vérifier la source de la transaction.
  • Interopérabilité : Corda est destiné à permettre à de nombreuses applications de coexister et d'interopérer sur le même réseau ; un ensemble défini d'interfaces de contrat est fourni pour optimiser l'interopérabilité à partir d'un large éventail de fournisseurs

Composants clés de CorDapps

CorDapp est un raccourci pour l'application distribuée Corda. Les CorDapps sont des applications distribuées qui s'exécutent sur le nœud Corda. Voici les composants clés d'un CorDapp :

États

Les états sont constitués de données. Ils gardent une trace des données entre les transactions et sont immuables, ce qui signifie qu'ils ne peuvent pas être modifiés après leur formation. Toute modification doit plutôt entraîner la création d'un nouvel État successeur.

Contrats

Les contrats définissent les critères de validation qui seront appliqués aux entrées et sorties des transactions. Les contrats garantissent que les états d'entrée et de sortie des transactions sont valides et que les transactions invalides sont évitées. Un ou plusieurs contrats peuvent exister dans un CorDapp, chacun fournissant des règles pour un ou plusieurs états.

Les flux

Les flux sont les activités que votre CorDapp peut entreprendre sur un réseau, et ils constituent la logique métier de votre CorDapp. Les flux permettent aux parties de coordonner leurs opérations sans recourir à un contrôleur central.

Transactions

Une transaction est une demande de mise à jour du registre. Il consomme les états d'entrée actuels et en génère de nouveaux pour mettre à jour le grand livre. Avant qu'une transaction ne soit acceptée par les nœuds, une transaction doit être unique, valide et signée par les parties appropriées.

 

Notaire

Un notaire est un service du réseau Corda qui permet d'éviter les dépenses en double des actifs du réseau. Il le fait en garantissant que chaque transaction ne comprend que des états d'entrée uniques qui n'ont pas été utilisés par une transaction précédente. Un notaire donne également une finalité à la transaction. Une transaction est considérée comme conclue après sa signature par le notaire.

Consensus

Dans Corda, vous pouvez établir un consensus en prouvant qu'une transaction est à la fois valide et unique. Le consensus est une méthode qui permet aux nœuds de s'entendre sur l'état actuel du réseau. Avant qu'une transaction proposée puisse être inscrite dans le grand livre, les deux parties doivent convenir qu'elle est légale.

Premiers pas avec Corda

Nous allons créer une CorDapp pour modéliser l'émission de jetons sur la blockchain Corda. Notre CorDapp gardera une trace de l'émetteur du jeton, du détenteur et du montant émis.

Il existe quatre logiciels requis pour le développement de CorDapp :

  • JDKJava 8
  • IDÉE IntelliJ
  • Gite
  • Gradle, toute version entre 5.1 et 5.6.4

Mise en place

Pour configurer notre CorDapp, commencez par cloner le modèle Corda Java à partir de leur dépôt GitHub. Ouvrir cordapp-template-javadans n'importe quel IDE de votre choix. Je vais utiliser IntelliJ IDE.

Créer l'état

Pour rappel, les états sont immuables et gardent une trace des données entre les transactions. Notre CorDapp va avoir un ensemble d'attributs que nous allons stocker sur notre état, comme issuer, holderet amount.

Naviguez jusqu'à /contracts/src/main/java/com/template/stateset créez une nouvelle classe Java appeléeTokenState :

package com.template.states

import com.template.contracts.TokenContract;
import net.corda.core.identity.AbstractParty;
import net.corda.core.contracts.BelongsToContract;
import net.corda.core.contracts.ContractState;
import net.corda.core.identity.Party;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
import java.util.List;

@BelongsToContract(TokenContract.class)
public class TokenState implements ContractState {
    private Party issuer;
    private Party holder;
    private int amount;

    public TokenState(Party issuer, Party holder, int amount){
        this.issuer = issuer;
        this.holder = holder;
        this.amount = amount;
    }

    public Party getHolder() {
        return holder;
    }

    public Party getIssuer() {
        return issuer;
    }

    public int getAmount() {
        return amount;
    }

    @NotNull
    @Override
    public List<AbstractParty> getParticipants() {
        return Arrays.asList(issuer, holder);
    }
}

Dans le code ci-dessus, nous créons une classe appelée TokenStatequi hérite de la ContractStateclasse. La ContractStateclasse indique à Corda que nous implémentons un état.

Ensuite, nous ajoutons l' @BelongsToContractannotation, qui établit la relation entre un état et un contrat. Sans cela, votre état ne sait pas quel contrat est utilisé pour le vérifier. L'ajout de cette annotation déclenche une erreur dans IntelliJ car nous n'avons pas encore créé notre fichier TokenContract.

Ensuite, nous créons trois attributs, issuer, holderet amount. Les attributs issueret holderreçoivent le type Partycar ils représentent tous deux des entités sur le nœud.

Ensuite, nous créons trois méthodes getter pour chacun des attributs. Enfin, nous créons une getParticipantsméthode qui définit quelles parties doivent être informées de la transaction. Dans notre cas, nous voulons seulement que le issueret le holdersoient au courant de la transaction.

Créer le contrat

Pour rappel, les contrats définissent les règles d'évolution des États. Ils effectuent certaines validations avant qu'une transaction ne se déroule avec succès. Par conséquent, chaque état est lié à un contrat.

Naviguez jusqu'à /contracts/src/main/java/com/template/contractset créez une nouvelle classe Java appeléeTokenContract :

package com.template.contracts

import net.corda.core.contracts.CommandData;
import net.corda.core.contracts.Contract;
import net.corda.core.transactions.LedgerTransaction;

import org.jetbrains.annotations.NotNull;
import com.template.states.TokenState;


public class TokenContract implements Contract {
    public static final String ID = "contracts.TokenContract";

    @Override
    public void verify(@NotNull LedgerTransaction tx) {

        if(tx.getCommands().size() != 1) {
            throw new IllegalArgumentException("expects only one command: ISSUE");
        }
        if(tx.getCommand(0).getValue() instanceof Commands.Issue){
            throw new IllegalArgumentException("issue command expected");
        }
        TokenState state = (TokenState) tx.getOutput(0);
        int amountIssued = state.getAmount();
        if (amountIssued <= 0){
            throw new IllegalArgumentException("amount must be greater than zero");
        }
        if(! (tx.getCommand(0).getSigners().contains(state.getIssuer().getOwningKey()))){
            throw new IllegalArgumentException("transaction must be signed by issuer");
        }
    }
    // Used to indicate the transaction's intent.
    public interface Commands extends CommandData {
        class Issue implements Commands {}
    }
}

Dans le code ci-dessus, nous créons une classe appelée TokenContractqui hérite de la Contractclasse. La Contractclasse dit à Corda que nous mettons en œuvre un contrat.

Tout d'abord, nous créons un attribut appelé IDqui identifiera notre contrat lors de la construction de notre transaction dans des environnements de test. L' IDattribut est purement facultatif.

L'une des méthodes qui nous est donnée par la Contractclasse dont nous avons hérité est la verifyméthode, que nous devons redéfinir. La verifyméthode prend les transactions en entrée et les évalue par rapport à des règles définies. Une transaction est valide si la verifyméthode ne lève pas d'exception.

Avec le code ci-dessus, notre contrat effectue les vérifications suivantes :

  • Les transactions doivent être signées par l'émetteur
  • Le montant doit être supérieur à zéro
  • Seule la issuecommande peut être utilisée
  • État d'entrée initial nul puisqu'il s'agit d'une émission

Enfin, puisque nous avons l'intention d'émettre le jeton à une autre partie, nous créons une classe appelée Issuequi hérite de la Commandclasse. La Commandclasse est utilisée pour indiquer le type d'action en cours d'exécution.

Ecriture du flux initiateur

Pour rappel, les flux contiennent la logique métier de notre CorDapp. Le flux initiateur est exécuté par le nœud initiant la transaction, qui serait le issuerdans notre cas.

Naviguez jusqu'à workflows/src/main/java/com/template/flowset créez une nouvelle classe Java appeléeFlowInitiator :

package com.template.flows;

import co.paralleluniverse.fibers.Suspendable;
import com.bootcamp.contracts.TokenContract;
import com.bootcamp.states.TokenState;
import net.corda.core.flows.*;
import net.corda.core.identity.CordaX500Name;
import net.corda.core.identity.Party;
import net.corda.core.transactions.SignedTransaction;
import net.corda.core.transactions.TransactionBuilder;
import net.corda.core.utilities.ProgressTracker;
import net.corda.core.contracts.CommandData;

import static java.util.Collections.singletonList;

    @InitiatingFlow
    @StartableByRPC
    public static class TokenFlowInitiator extends FlowLogic<SignedTransaction> {
        private final Party owner;
        private final int amount;

        public TokenFlowInitiator(Party owner, int amount) {
            this.owner = owner;
            this.amount = amount;
        }

        private final ProgressTracker progressTracker = new ProgressTracker();

        @Override
        public ProgressTracker getProgressTracker() {
            return progressTracker;
        }

        @Suspendable
        @Override
        public SignedTransaction call() throws FlowException {

            /** Explicit selection of notary by CordaX500Name - argument can by coded in flows or parsed from config (Preferred)*/
            final Party notary = getServiceHub().getNetworkMapCache().getNotary(CordaX500Name.parse("O=Notary,L=London,C=GB"));
            // We get a reference to our own identity.
            Party issuer = getOurIdentity();

            /* ============================================================================
             *         TODO 1 - Create our TokenState to represent on-ledger tokens!
             * ===========================================================================*/
            // We create our new TokenState.
            TokenState tokenState = new TokenState(issuer, owner, amount);

            /* ============================================================================
             *      TODO 3 - Build our token issuance transaction to update the ledger!
             * ===========================================================================*/
            // We build our transaction.
            TransactionBuilder transactionBuilder = new TransactionBuilder.setNotary(notary).addOutputState(tokenState).addCommand(new TokenContract.Commands.Issue(), Arrays.asList(issuer.getOwningKey(), owner.getOwningKey()));

            /* ============================================================================
             *          TODO 2 - Write our TokenContract to control token issuance!
             * ===========================================================================*/
            // We check our transaction is valid based on its contracts.
            transactionBuilder.verify(getServiceHub());

            FlowSession session = initiateFlow(owner);

            // We sign the transaction with our private key, making it immutable.
            SignedTransaction signedTransaction = getServiceHub().signInitialTransaction(transactionBuilder);

            // The counterparty signs the transaction
            SignedTransaction fullySignedTransaction = subFlow(new CollectSignaturesFlow(signedTransaction, singletonList(session)));

            // We get the transaction notarised and recorded automatically by the platform.
            return subFlow(new FinalityFlow(fullySignedTransaction, singletonList(session)));
        }
    }

Dans le code ci-dessus, nous créons une classe appelée TokenFlowInitiatorqui hérite de la FlowLogicclasse. La FlowLogicclasse dit à Corda que nous créons un flux.

Ensuite, nous ajoutons deux annotations, @InitiatingFlowet @StartableByRPC. L' @InitiatingFlowannotation indique que ce flux est le flux initiateur. D'autre part, l' @StartableByRPCannotation permet à RPC de démarrer le flux.

Ensuite, nous créons une variable appelée progressTrackerqui contrôle chaque étape du flux et génère les messages spécifiés lorsque chaque point de contrôle est atteint dans le code.

Ensuite, nous créons la callméthode, que Corda appelle au démarrage du flux. Dans la callméthode, nous créons d'abord un notaire et le stockons dans une variable appelée notary. Puisque nous traitons avec plusieurs parties, nous avons besoin d'un service de notaire pour parvenir à un consensus entre les parties.

Nous obtenons notre identité et la stockons dans une variable appelée issuer. Ensuite, nous créons notre jeton en créant une nouvelle instance de TokenStateet en passant les arguments issuer, owneret .amount

Ensuite, nous construisons notre proposition de transaction en créant une nouvelle instance de TransactionBuilder. Nous enchaînons différentes méthodes pour paramétrer notre notaire, ajouter des commandes, et signer la transaction.

Enfin, nous commençons a FlowSessionavec la contrepartie en utilisant la InitiateFlowméthode. Ce processus nous permet d'envoyer l'état à la contrepartie. Nous appelons ensuite le sous- CollectSignaturesFlowflux pour collecter les signatures.

Rédiger le flux du répondeur

Le flux du répondeur est géré par la contrepartie. Il reçoit et enregistre la transaction, puis répond au flux de l'émetteur en renvoyant un accusé de réception si la transaction a réussi.

Naviguez jusqu'à workflows/src/main/java/com/template/flowset créez une nouvelle classe Java appeléeTokenFlowResponder :

package com.template.flows;

import co.paralleluniverse.fibers.Suspendable;
import net.corda.core.flows.*;
import net.corda.core.identity.Party;
import net.corda.core.transactions.SignedTransaction;


@InitiatedBy(TokenFlowInitiator.class)
    public static class TokenFlowResponder extends FlowLogic<Void>{
        //private variable
        private FlowSession counterpartySession;

        //Constructor
        public TokenFlowResponder(FlowSession counterpartySession) {
            this.counterpartySession = counterpartySession;
        }

        @Suspendable
        @Override
        public Void call() throws FlowException {
            SignedTransaction signedTransaction = subFlow(new SignTransactionFlow(counterpartySession) {});

            //Stored the transaction into data base.
            subFlow(new ReceiveFinalityFlow(counterpartySession, signedTransaction.getId()));
            return null;
        }
    }

Dans le code ci-dessus, nous créons une classe appelée TokenFlowResponderqui hérite de la FlowLogicclasse. Nous ajoutons ensuite l' @InitiatedByannotation et transmettons la TokenFlowInitiatorclasse en tant qu'argument, indiquant à Corda qui a initié le flux.

Ensuite, nous créons la callméthode avec a subFlowqui vérifiera la transaction et les signatures qu'elle a reçues de l'initiateur du flux. Facultativement, nous pouvons créer de manière conventionnelle une nouvelle méthode appelée checkTransactionà effectuer une série de tests juste pour être sûr.

Exécution de notre CorDapp

Pour démarrer notre CorDapp, nous devons d'abord le déployer en naviguant à la racine de notre projet et en exécutant les commandes suivantes :

#Mac or Linux
./gradlew clean deployNodes

#Windows
gradlew.bat clean deployNodes

Si notre CorDapp se construit avec succès, il génère trois nœuds avec le CorDapp installé dessus. Ceux-ci peuvent être trouvés dans le build/nodesdossier.

Lancer l'exemple de CorDapp

Pour démarrer les nœuds et notre CorDapp, exécutez la commande suivante depuis notre répertoire racine :

#Mac or Linux
./build/nodes/runnodes

#Windows
.\build\nodes\runnodes.bat

Le code ci-dessus ouvrira une nouvelle fenêtre de terminal pour chaque nœud. Donnez à chaque terminal un peu de temps pour démarrer et vous recevrez un message de bienvenue sur le terminal une fois que le nœud sera prêt.

Interagir avec notre CorDapp

Pour vérifier si notre CorDapp a fonctionné avec succès, nous pouvons essayer de démarrer un flux en exécutant la commande suivante :

flow start TokenFlowInitiator owner: PartyB, amount: 100

Conclusion

La blockchain est une technologie qui change la donne, et les entreprises réglementées ne sont pas en reste grâce à des systèmes qui utilisent des blockchains privées. Les projets de blockchain comme Corda offrent aux entreprises la flexibilité dont elles ont besoin tout en préservant la confidentialité des données. Dans cet article, nous avons exploré comment démarrer avec Corda, en apprenant à créer des CorDapps.

J'espère que ce tutoriel vous a plu, et n'hésitez pas à laisser un commentaire si vous avez des questions.

#blockchain #dapp #corda 

Lic. Adria Sepúlveda

Lic. Adria Sepúlveda

1651673160

Cómo Escribir DApps en Corda

El lanzamiento de bitcoin el 3 de enero de 2009 puso en marcha tendencias como los activos digitales y las monedas digitales y, desde entonces, se han creado más cadenas de bloques como Ethereum y Solana. A pesar de tener diferentes características y casos de uso, estas cadenas de bloques tienen una cosa en común; fueron diseñados para operar democráticamente sin reguladores. Por lo tanto, este modelo no es adecuado para industrias reguladas, en las que los datos deben mantenerse confidenciales y compartirse entre partes de confianza. Por esta razón, existen cadenas de bloques privadas.

Una cadena de bloques privada es una cadena de bloques autorizada. Una cadena de bloques privada contiene entidades llamadas operadores de red que controlan la red y pueden configurar permisos y controles de acceso de los otros nodos. Para mantener la privacidad y la confianza, solo las entidades que participan en una transacción tendrán conocimiento de ella, mientras que otras no podrán acceder a ella.

Algunos ejemplos de plataformas digitales que utilizan cadenas de bloques privadas incluyen Hyperledger Fabric , Ripple y R3's Corda . En este artículo, exploraremos Corda y aprenderemos a crear CorDapps. ¡Empecemos!

Introducción a Corda

Corda es una tecnología de registro distribuido (DLT) peer-to-peer (P2P) autorizada que facilita el desarrollo de aplicaciones en mercados regulados. Con Corda, las partes pueden descubrirse libremente y realizar transacciones entre sí en una sola red abierta mientras confían en la identificación de los participantes de la red.

A la larga, Corda aspira a ser un libro mayor distribuido mundialmente compartido. Para ello, las numerosas soluciones que utilizan el software de Corda deben cumplir un conjunto de estándares y criterios comunes. Algunos de estos criterios, a menudo conocidos como principios de estado final, son los siguientes:

  • Identidad asegurada: Las partes tendrán confianza en las identidades de los participantes de la red. La identificación en Corda está representada por un certificado emitido por una autoridad relevante
  • Privacidad: las únicas personas que tienen acceso a la información de la transacción son aquellas que están involucradas en la transacción y aquellas que necesitan verificar el origen de la transacción.
  • Interoperabilidad: Corda está destinado a permitir que numerosas aplicaciones coexistan e interoperen en la misma red; se proporciona un conjunto definido de interfaces de contrato para optimizar la interoperabilidad de una amplia gama de proveedores

Componentes clave de CorDapps

CorDapp es una abreviatura de aplicación distribuida de Corda. CorDapps son aplicaciones distribuidas que se ejecutan en el nodo de Corda. Los siguientes son los componentes clave de una CorDapp:

estados

Los estados están hechos de datos. Realizan un seguimiento de los datos entre transacciones y son inmutables, lo que significa que no se pueden cambiar una vez que se han formado. En cambio, cualquier modificación debe dar como resultado la creación de un nuevo estado sucesor.

Contratos

Los contratos definen los criterios de validación que se aplicarán a las entradas y salidas de transacciones. Los contratos garantizan que los estados de entrada y salida de la transacción son válidos y que se evitan las transacciones no válidas. Pueden existir uno o más contratos en una CorDapp, cada uno de los cuales proporciona reglas para uno o más estados.

Flujos

Los flujos son las actividades que su CorDapp puede realizar en una red y constituyen la lógica comercial de su CorDapp. Los flujos permiten a las partes coordinar sus operaciones sin el uso de un controlador central.

Actas

Una transacción es una solicitud de actualización del libro mayor. Consume los estados de entrada actuales y genera otros nuevos para actualizar el libro mayor. Antes de que los nodos acepten una transacción, esta debe ser única, válida y estar firmada por las partes correspondientes.

Notario

Un notario es un servicio de la red de Corda que ayuda a evitar el gasto duplicado de los activos de la red. Lo hace garantizando que cada transacción solo incluya estados de entrada únicos que no hayan sido utilizados por una transacción anterior. Un notario también da una finalidad de transacción. Una transacción se considera finalizada después de que haya sido firmada por el notario.

Consenso

En Corda, puede establecer un consenso probando una transacción que sea válida y única. El consenso es un método que permite a los nodos ponerse de acuerdo sobre el estado actual de la red. Antes de que una transacción propuesta pueda ingresarse en el libro mayor, ambas partes deben estar de acuerdo en que es legal.

Primeros pasos con Corda

Crearemos una CorDapp para modelar la emisión de tokens en la cadena de bloques de Corda. Nuestro CorDapp hará un seguimiento del emisor del token, el titular y la cantidad que se emite.

Hay cuatro piezas de software necesarias para el desarrollo de CorDapp:

  • Java 8 JDK
  • IDEA IntelliJ
  • Git
  • Gradle, cualquier versión entre 5.1 y 5.6.4

configurando

Para configurar nuestra CorDapp, primero, clone la plantilla Corda Java de su repositorio de GitHub. Abra cordapp-template-javaen cualquier IDE de su elección. Usaré IntelliJ IDE.

Crear el Estado

Para reiterar, los estados son inmutables y realizan un seguimiento de los datos entre transacciones. Nuestra CorDapp tendrá un conjunto de atributos que almacenaremos en nuestro estado, como issuer, holdery amount.

Navegue /contracts/src/main/java/com/template/statesy cree una nueva clase de Java llamada TokenState:

package com.template.states

import com.template.contracts.TokenContract;
import net.corda.core.identity.AbstractParty;
import net.corda.core.contracts.BelongsToContract;
import net.corda.core.contracts.ContractState;
import net.corda.core.identity.Party;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
import java.util.List;

@BelongsToContract(TokenContract.class)
public class TokenState implements ContractState {
    private Party issuer;
    private Party holder;
    private int amount;

    public TokenState(Party issuer, Party holder, int amount){
        this.issuer = issuer;
        this.holder = holder;
        this.amount = amount;
    }

    public Party getHolder() {
        return holder;
    }

    public Party getIssuer() {
        return issuer;
    }

    public int getAmount() {
        return amount;
    }

    @NotNull
    @Override
    public List<AbstractParty> getParticipants() {
        return Arrays.asList(issuer, holder);
    }
}

En el código anterior, creamos una clase llamada TokenStateque hereda de la ContractStateclase. La ContractStateclase le dice a Corda que estamos implementando un estado.

A continuación, añadimos la @BelongsToContractanotación, que establece la relación entre un estado y un contrato. Sin esto, su estado no sabe qué contrato se utiliza para verificarlo. Agregar esta anotación desencadena un error en IntelliJ porque aún tenemos que crear nuestro archivo TokenContract.

Luego, creamos tres atributos, issuer, holdery amount. Los atributos issuery holderreciben un tipo de Partyporque ambos representan entidades en el nodo.

A continuación, creamos tres métodos captadores para cada uno de los atributos. Finalmente, creamos un getParticipantsmétodo que define qué partes deben estar al tanto de la transacción. En nuestro caso, solo queremos que el issuery el holdersean conscientes de la transacción.

Crear el contrato

Para reiterar, los contratos definen las reglas de cómo los estados pueden evolucionar. Realizan ciertas validaciones antes de que una transacción se realice con éxito. Por lo tanto, cada estado está vinculado a un contrato.

Navegue /contracts/src/main/java/com/template/contractsy cree una nueva clase de Java llamada TokenContract:

package com.template.contracts

import net.corda.core.contracts.CommandData;
import net.corda.core.contracts.Contract;
import net.corda.core.transactions.LedgerTransaction;

import org.jetbrains.annotations.NotNull;
import com.template.states.TokenState;


public class TokenContract implements Contract {
    public static final String ID = "contracts.TokenContract";

    @Override
    public void verify(@NotNull LedgerTransaction tx) {

        if(tx.getCommands().size() != 1) {
            throw new IllegalArgumentException("expects only one command: ISSUE");
        }
        if(tx.getCommand(0).getValue() instanceof Commands.Issue){
            throw new IllegalArgumentException("issue command expected");
        }
        TokenState state = (TokenState) tx.getOutput(0);
        int amountIssued = state.getAmount();
        if (amountIssued <= 0){
            throw new IllegalArgumentException("amount must be greater than zero");
        }
        if(! (tx.getCommand(0).getSigners().contains(state.getIssuer().getOwningKey()))){
            throw new IllegalArgumentException("transaction must be signed by issuer");
        }
    }
    // Used to indicate the transaction's intent.
    public interface Commands extends CommandData {
        class Issue implements Commands {}
    }
}

En el código anterior, creamos una clase llamada TokenContractque hereda de la Contractclase. La Contractclase le dice a Corda que estamos implementando un contrato.

Primero, creamos un atributo llamado IDque identificará nuestro contrato al construir nuestra transacción en entornos de prueba. El IDatributo es puramente opcional.

Uno de los métodos que nos da la Contractclase que heredamos es el verifymétodo, que debemos anular. El verifymétodo toma transacciones como entrada y las evalúa contra reglas definidas. Una transacción es válida si el verifymétodo no arroja una excepción.

Con el código anterior, nuestro contrato realiza las siguientes comprobaciones:

  • Las transacciones deben ser firmadas por el emisor.
  • El monto debe ser mayor que cero
  • Solo issuese puede usar el comando
  • Estado de entrada inicial cero ya que es una emisión

Finalmente, dado que tenemos la intención de emitir el token a otra parte, creamos una clase llamada Issueque hereda de la Commandclase. La Commandclase se utiliza para indicar el tipo de acción que se está realizando.

Escribir el flujo de inicio

Para reiterar, los flujos contienen la lógica comercial de nuestra CorDapp. El flujo del iniciador lo ejecuta el nodo que inicia la transacción, que sería issueren nuestro caso.

Navegue workflows/src/main/java/com/template/flowsy cree una nueva clase de Java llamada FlowInitiator:

package com.template.flows;

import co.paralleluniverse.fibers.Suspendable;
import com.bootcamp.contracts.TokenContract;
import com.bootcamp.states.TokenState;
import net.corda.core.flows.*;
import net.corda.core.identity.CordaX500Name;
import net.corda.core.identity.Party;
import net.corda.core.transactions.SignedTransaction;
import net.corda.core.transactions.TransactionBuilder;
import net.corda.core.utilities.ProgressTracker;
import net.corda.core.contracts.CommandData;

import static java.util.Collections.singletonList;

    @InitiatingFlow
    @StartableByRPC
    public static class TokenFlowInitiator extends FlowLogic<SignedTransaction> {
        private final Party owner;
        private final int amount;

        public TokenFlowInitiator(Party owner, int amount) {
            this.owner = owner;
            this.amount = amount;
        }

        private final ProgressTracker progressTracker = new ProgressTracker();

        @Override
        public ProgressTracker getProgressTracker() {
            return progressTracker;
        }

        @Suspendable
        @Override
        public SignedTransaction call() throws FlowException {

            /** Explicit selection of notary by CordaX500Name - argument can by coded in flows or parsed from config (Preferred)*/
            final Party notary = getServiceHub().getNetworkMapCache().getNotary(CordaX500Name.parse("O=Notary,L=London,C=GB"));
            // We get a reference to our own identity.
            Party issuer = getOurIdentity();

            /* ============================================================================
             *         TODO 1 - Create our TokenState to represent on-ledger tokens!
             * ===========================================================================*/
            // We create our new TokenState.
            TokenState tokenState = new TokenState(issuer, owner, amount);

            /* ============================================================================
             *      TODO 3 - Build our token issuance transaction to update the ledger!
             * ===========================================================================*/
            // We build our transaction.
            TransactionBuilder transactionBuilder = new TransactionBuilder.setNotary(notary).addOutputState(tokenState).addCommand(new TokenContract.Commands.Issue(), Arrays.asList(issuer.getOwningKey(), owner.getOwningKey()));

            /* ============================================================================
             *          TODO 2 - Write our TokenContract to control token issuance!
             * ===========================================================================*/
            // We check our transaction is valid based on its contracts.
            transactionBuilder.verify(getServiceHub());

            FlowSession session = initiateFlow(owner);

            // We sign the transaction with our private key, making it immutable.
            SignedTransaction signedTransaction = getServiceHub().signInitialTransaction(transactionBuilder);

            // The counterparty signs the transaction
            SignedTransaction fullySignedTransaction = subFlow(new CollectSignaturesFlow(signedTransaction, singletonList(session)));

            // We get the transaction notarised and recorded automatically by the platform.
            return subFlow(new FinalityFlow(fullySignedTransaction, singletonList(session)));
        }
    }

En el código anterior, creamos una clase llamada TokenFlowInitiatorque hereda de la FlowLogicclase. La FlowLogicclase le dice a Corda que estamos creando un Flujo.

Luego, agregamos dos anotaciones, @InitiatingFlowy @StartableByRPC. La @InitiatingFlowanotación indica que este flujo es el flujo iniciador. Por otro lado, la @StartableByRPCanotación permite que RPC inicie el flujo.

A continuación, creamos una variable llamada progressTrackerque marca puntos de control en cada etapa del flujo y genera los mensajes especificados cuando se alcanza cada punto de control en el código.

A continuación, creamos el callmétodo, al que llama Corda cuando se inicia el flujo. Dentro del callmétodo, primero creamos un notario y lo almacenamos en una variable llamada notary. Dado que estamos tratando con múltiples partes, necesitamos un servicio de notario para llegar a un consenso entre las partes.

Obtenemos nuestra identidad y la almacenamos en una variable llamada issuer. A continuación, creamos nuestro token creando una nueva instancia de TokenStatey pasando los argumentos issuer, ownery .amount

Luego, construimos nuestra propuesta de transacción creando una nueva instancia de TransactionBuilder. Encadenamos diferentes métodos para configurar nuestro notario, agregar comandos y firmar la transacción.

Finalmente, comenzamos FlowSessioncon la contraparte utilizando el InitiateFlowmétodo. Este proceso nos permite enviar el estado a la contraparte. Luego llamamos al CollectSignaturesFlowsubflujo para recopilar firmas.

Escribir el flujo de respuesta

El flujo de respuesta lo ejecuta la contraparte. Recibe y registra la transacción, luego responde al flujo del emisor enviando un acuse de recibo si la transacción fue exitosa.

Navegue workflows/src/main/java/com/template/flowsy cree una nueva clase de Java llamada TokenFlowResponder:

package com.template.flows;

import co.paralleluniverse.fibers.Suspendable;
import net.corda.core.flows.*;
import net.corda.core.identity.Party;
import net.corda.core.transactions.SignedTransaction;


@InitiatedBy(TokenFlowInitiator.class)
    public static class TokenFlowResponder extends FlowLogic<Void>{
        //private variable
        private FlowSession counterpartySession;

        //Constructor
        public TokenFlowResponder(FlowSession counterpartySession) {
            this.counterpartySession = counterpartySession;
        }

        @Suspendable
        @Override
        public Void call() throws FlowException {
            SignedTransaction signedTransaction = subFlow(new SignTransactionFlow(counterpartySession) {});

            //Stored the transaction into data base.
            subFlow(new ReceiveFinalityFlow(counterpartySession, signedTransaction.getId()));
            return null;
        }
    }

En el código anterior, creamos una clase llamada TokenFlowResponderque hereda de la FlowLogicclase. Luego agregamos la @InitiatedByanotación y pasamos la TokenFlowInitiatorclase como argumento, diciéndole a Corda quién inició el flujo.

Luego, creamos el callmétodo con un subFlowque verificará la transacción y las firmas que recibió del iniciador del flujo. Opcionalmente, podemos crear convencionalmente un nuevo método llamado checkTransactionpara realizar una serie de pruebas solo para estar seguros.

Ejecutando nuestra CorDapp

Para iniciar nuestra CorDapp, primero debemos implementarla navegando a la raíz de nuestro proyecto y ejecutando los siguientes comandos:

#Mac or Linux
./gradlew clean deployNodes

#Windows
gradlew.bat clean deployNodes

Si nuestra CorDapp se construye con éxito, genera tres nodos con la CorDapp instalada en ellos. Estos se pueden encontrar en la build/nodescarpeta.

Inicie la aplicación CorDapp de muestra

Para iniciar los nodos y nuestra CorDapp, ejecute el siguiente comando desde nuestro directorio raíz:

#Mac or Linux
./build/nodes/runnodes

#Windows
.\build\nodes\runnodes.bat

El código anterior iniciará una nueva ventana de terminal para cada nodo. Dé a cada terminal algo de tiempo para comenzar y recibirá un mensaje de bienvenida en el terminal una vez que el nodo esté listo.

Interactuando con nuestra CorDapp

Para verificar si nuestro CorDapp funcionó correctamente, podemos intentar iniciar un flujo ejecutando el siguiente comando:

flow start TokenFlowInitiator owner: PartyB, amount: 100

Si tiene éxito, recibirá un mensaje de confirmación.

Conclusión

La cadena de bloques es una tecnología que cambia las reglas del juego, y las empresas reguladas no se quedan fuera de este cambio gracias a los sistemas que utilizan cadenas de bloques privadas. Los proyectos de cadena de bloques como Corda brindan a las empresas la flexibilidad que necesitan y, al mismo tiempo, mantienen la privacidad de los datos. En este artículo, exploramos cómo empezar con Corda, aprendiendo cómo hacer CorDapps.

Espero que hayas disfrutado este tutorial, y no dudes en dejar un comentario si tienes alguna pregunta.

 Fuente: https://blog.logrocket.com/how-to-write-dapps-corda/

#dapp #corda #blockchain