FCL SDK Reference

[Previous << FCL Reference](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de)
[Next >> Authentication](https://qiita.com/flowcadence/items/07695f36283735c00a71)

https://qiita.com/flowcadence/items/3073d69c6e9895e68b5a#reference-2020832ebee1810a325a

<h1>Overview</h1>

このリファレンスでは、FCL経由でアクセスできるSDKで利用可能なメソッドを説明し、それらのメソッドの動作について詳しく説明しています。FCL/SDKはオープンソースであり、ライセンスに従ってご利用いただけます。

ライブラリクライアントの仕様は、こちらでご覧いただけます。

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de)

<h1>Getting Started</h1>
<h3>Installing</h3>

FCL経由でFlow SDKにアクセスしますのでFCLをインストールします。

NPM:
```ruby
npm install --save @onflow/fcl @onflow/types
```
Yarn:
```ruby
yarn add @onflow/fcl @onflow/types
```

<h3>Importing the Library</h3>

javascriptでインポートできます。
```ruby
import * as fcl from "@onflow/fcl"
import * as types from "@onflow/types"
```

<h1>Connect</h1>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://developers.flow.com/tools/clients/fcl-js/configure-fcl)

デフォルトでは、ライブラリはアクセスノードとの通信にHTTPを使用します。そして、正しいアクセスノードAPI URLで設定されていといけません。ホストに到達できない場合、エラーが返されます。

📖**HTTP/REST APIの情報**は[こちら](https://developers.flow.com/http-api)でご確認いただけます。Flow HTTP/RESTのパブリックアクセスノードは、以下からアクセスできます。

* Testnet `https://rest-testnet.onflow.org`
* Mainnet `https://rest-mainnet.onflow.org`
* Local Emulator `127.0.0.1:8888`

Example:
```ruby
import { config } from "@onflow/fcl"

config({
  "accessNode.api": "https://rest-testnet.onflow.org"
})
```

<h1>Querying the Flow Network</h1>

アクセスノードとの接続が確立されたら、Flowネットワークにqueryで問い合わせて、ブロック、アカウント、イベント、トランザクションに関するデータを取得することができます。以下では、これらのデータをそれぞれ取得する方法について説明していきます。

<h3>Get Blocks</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#getblock)

ネットワークにIDと高さによるブロックをqueryします、または最新のブロックの取得します。

📖 **ブロックID**は、ブロックペイロード全体のSHA3-256 hashです。このハッシュは、（`GetLatestBlock`からのレスポンスなど）ブロックレスポンスオブジェクトのIDとして保存されています。

📖 **ブロック高さ**は、チェーン上のブロックの高さを表します。最新のブロック高さは、有効なブロックが生成されるごとに1ずつ増加します。

**Examples**
この例では、最新のブロックの取得方法と、高さまたはIDによるその他のブロックの取得方法を説明しています。

```ruby
import * as fcl from "@onflow/fcl";

/* Get latest block */
const latestBlock = await fcl.latestBlock(true); // If true, get the latest sealed block

/* Get block by ID (uses builder function) */
await fcl.send([fcl.getBlock(), fcl.atBlockId("23232323232")]).then(fcl.decode);

/* Get block at height (uses builder function) */
await fcl.send([fcl.getBlock(), fcl.atBlockHeight(123)]).then(fcl.decode)
```
Result output: [BlockObject](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#blockobject)

<h3>Get Account</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#account)

任意のアカウントを、Flowネットワークの最新ブロックまたは指定したブロック高さから取得します。

📖 **Account address**は、アカウントを一意に識別するものです。`0x`という接頭辞に注意してください。デフォルトの表現ではこの接頭辞を使うべきですが、ユーザーが入力する接頭辞がない表現については慎重に安全に処理してください。

アカウントには以下のデータが含まれます。
* Address：アカウントのアドレス。
* Balance：アカウントの残高。
* Contracts：アカウントにデプロイされたコントラクトのリスト。
* Keys：アカウントに関連付けられたキーのリスト。

**Examples**
最新のブロックからと、特定のブロック高さからアカウントを取得する方法を例示します。
```ruby
import * as fcl from "@onflow/fcl";

/* Get account from latest block height */
const account = await fcl.account("0x1d007d755706c469");

/* Get account at a specific block height */
fcl.send([
  fcl.getAccount("0x1d007d755706c469"),
  fcl.atBlockHeight(123)
]);
```
Result output: [AccountObject](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#accountobject)
<h3>Get Transactions</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#gettransaction)

トランザクションIDを指定して、ネットワークからトランザクションを取得します。 トランザクションを送信した後、ステータスを確認するためにトランザクションの結果を取得することもできます。

📖 **トランザクションID**は、エンコードされたトランザクションペイロードのハッシュであり、ネットワークにトランザクションを送信する前に計算することができます。

⚠️ 提供するトランザクションIDは、直近のspork以降のものでなければなりません。

📖 **トランザクションステータス**は、ブロックチェーン上のトランザクションの状態を表します。ステータスは、sealedされるまでは変更される可能性があります。
| Status | Final | Description |
|:-:|:-:|:-:|
| UNKNOWN | ❌ | The transaction has not yet been seen by the network |
| PENDING | ❌ | The transaction has not yet been included in a block |
| FINALIZED | ❌ | The transaction has been included in a block |
| EXECUTED | ❌ | The transaction has been executed but the result has not yet been sealed |
| SEALED | ✅ | The transaction has been executed and the result is sealed in a block |
| EXPIRED | ✅ | The transaction reference block is outdated before being executed |

```ruby
import * as fcl from "@onflow/fcl";

/* Snapshot the transaction at a point in time */
fcl.tx(transactionId).snapshot();

/* Subscribe to a transaction's updates */
fcl.tx(transactionId).subscribe(callback);

/* Provides the transaction once the status is finalized */
fcl.tx(transactionId).onceFinalized();

/* Provides the transaction once the status is executed */
fcl.tx(transactionId).onceExecuted();

/* Provides the transaction once the status is sealed */
fcl.tx(transactionId).onceSealed();
```
Result output: [TransactionStatusObject](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#gettransactionstatus)

<h3>Get Events</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#geteventsatblockheightrange)

指定されたブロックの高さの範囲内にある、またはブロックIDのリストから、指定された型のイベントを取得します。

📖 **Event type**は、標準フォーマットに従った文字列です。
```ruby
A.{contract address}.{contract name}.{event name}
```
[イベントに関する詳細をドキュメント](https://qiita.com/flowcadence/items/5e0aea26c0ce24fab7e9)で確認してください。このスタンダードに対する例外はcore eventsであり、[このドキュメント](https://qiita.com/flowcadence/items/5e0aea26c0ce24fab7e9)で詳細をご確認ください。

📖 **Block height range**は、チェーン内の開始ブロックと終了ブロックの高さを表します。

**Examples**

ブロックの範囲内および複数のブロックIDでイベントを取得する方法を示します。

```ruby
import * as fcl from "@onflow/fcl";

/* Get events at block height range */
await fcl
  .send([
    fcl.getEventsAtBlockHeightRange(
      "A.7e60df042a9c0868.FlowToken.TokensWithdrawn", /* event name */
      35580624, /* block to start looking for events at */
      35580624
      /* block to stop looking for events at */
    ),
  ])
  .then(fcl.decode);

/* Get events from list of block ids */
await fcl
  .send([
    fcl.getEventsAtBlockIds("A.7e60df042a9c0868.FlowToken.TokensWithdrawn", [
      "c4f239d49e96d1e5fbcf1f31027a6e582e8c03fcd9954177b7723fdb03d938c7",
      "5dbaa85922eb194a3dc463c946cc01c866f2ff2b88f3e59e21c0d8d00113273f",
    ]),
  ])
  .then(fcl.decode);
```
Result output: [EventObject](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#event-object)

<h3>Get Collections</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#getcollection)

同じブロックに含まれているトランザクションの塊を取得します。これを**collections**と呼びます。コレクションは、ブロックあたりのトランザクション数を増やすことで、コンセンサス処理のスループットを向上させるために使用され、それらはブロックとトランザクションの間のリンクとして働きます。

📖 **コレクションID**は、collectionペイロードのSHA3-256ハッシュです。

コレクションの取得例：
```ruby
import * as fcl from "@onflow/fcl";

const collection = await fcl
  .send([
    fcl.getCollection(
      "cccdb0c67d015dc7f6444e8f62a3244ed650215ed66b90603006c70c5ef1f6e5"
    ),
  ])
  .then(fcl.decode);
```
Result output: [CollectionObject](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#collectionobject)

<h3>Execute Scripts</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#query%E3%82%B9%E3%82%AF%E3%83%AA%E3%83%97%E3%83%88)

スクリプトを使用すると、Flowブロックチェーン上で変更が発生しない任意のCadenceコードを書いて、そのデータを受け取ることができます。[Cadenceはこちらに](https://qiita.com/flowcadence/items/9b08c176d64eff402a4d)、[スクリプトについてはこちら](https://qiita.com/flowcadence/items/ef8373ed9471362f7132)で詳しく説明されていますが、現時点で私達はスクリプトコードの実行とデータの取得のみに興味を持ちます。

Flowブロックチェーンの最新の状態に対してスクリプトを実行することもできますし、ブロックの高さまたはブロックIDで定義されたヒストリーの特定の時点でスクリプトを実行することもできます。

📖 **ブロックID**はブロックのペイロード全体の SHA3-256 ハッシュですが、ブロックのレスポンスのプロパティからその値を取得できます。

📖 **ブロック高さ**はチェーン内のブロックの高さを表します。
```ruby
import * as fcl from "@onflow/fcl";

const result = await fcl.query({
  cadence: `
    access(all) fun main(a: Int, b: Int, addr: Address): Int {
      log(addr)
      return a + b
    }
  `,
  args: (arg, t) => [
    arg(7, t.Int), // a: Int
    arg(6, t.Int), // b: Int
    arg("0xba1132bc08f82fe2", t.Address), /* addr: Address */
  ],
});
```
Example output:
```ruby
console.log(result); /* 13 */
```

<h1>Mutate Flow Network</h1>

Flowは、他の多くのブロックチェーンと同じ様に、共有されたグローバルチェーンの状態を変化させるトランザクションを誰でも送信することができます。トランザクションは、状態の変化を記述したペイロードと、特定アカウントによる所有状態の変化を許可した1つ以上の承認、を含むオブジェクトです。

トランザクションデータは、SDKの助けを借りて、作成/署名されます。署名されたトランザクションのペイロードは、その後、アクセスノードAPIに送信されます。トランザクションが無効であった場合、または正しい数の承認署名が用意されていなかった場合、トランザクションは拒否されます。
<h1>Transactions</h1>

トランザクションとは署名済みのデータセットでしかなく、どのようにネットワークの状態を変化させるかと、その実行を定義したり制限したりするプロパティを指示したスクリプト・コードを含んでいます。これらのプロパティについては、以下で説明します。

📖 **Script**フィールドは、状態の変化のロジックを記述するトランザクションの一部です。Flowでは、トランザクションロジックは[Cadence](https://qiita.com/flowcadence/items/87147a26f1d2b89b46ca)で書かれます。以下は、トランザクションのスクリプトの例です。
```ruby
transaction(greeting: String) {
  execute {
    log(greeting.concat(", World!"))
  }
}
```
📖 **Arguments**: トランザクションは、Cadenceスクリプトに渡されるゼロ個以上の引数を受け入れることができます。トランザクションの引数は、Cadenceスクリプト内で宣言された数と順序と一致する必要があります。上記のサンプルスクリプトでは、単一の`String`引数を受け入れています。

📖 [**Proposal key**](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#proposal-key)は、シーケンス番号として機能し、リプレイ攻撃やその他の潜在的な攻撃を防止するために、提供されなければなりません。

各アカウントのキーは別個のトランザクションのシーケンス番号を管理しています。トランザクションにそのシーケンス番号を付与するキーは、提案キー(proposal key)と呼ばれます。

提案キーは3つのフィールドを含みます。
* Account address
* Key index
* Sequence number

トランザクションは、宣言されたシーケンス番号がそのキーの現在のチェーン上のシーケンス番号と一致する場合のみ有効です。トランザクションが実行された後、シーケンス番号は1つインクリメントされます。

📖 [**Payer**](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signer-roles)は、トランザクションの料金を支払うアカウントです。トランザクションは、必ず1つのPayerを指定する必要があります。Payerは、ネットワーク料金とガス料金の支払いの責任を負うのみであり、トランザクションはPayerアカウントに保存されているリソースやコードにアクセスする権限はありません。

📖 [**Authorizers**](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signer-roles)とは、トランザクションがリソースを読み取り、変更することを承認するアカウントです。トランザクションは、アクセスする必要のあるアカウントの数に応じて、authorizerをゼロまたは複数指定できます。

トランザクションの承認者の数は、Cadenceスクリプトのprepareステートメントで宣言された`&Account`パラメータの数と一致する必要があります。

複数の承認者を含むトランザクションの例：
```ruby
transaction {
  prepare(authorizer1: &Account, authorizer2: &Account) { }
}
```
📖 **Gas limit**とは、トランザクションに必要な計算量の制限値であり、ガスリミットを超えると処理が中断されます。Cadenceでは、トランザクションごとの操作数を計測によって測定しています。詳細は、[Cadenceのドキュメント](https://qiita.com/flowcadence/items/87147a26f1d2b89b46ca)を参照してください。

ガスリミットは、トランザクションスクリプトの複雑さによって異なります。専用のガス測定ツールが利用可能になるまでは、エミュレータを使用して複雑なトランザクションをテストし、安全なリミットを決定することをお勧めします。

📖 **Reference block(参照ブロック)** は、ネットワークによってトランザクションが有効とみなされる、expiration window(有効期限の期間)（ブロック単位）を指定します。 トランザクションがexpiry block(有効期限ブロック)を過ぎて送信された場合、そのトランザクションは拒否されます。 Flowは、トランザクション上の*Reference block(参照ブロック)* フィールドを使用してトランザクションの有効期限を計算します。 トランザクションは、`600`ブロックがReference block(参照ブロック)の上にコミットされると有効期限切れとなり、これは平均的なMainnetブロックレートでは約10分かかります。

<h3>Mutate</h3>

[![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3912821/f8144689-226d-f3a6-80a8-deebafb9e1fb.png)](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#mutate%E3%83%88%E3%83%A9%E3%83%B3%E3%82%B6%E3%82%AF%E3%82%B7%E3%83%A7%E3%83%B3)

FCLの「mutate」は、トランザクションの構築、署名、送信(building, signing, and sending a transaction)を裏側で実行します。FCLを使用してブロックチェーンの状態を変更するには、以下を行います。

```ruby
import * as fcl from "@onflow/fcl"

await fcl.mutate({
  cadence: `
    transaction(a: Int) {
      prepare(acct: &Account) {
        log(acct)
        log(a)
      }
    }
  `,
  args: (arg, t) => [
    arg(6, t.Int)
  ],
  limit: 50
})
```
Flowはトランザクションの署名に関しては、高い柔軟性をサポートしており、複数の承認者（マルチシグ取引）を定義したり、提案者とは異なる支払者アカウントを持つことができます。以下では、高度な署名シナリオについて説明します。

### [Single party, single signature](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#single-party-single-signature)

* Proposer, payer and authorizer are the same account (`0x01`).
* Only the envelope must be signed.
* Proposal key must have full signing weight.

| Account | Key ID | Weight |
|:-:|:-:|:-:|
| `0x01` | 1 | 1000 |

```ruby
/* There are multiple ways to acheive this */
import * as fcl from "@onflow/fcl"

/* FCL provides currentUser as an authorization function */
await fcl.mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  proposer: currentUser,
  payer: currentUser,
  authorizations: [currentUser],
  limit: 50,
})

/* Or, simplified */

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  authz: currentUser, /* Optional. Will default to currentUser if not provided. */
  limit: 50,
})


/* Or, create a custom authorization function */
const authzFn = async (txAccount) => {
  return {
    ...txAccount,
    addr: "0x01",
    keyId: 0,
    signingFunction: async(signable) => {
      return {
        addr: "0x01",
        keyId: 0,
        signature
      }
    }
  }
}

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  proposer: authzFn,
  payer: authzFn,
  authorizations: [authzFn],
  limit: 50,
})
```
### [Single party, multiple signatures](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#single-party-multiple-signatures)

* Proposer, payer and authorizer are the same account (`0x01`).
* Only the envelope must be signed.
* Each key has weight 500, so two signatures are required.

| Account | Key ID | Weight |
|:-:|:-:|:-:|
| `0x01` | 1 | 500 |
| `0x01` | 2 | 500 |

```ruby
import * as fcl from "@onflow/fcl"

const authzFn = async (txAccount) => {
  return [
    {
      ...txAccount,
      addr: "0x01",
      keyId: 0,
      signingFunction: async(signable) => {
        return {
          addr: "0x01",
          keyId: 0,
          signature
        }
      }
    },
    {
      ...txAccount,
      addr: "0x01",
      keyId: 1,
      signingFunction: async(signable) => {
        return {
          addr: "0x01",
          keyId: 1,
          signature
        }
      }
    }
  ]
}

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  proposer: authzFn,
  payer: authzFn,
  authorizations: [authzFn],
  limit: 50,
})
```
### [Multiple parties](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#multiple-parties)

* Proposer and authorizer are the same account (`0x01`).
* Payer is a separate account (`0x02`).
* Account `0x01` signs the payload.
* Account `0x02` signs the envelope.
  * Account `0x02` must sign last since it is the payer.

| Account | Key ID | Weight |
|:-:|:-:|:-:|
| `0x01` | 1 | 1000 |
| `0x02` | 3 | 1000 |

```ruby
import * as fcl from "@onflow/fcl"

const authzFn = async (txAccount) => {
  return {
    ...txAccount,
    addr: "0x01",
    keyId: 0,
    signingFunction: async(signable) => {
      return {
        addr: "0x01",
        keyId: 0,
        signature
      }
    }
  }
}

const authzTwoFn = async (txAccount) => {
  return {
    ...txAccount,
    addr: "0x02",
    keyId: 0,
    signingFunction: async(signable) => {
      return {
        addr: "0x02",
        keyId: 0,
        signature
      }
    }
  }
}

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  proposer: authzFn,
  payer: authzTwoFn,
  authorizations: [authzFn],
  limit: 50,
})
```
### [Multiple parties, two authorizers](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#multiple-parties)

* Proposer and authorizer are the same account (`0x01`).
* Payer is a separate account (`0x02`).
* Account `0x01` signs the payload.
* Account `0x02` signs the envelope.
  * Account `0x02` must sign last since it is the payer.
* Account `0x02` is also an authorizer to show how to include two `&Account` objects into an transaction

| Account | Key ID | Weight |
|:-:|:-:|:-:|
| `0x01` | 1 | 1000 |
| `0x02` | 3 | 1000 |

```ruby
import * as fcl from "@onflow/fcl"

const authzFn = async (txAccount) => {
  return {
    ...txAccount,
    addr: "0x01",
    keyId: 0,
    signingFunction: async(signable) => {
      return {
        addr: "0x01",
        keyId: 0,
        signature
      }
    }
  }
}

const authzTwoFn = async (txAccount) => {
  return {
    ...txAccount,
    addr: "0x02",
    keyId: 0,
    signingFunction: async(signable) => {
      return {
        addr: "0x02",
        keyId: 0,
        signature
      }
    }
  }
}

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account, acct2: &Account) {}
    }
  `,
  proposer: authzFn,
  payer: authzTwoFn,
  authorizations: [authzFn, authzTwoFn],
  limit: 50,
})
```
### [Multiple parties, multiple signatures](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#multiple-parties-multiple-signatures)

* Proposer and authorizer are the same account (`0x01`).
* Payer is a separate account (`0x02`).
* Account `0x01` signs the payload.
* Account `0x02` signs the envelope.
  * Account `0x02` must sign last since it is the payer.
* Both accounts must sign twice (once with each of their keys).

| Account | Key ID | Weight |
|:-:|:-:|:-:|
| `0x01` | 1 | 500 |
| `0x01` | 2 | 500 |
| `0x02` | 3 | 500 |
| `0x02` | 4 | 500 |

```ruby
import * as fcl from "@onflow/fcl"

const authzFn = async (txAccount) => {
  return [
    {
      ...txAccount,
      addr: "0x01",
      keyId: 0,
      signingFunction: async(signable) => {
        return {
          addr: "0x01",
          keyId: 0,
          signature
        }
      }
    },
    {
      ...txAccount,
      addr: "0x01",
      keyId: 1,
      signingFunction: async(signable) => {
        return {
          addr: "0x01",
          keyId: 1,
          signature
        }
      }
    }
  ]
}

const authzTwoFn = async (txAccount) => {
  return [
    {
      ...txAccount,
      addr: "0x02",
      keyId: 0,
      signingFunction: async(signable) => {
        return {
          addr: "0x02",
          keyId: 0,
          signature
        }
      }
    },
    {
      ...txAccount,
      addr: "0x02",
      keyId: 1,
      signingFunction: async(signable) => {
        return {
          addr: "0x02",
          keyId: 1,
          signature
        }
      }
    }
  ]
}

mutate({
  cadence: `
    transaction {
      prepare(acct: &Account) {}
    }
  `,
  proposer: authzFn,
  payer: authzTwoFn,
  authorizations: [authzFn],
  limit: 50,
})
```
トランザクションが**構築され**、**署名され**ると、Flowブロックチェーンに送信され、そこで実行されます。送信が成功した場合、[トランザクションの結果を取得](#get-transactions)できます。

*Last updated on **Dec 11, 2024** by **Chase Fleming***

翻訳元

https://developers.flow.com/tools/clients/fcl-js/sdk-guidelines

***



<b>Flow BlockchainのCadence version1.0ドキュメント (FCL SDK Reference)</b>



***
<b>[Previous << FCL Reference](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de)
</b>

[Flow blockchain / Cadence version1.0ドキュメント](https://qiita.com/flowcadence/items/3073d69c6e9895e68b5a) (FCL SDK Reference)

<b>[Next >> Authentication](https://qiita.com/flowcadence/items/07695f36283735c00a71)</b>