Flow Client Library (FCL) API Reference

[Previous << Flow Client Library (FCL)](https://qiita.com/flowcadence/items/4174cc0ae785b1ddb1d6)
[Next >> FCL SDK Reference](https://qiita.com/flowcadence/items/c1a1364b2dba4262bdc1)

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

>For release updates, [see the repo](https://github.com/onflow/fcl-js/releases)

<h1>Configuration(設定)</h1>

FCLには、FCLのさまざまな側面(aspect)を設定できる仕組みがあります。Flow Blockchainのインスタンスを（ローカルのエミュレーターからテストネット、メインネットへと）移動させる時、あなたが必要なFCLの実装はコンフィグレーションだけで済みます。
***
<h3>Setting Configuration Values</h3>

値の設定は一度だけ行います。この設定はできるだけ早い段階に行うのがお勧めです。 設定値をセットするには、`config` インスタンス上で`put`メソッドを呼び出す必要があります。`put`メソッドは`config`インスタンスを返しますので、チェイニングができます。

または、JSONオブジェクトを直接渡してコンフィグをセットすることもできます。
```ruby
import * as fcl from '@onflow/fcl';

fcl
  /* returns the config instance */
  .config()
  /* configures "foo" to be "bar" */
  .put('foo', 'bar')
  /* configures "baz" to be "buz" */
  .put('baz', 'buz');

/* OR */

fcl.config({
  foo: 'bar',
  baz: 'buz',
});
```
<h3>Getting Configuration Values</h3>

`config`インスタンスには非同期の`get`メソッドがあり、設定値を取得できます。また、フォールバック値も渡すことができます。
```ruby
import * as fcl from '@onflow/fcl';

fcl.config().put('foo', 'bar').put('woot', 5).put('rawr', 7);

const FALLBACK = 1;

async function addStuff() {
  var woot = await fcl.config().get('woot', FALLBACK); /* will be 5 -- set in the config before */
  var rawr = await fcl.config().get('rawr', FALLBACK); /* will be 7 -- set in the config before */
  var hmmm = await fcl.config().get('hmmm', FALLBACK); /* will be 1 -- uses fallback because this isnt in the config */

  return woot + rawr + hmmm;
}

addStuff().then((d) => console.log(d)); /* 13 (5 + 7 + 1) */
```

<h3>Common Configuration Keys</h3>

| Name | Example | Description |
|:-:|:-:|:-:|
| `accessNode.api` **(required)**  | `https://rest-testnet.onflow.org` | Flow Blockchainの通信したいAccess NodeのAPI URL。利用可能なすべてのアクセスノードのエンドポイントは[こちら](https://developers.flow.com/http-api)でご確認ください。 |
| `app.detail.title` | `Cryptokitties` | アプリケーションのタイトルは、ウォレットやその他のサービスから要求されることがあります。WalletConnectプラグインとWallet Discoveryサービスで使用されています。 |
| `app.detail.icon` | `https://fcl-discovery.onflow.org/images/blocto.png` | あなたのアプリケーションのアイコンURLは、ウォレットやその他サービスから要求されます。WalletConnectプラグインとWallet Discoveryサービスで使用されています。 |
| `app.detail.description` | `Cryptokitties is a blockchain game` | あなたのアプリケーションの説明は、ウォレットやその他サービスから要求されます。WalletConnectプラグインとWallet Discoveryサービスで使用されています。 |
| `app.detail.url` | `https://cryptokitties.co` | あなたのアプリケーションURLは、ウォレットやその他サービスから要求されます。WalletConnectプラグインとウWallet Discoveryサービスで使用されています。 |
| `challenge.handshake` | **DEPRECATED** | 代わりに`discovery.wallet`を使用してください。 |
| `discovery.authn.endpoint` | `https://fcl-discovery.onflow.org/api/testnet/authn` | 設定可能な代替Wallet Discoveryメカニズムのエンドポイント。詳細については、[discovery](#discovery)をご覧ください。 |
| `discovery.wallet` **(required)** | `https://fcl-discovery.onflow.org/testnet/authn` | FCLにウォレットまたはWallet Discoveryメカニズムを指定します。 |
| `discovery.wallet.method` | `IFRAME/RPC`, `POP/RPC`, `TAB/RPC`, `HTTP/POST`, or `EXT/RPC` | どの戦略(タブ、ポップアップ、iFrame)でウォレットを見せるかを指定します |
| `fcl.limit` | `100` | トランザクションで指定されていない場合のfallbackとしてcompute limitを指定します。整数で指定します。 |
| `flow.network` **(recommended)** | `testnet` | 接続するネットワーク及び、`testnet`および`mainnet`のFCLCryptoContractのアドレス提供に使用します。指定可能な値：`local`、`testnet`、`mainnet`。 |
| `walletconnect.projectId` | `YOUR_PROJECT_ID` | あなたのアプリである WalletConnect のプロジェクトID。 アプリケーションのプロジェクトIDを取得するには、[WalletConnect Cloud](https://cloud.walletconnect.com/sign-in)を参照してください。 |

<h1>Using Contracts in Scripts and Transactions(エイリアス作成)</h1>
<h3>Address Replacement</h3>

コンフィグレーションの`0x`で始まるキーはFCLのスクリプトおよびトランザクション内で置き換えられます。これにより、アプリケーションをFlow Blockchainの異なるインスタンスに向けた場合でも、１箇所変更するのみで、スクリプトまたはトランザクションのCadenceコードを変更する必要がなくなります。
```ruby
import * as fcl from '@onflow/fcl';

fcl.config().put('0xFungibleToken', '0xf233dcee88fe0abe');

async function myScript() {
  return fcl
    .send([
      fcl.script`
      import FungibleToken from 0xFungibleToken // will be replaced with 0xf233dcee88fe0abe because of the configuration

      access(all) fun main() { /* Rest of the script goes here */ }
    `,
    ])
    .then(fcl.decode);
}

async function myTransaction() {
  return fcl
    .send([
      fcl.transaction`
      import FungibleToken from 0xFungibleToken // will be replaced with 0xf233dcee88fe0abe because of the configuration

      transaction { /* Rest of the transaction goes here */ }
    `,
    ])
    .then(fcl.decode);
}
```
**Example**
```ruby
import * as fcl from '@onflow/fcl';

fcl
  .config()
  .put('flow.network', 'testnet')
  .put('walletconnect.projectId', 'YOUR_PROJECT_ID')
  .put('accessNode.api', 'https://rest-testnet.onflow.org')
  .put('discovery.wallet', 'https://fcl-discovery.onflow.org/testnet/authn')
  .put('app.detail.title', 'Test Harness')
  .put('app.detail.icon', 'https://i.imgur.com/r23Zhvu.png')
  .put('app.detail.description', 'A test harness for FCL')
  .put('app.detail.url', 'https://myapp.com')
  .put('service.OpenID.scopes', 'email email_verified name zoneinfo')
  .put('0xFlowToken', '0x7e60df042a9c0868');
```
<h3>Using Flow.json</h3>

よりシンプルに、より柔軟にスマートコントラクトのインポートをスクリプトやトランザクションの中で行う方法は、FCLの`config.load`メソッドを使用する方法です。これは、コントラクトの設定を`flow.json`ファイルから読み込み、あなたのimportシンタックスをクリーンかつ、FCLが、違うネットワークでも正しいコントラクトのアドレスを使う事ができるようにします。

<h3>Setting Up</h3>

**1. Define Your Contracts in flow.json**

以下は複数のネットワークのエイリアスを持つ`flow.json`ファイルの例です。
```ruby
{
  "contracts": {
    "HelloWorld": {
      "source": "./cadence/contracts/HelloWorld.cdc",
      "aliases": {
        "testnet": "0x1cf0e2f2f715450",
        "mainnet": "0xf8d6e0586b0a20c7"
      }
    }
  }
}
```
* source: Points to the contract file in your project.
* aliases: Maps each network to the correct contract address.

**2. Configure FCL**

`flow.json`ファイルを読み込み、FCLで使えるように設定する。
```ruby
import { config } from '@onflow/fcl';
import flowJSON from '../flow.json';

config({
  'flow.network': 'testnet', /* Choose your network, e.g., testnet or mainnet */
  'accessNode.api': 'https://rest-testnet.onflow.org', /* Access node for the network */
  'discovery.wallet': `https://fcl-discovery.onflow.org/testnet/authn`, /* Wallet discovery */
}).load({ flowJSON });
```
この設定により、FCLは選択されたネットワーク（`testnet`や`mainnet`など）に基づいて、自動的に正しいコントラクトアドレスを使用します。

**3. Use Contract Names in Scripts and Transactions**

`flow.json`の設定が完了したら、Cadenceスクリプトまたはトランザクションで、名前だけでスマートコントラクトをインポートすることができます。
```ruby
import "HelloWorld"

access(all) fun main(): String {
    return HelloWorld.sayHello()
}
```
FCLは`"HelloWorld"`を`flow.json`の設定から正しいアドレスに置き換えます。

> **Note**：秘密鍵を`flow.json`に保存するのはやめてください。代わりに、[key/location syntax](https://qiita.com/flowcadence/items/82b619c30a90193904c7)を使用して、機密性の高いキーを別の`.gitignore`で保護されたファイルに保管します。

<h1>Wallet Interactions(サインイン,サイン)</h1>

これらのメソッドは、ユーザーを認証したり、ユーザーのトランザクションを承認するために、dappsがFCL対応のウォレットとやりとりできるようにします。

> ⚠️These methods are **async**.

<h3>authenticate</h3>

> ⚠️**This method can only be used in web browsers.**

このメソッドを呼び出すと、FCLをサポートするウォレットを介して現在のユーザーが認証処理をします。一度実行されると、FCLは設定された`discovery.wallet`エンドポイントと通信を行い、ユーザーに認証に使用するウォレットを選択させます。ウォレットプロバイダーがユーザーを認証すると、FCLは今後のその使用や認証のために[current user](https://qiita.com/flowcadence/items/82c4e2d91df09051b1de#current-user%E7%8F%BE%E5%9C%A8%E3%81%AE%E3%83%A6%E3%83%BC%E3%82%B6)オブジェクトに値をセットします。

**Note**
⚠️`discovery.wallet`の値はこのメソッドが呼び出される前にconfigurationにセットされてなくてはなりません。[FCL Configurationの項目](#configuration設定)をご覧ください。

📣 デフォルトのdiscovery endpointは、ユーザーが対応するウォレットを選択できるように、iframeオーバーレイを開きます。
**Usage**
```ruby
import * as fcl from '@onflow/fcl';
fcl
  .config()
  .put('accessNode.api', 'https://rest-testnet.onflow.org')
  .put('discovery.wallet', 'https://fcl-discovery.onflow.org/testnet/authn');
/* anywhere on the page */
fcl.authenticate();
```
**Note**

⚠️ `authenticate`は、[discovery](#discovery3rdpartyウォレット) から返されたサービスを`fcl.authenticate({ service })`を使うことにより受け取ることもできます。

***

<h3>unauthenticate</h3>

> ⚠️**This method can only be used in web browsers.**

現在のユーザーをログアウトさせ、[current user](#currentuserobject)オブジェクトの値にnullにセットします。

**Note**

⚠️current userは先に認証されていなければなりません。

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
fcl.config().put('accessNode.api', 'https://rest-testnet.onflow.org');
/* first authenticate to set current user */
fcl.authenticate();
/* ... somewhere else & sometime later */
fcl.unauthenticate();
/* fcl.currentUser.loggedIn === null */
```
***

<h3>reauthenticate</h3>

> ⚠️**This method can only be used in web browsers.**

current userに対して、先に[`fcl.unauthenticate()`](#unauthenticate)を呼び出し、再度[`fcl.authenticate()`](#authenticate)を呼び出す処理を**簡便にした方法**です。

**Note**

⚠️current userは先に認証されていなければなりません。

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
/* first authenticate to set current user */
fcl.authenticate();
/* ... somewhere else & sometime later */
fcl.reauthenticate();
/* logs out user and opens up login|sign-up flow */
```
***

<h3>signUp</h3>

> ⚠️**This method can only be used in web browsers.**

[`fcl.authenticate()`](#authenticate)と同等の便利メソッド

***


<h3>logIn</h3>

> ⚠️**This method can only be used in web browsers.**

[`fcl.authenticate()`](#authenticate)と同等の便利メソッド

***


<h3>authz</h3>

現在のユーザー(current user)がトランザクションを Flow に送信するために必要な認証情報を生成してくれる**簡便メソッド**。これは、ユーザーのウォレットプロバイダーに接続し、トランザクションを送信するために必要な、署名を生成する署名関数を定義しています。

> 📣 必要に応じて、この関数をあなたの[authorization function](#authorization-function)に置き換えることができます。

**Returns**

| Type | Description |
|:-:|:-:|
| [AuthorizationObject](#authorizationobject) | トランザクションをいずれかのロールで承認するためにcurrent userから取り出した、必要な情報を含むオブジェクト。 |

**Usage**

**Note:** `proposer`、`payer`、`authorizations`のデフォルト値はすでに`fcl.authz`であるため、これらのパラメータを含める必要はありません。これは例としてのみ表示しています。詳しくは[署名の役割](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca)をご覧ください。

```ruby
import * as fcl from '@onflow/fcl';
/* login somewhere before */
fcl.authenticate();
/* once logged in authz will produce values */
console.log(fcl.authz);
/* prints {addr, signingFunction, keyId, sequenceNum} from the current authenticated user. */

const txId = await fcl.mutate({
  cadence: `
    import Profile from 0xba1132bc08f82fe2
    
    transaction(name: String) {
      prepare(account: auth(BorrowValue) &Account) {
        account.storage.borrow<&{Profile.Owner}>(from: Profile.privatePath)!.setName(name)
      }
    }
  `,
  args: (arg, t) => [arg('myName', t.String)],
  proposer: fcl.authz, /* optional - default is fcl.authz */
  payer: fcl.authz, /* optional - default is fcl.authz */
  authorizations: [fcl.authz], /* optional - default is [fcl.authz] */
});
```
***


<h1>Current User(現在のユーザ)</h1>

セットされていれば、[現在のユーザー(current user)](#currentuserobject)を保持し、ユーザー認証とユーザーによる承認を管理するための一連の関数を提供します。

> ⚠️**The following methods can only be used in web browsers.**

<h3>currentUser.subscribe</h3>

subscribeに渡されるコールバックは、ユーザーが認証および認証解除を行う時に呼び出されるため、それに従ってUIを簡単に更新することができます。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `callback` | function | コールバックはcurrent userを最初の引数として[current user](#currentuserobject)がセットまたは取り除かれた時に呼び出されます。 |

**Usage**
```ruby
import React, { useState, useEffect } from 'react';
import * as fcl from '@onflow/fcl';

export function AuthCluster() {
  const [user, setUser] = useState({ loggedIn: null });
  useEffect(() => fcl.currentUser.subscribe(setUser), []); /* sets the callback for FCL to use */

  if (user.loggedIn) {
    return (
      <div>
        <span>{user?.addr ?? 'No Address'}</span>
        <button onClick={fcl.unauthenticate}>Log Out</button> {/* once logged out in setUser(user) will be called */}
      </div>
    );
  } else {
    return (
      <div>
        <button onClick={fcl.logIn}>Log In</button>{' '}
        {/* once logged in setUser(user) will be called */}
        {/* once signed up, setUser(user) will be called */}
        <button onClick={fcl.signUp}>Sign Up</button>
      </div>
    );
  }
}
```

***


<h3>currentUser.snapshot</h3>

[current user](#currentuserobject)オブジェクトを返します。これは、[`fcl.currentUser.subscribe(callback)`](#currentusersubscribe)でセットされ利用可能なオブジェクトと同じものです。

**Usage**
```ruby
/* returns the current user object */
const user = fcl.currentUser.snapshot();

/* subscribes to the current user object and logs to console on changes */
fcl.currentUser.subscribe(console.log);
```
***

<h3>currentUser.authenticate</h3>

`fcl.authenticate`と同等です。
***


<h3>currentUser.unauthenticate</h3>

`fcl.unauthenticate`と同等です。
***


<h3>currentUser.authorization</h3>

`fcl.authz`と同等です。
***


<h3>currentUser.signUserMessage</h3>

FCL対応のウォレット/サービス経由でユーザーが自ら署名できるメソッドです。

> ⚠️ このメソッドは、current user(現在のユーザー)のウォレットがsigning service endpoint(署名サービスエンドポイント)をサポートしている必要があります。現時点で、**Blocto**のみこの機能にデフォルトで対応しています。

**Arguments**

| Name | Type | Description |
|:-:|:-:|:-:|
| `message` | string **(required)** | A hexadecimal string to be signed |

**Returns**

| Type | Description |
|:-:|:-:|
| `Array` | An Array of [CompositeSignatures](https://github.com/onflow/fcl-js/blob/master/packages/fcl/src/wallet-provider-spec/draft-v2.md#compositesignature): signature |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

export const signMessage = async () => {
  const MSG = Buffer.from('FOO').toString('hex');
  try {
    return await currentUser.signUserMessage(MSG);
  } catch (error) {
    console.log(error);
  }
};
```

***

<h1>Discovery(3rdPartyウォレット)</h1>
<h3>discovery</h3>

ディスカバリーはコードを抽象化しているため、開発者はFlow対応のウォレットの発見やインテグレーション、認証等をコードで行う必要がありません。FCLの`discovery`を使うことで、dappsはUIを完全に制御しつつ、ウォレットをリストし、認証を行うことができます。これによる一般的なユースケースは、ログイン画面や登録画面です。

（あるいは、UIの制御が必要のない場合は、d`iscovery.wallet`設定値をそのまま使用することもできます。これは、[クイックスタート](https://developers.flow.com/build/getting-started/fcl-quickstart)で説明されている最もシンプルな構成です。）

> ⚠️**The following methods can only be used in web browsers.**

**Note**

⚠️`discovery.authn.endpoint`の値はこのメソッドを呼び出す前にconfigurationで設定されている**必要があります**。[FCL Configuration](#configuration設定)を参照してください。

***


<h3>Suggested Configuration</h3>

| Environment | Example |
|:-:|:-:|
| Mainnet | `https://fcl-discovery.onflow.org/api/authn` |
| Testnet | `https://fcl-discovery.onflow.org/api/testnet/authn` |

If the Discovery endpoint is set in config, then you can iterate through authn services and pass the chosen service to [authenticate](#authenticate) to authenticate a user.

**Usage**

```ruby
import './config';
import { useState, useEffect } from 'react';
import * as fcl from '@onflow/fcl';

function Component() {
  const [wallets, setWallets] = useState([]);
  useEffect(
    () => fcl.discovery.authn.subscribe((res) => setWallets(res.results)),
    [],
  );

  return (
    <div>
      {wallets.map((wallet) => (
        <button
          key={wallet.provider.address}
          onClick={() => fcl.authenticate({ service: wallet })}
        >
          Login with {wallet.provider.name}
        </button>
      ))}
    </div>
  );
}
```

***

<h3>authn</h3>

**More Configuration**

デフォルトでは、LedgerやDapper Walletのような限定的な機能のサービスもしくは開発者による登録を必要とするサービスは、アプリ上でユーザーに表示する為には追加設定(opt-in)をする必要があります。 アプリケーションでオプトインのウォレットをユーザーに対して有効にするには、設定内で`discovery.authn.include`プロパティを使用し、ユーザーに表示したいオプトインのウォレットを配列で設定します。

```ruby
import { config } from '@onflow/fcl';

config({
  'discovery.authn.endpoint':
    'https://fcl-discovery.onflow.org/api/testnet/authn', /* Endpoint set to Testnet */
  'discovery.authn.include': ['0x9d2e44203cb13051'], /* Ledger wallet address on Testnet set to be included */
});
```

**Opt-In Wallet Addresses on Testnet and Mainnet**

| Service | Testnet | Mainnet |
|:-:|:-:|:-:|
| `Dapper Wallet` | 0x82ec283f88a62e65 | 0xead892083b3e2c6c |
| `Ledger` | 0x9d2e44203cb13051 | 0xe5cd26afebe62781 |

ウォレットに関するより詳しい情報は、こちらの[service list](https://github.com/onflow/fcl-discovery/blob/87e172db85d185882d9fde007c95f08bc2a1cccb/data/services.json)を見てください。

***


<h3>discovery.authn.snapshot()</h3>

`authn` services のリストを返します。

***

<h3>discovery.authn.subscribe(callback)</h3>

`subscribe` にセットされたコールバック関数が、`authn` servicesのリストと一緒に呼ばれます。

***

<h1>On-chain Interactions(トランザクション)</h1>

> 📣 These methods can be used in browsers and NodeJS. (ブラウザ、Node.jsどちらでも使えます)

これらのメソッドによりdappsは、[Access Node API](https://developers.flow.com/networks/node-ops/access-onchain-data/access-nodes/accessing-data/access-api)を使用した一連の関数を介して、Flowブロックチェーンと直接やりとりすることが可能になります。


<h3>Query and Mutate Flow with Cadence</h3>

ブロックチェーン上で任意のCadenceスクリプトを実行したい場合、これらのメソッドは、ブロックチェーンとのやりとりを生成し、送信し、デコードする必要がなく、これを実行する便利な方法を提供します。

<h3>query(スクリプト)</h3>

ブロックチェーンを照会する(query)ためのスクリプトを送信できます。

**Options**
*以下キーを持つ一つのオブジェクトとして、下記コードのように渡します。特に記載のない限り、すべてのキーはオプションです。*
| Key | Type | Description |
|:-:|:-:|:-:|
| `cadence` | string **(required)** | A valid cadence script. |
| `args` | [ArgumentFunction](#argumentfunction) | Any arguments to the script if needed should be supplied via a function that returns an array of arguments. |
| `limit` | number | クエリに対する計算（ガス）リミット。Flowでの計算コストの算出方法については、[計算コストに関するドキュメント](https://qiita.com/flowcadence/items/c4c24a01ec3d6b7429e2)を参照してください。 |


**Returns**
| Type | Description |
|:-:|:-:|
| any | A JSON representation of the response. |

**Usage**
```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 */
  ],
});
console.log(result); /* 13 */
```
**Examples**
* [Additional Explanation](https://gist.github.com/orodio/3bf977a0bd45b990d16fdc1459b129a2)
***

<h3>mutate(トランザクション)</h3>

ブロックチェーンにトランザクションを送信し、状態(state)を変更することができます。

⚠️ブラウザで使用する場合、`fcl.mutate`は組み込みの`fcl.authz`関数を使用して、current userの署名を生成します。このメソッドをNode.jsから呼び出す場合は、あなたは独自のカスタム署名関数を指定する必要があります。

**Options**
*以下キーを持つ一つのオブジェクトとして、下記コードのように渡します。特に記載のない限り、すべてのキーはオプションです。*
| Key | Type | Description |
|:-:|:-:|:-:|
| `cadence` | string **(required)** | A valid cadence transaction. |
| `args` | [ArgumentFunction](#argumentfunction) | Any arguments to the script if needed should be supplied via a function that returns an array of arguments. |
| `limit` | number | クエリに対する計算（ガス）リミット。Flowでの計算コストの算出方法については、[計算コストに関するドキュメント](https://qiita.com/flowcadence/items/3616deed7fbb2d69f91e#transactions)を参照してください。 |
| `proposer` | [AuthorizationFunction](#authorization-function) | The authorization function that returns a valid [AuthorizationObject](#authorizationobject) for the [proposer role](#transactionrolesobject). |

**Returns**
| Type | Description |
|:-:|:-:|
| string | トランザクションID |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
/* login somewhere before */
fcl.authenticate();

const txId = await fcl.mutate({
  cadence: `
    import Profile from 0xba1132bc08f82fe2
    
    transaction(name: String) {
      prepare(account: auth(BorrowValue) &Account) {
        account.storage.borrow<&{Profile.Owner}>(from: Profile.privatePath)!.setName(name)
      }
    }
  `,
  args: (arg, t) => [arg('myName', t.String)],
});
```
**Examples**
* [Additional explanation](https://gist.github.com/orodio/3bf977a0bd45b990d16fdc1459b129a2)
* [Custom authorization function](#authorization-function)

***

<h3>verifyUserSignatures (Deprecated)</h3>

`fcl.AppUtils.verifyUserSignatures` を使用してください。

***

<h1>AppUtils(ノンカストディアル)</h1>

<h3>AppUtils.verifyUserSignatures</h3>

ユーザーの秘密鍵によって署名されたメッセージを暗号学的に検証することができるメソッド。これは通常、`currentUser.signUserMessage`からの応答とともに使用されます。

**Note**
⚠️ このAPIを使用するには、`fcl.config.flow.network`かオプションのオーバーライドが必要です。[FCL Configuration](#configuration設定)(の`flow.network`)を参照してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `message` | string **(required)** | A hexadecimal string |
| `compositeSignatures` | Array **(required)** | An Array of `CompositeSignatures` |
| `opts` | Object **(optional)** | opts.fclCryptoContract を指定すると、ローカル開発用の FCLCryptoContract アドレスを上書きできます。 |

**Returns**
| Type | Description |
|:-:|:-:|
| Boolean | `true` if verified or `false` |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const isValid = await fcl.AppUtils.verifyUserSignatures(
  Buffer.from('FOO').toString('hex'),
  [
    {
      f_type: 'CompositeSignature',
      f_vsn: '1.0.0',
      addr: '0x123',
      keyId: 0,
      signature: 'abc123',
    },
  ],
  { fclCryptoContract },
);
```
**Examples**
* [fcl-next-harness](https://github.com/onflow/fcl-next-harness)

***

<h3>AppUtils.verifyAccountProof</h3>

このメソッドはアプリケーションが、ユーザーがオンチェーンアカウントを管理していることを暗号学的に証明できます。ユーザーが認証する際、FCLの`account-proof`サービスをサポートすることを、いくつかのFCL対応ウォレットは選びます。もしウォレットがこのサービスをサポートすることを選択し、ユーザーがデータの署名を承認した場合、`account-proof`データと、ユーザーがオンチェーンアカウントを管理している(control)ことを証明する署名が返されます。詳細は、[proving-authentication](https://github.com/onflow/fcl-js/blob/master/docs/reference/proving-authentication.mdx)のドキュメントを参照してください。

⚠️ このAPIを使用するには、`fcl.config.flow.network`かオプションのオーバーライドが必要です。[FCL Configuration](#configuration設定)(の`flow.network`)を参照してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `appIdentifier` | string **(required)** | A hexadecimal string |
| `accountProofData` | Object **(required)** | Object with properties: `address`: `string` - A Flow account address. `nonce`: `string` - A random string in hexadecimal format (minimum 32 bytes in total, i.e 64 hex characters) `signatures`: `Object[]` - An array of composite signatures to verify |
| `opts` | Object **(optional)** | opts.fclCryptoContract を指定すると、ローカル開発用の FCLCryptoContract アドレスを上書きできます。 |

**Returns**
| Type | Description |
|:-:|:-:|
| Boolean | `true` if verified or `false` |

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

const accountProofData = {
  address: "0x123",
  nonce: "F0123"
  signatures: [{f_type: "CompositeSignature", f_vsn: "1.0.0", addr: "0x123", keyId: 0, signature: "abc123"}],
}

const isValid = await fcl.AppUtils.verifyAccountProof(
  "AwesomeAppId",
  accountProofData,
  {fclCryptoContract}
)
```
**Examples**
* [fcl-next-harness](https://github.com/onflow/fcl-next-harness)

***

<h3>Query and mutate the blockchain with Builders</h3>

いくつかのケースでは、あなたは`fcl.query` や、 `fcl.mutate` インターフェイスが提供するものよりも、より複雑なインタラクションを構築したいと思うかもしれません。これを行うために、ビルダーを組み合わせてインタラクションを構築し、それを認証し、ブロックチェーンに送信するパターンをFCLは使用します。

> ⚠【推奨】 これらのビルダーの使用が必要な特定のユースケースがない限り、`fcl.query({...options}`または`fcl.mutate({...options})`でほとんどのケースに対応できるはずです。

<h3>send</h3>

任意のスクリプト、トランザクション、リクエストを Flow に対して送信します。

このメソッドは、[ビルダー](#buildersオンチェーン情報取得)の配列を消費して、認証して送信します。配列に含める必要のあるビルダーは、構築する[やりとり(interaction)](#interaction)によります。

**Note**
> ⚠️正しいキーとすべての値をJSONから取得するには、[`fcl.decode(response)`](#decode)と併用する必要があります。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `builders` | [[Builders](#buildersオンチェーン情報取得)] | See builder functions. |

**Returns**
| Type | Description |
|:-:|:-:|
| [ResponseObject](#responseobject) | チェーンから返されたデータを含むオブジェクト。常に`fcl.decode()`で、適切なJSONキーと値を取得するためにデコードする必要があります。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

/* a script only needs to resolve the arguments to the script */
const response = await fcl.send([fcl.script`${script}`, fcl.args(args)]);
/* note: response values are encoded, call await fcl.decode(response) to get JSON */

/* a transaction requires multiple 'builders' that need to be resolved prior to being sent to the chain - such as setting the authorizations. */
const response = await fcl.send([
  fcl.transaction`
    ${transaction}
    `,
  fcl.args(args),
  fcl.proposer(proposer),
  fcl.authorizations(authorizations),
  fcl.payer(payer),
  fcl.limit(9999),
]);
/* note: response contains several values (Cad) */
```
***

<h3>decode</h3>

`fcl.send()`からのレスポンスをデコードし、Cadenceコードから返された値の適切なJSON表現に変換します。

**Note**
📣 独自のデコーダーを定義するには、[`tutorial`](https://github.com/onflow/fcl-js/tree/master/packages/sdk/src/decode)を参照してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `response` | [ResponseObject](#responseobject) | `fcl.send([...])`から返されるべき応答です。 |

**Returns**
| Type | Description |
|:-:|:-:|
| any | 実行したCadenceコードによる生の文字列応答をJSON表現にしたもの。戻り値は単一の値・型、または複数の型を持つオブジェクトとなります。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

/* simple script to add 2 numbers */
const response = await fcl.send([
  fcl.script`
        access(all) fun main(int1: Int, int2: Int): Int {
            return int1 + int2
        }
    `,
  fcl.args([fcl.arg(1, fcl.t.Int), fcl.arg(2, fcl.t.Int)]),
]);

const decoded = await fcl.decode(response);

assert(3 === decoded);
assert(typeof decoded === 'number');
```

***

<h1>Builders(オンチェーン情報取得)</h1>

これらのメソッドは、トランザクションやスクリプトのテンプレートの色々な部分を埋めて、構築、認証、ブロックチェーンに対して送信します。入力済みテンプレートは[Interaction(インタラクション)](#interaction)と呼ばれます。

⚠️**These methods must be used with fcl.send([...builders]).then(fcl.decode)**

<h3>Query Builders</h3>

<h3>getAccount</h3>

アドレスをもとにアカウント情報を返します。

⚠️他のビルダーと組み合わせる必要がない場合は、あらかじめ構築されたインタラクションの[`fcl.account(address)`](#account)の使用を検討してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `address` | [Address](#address) | Address of the user account with or without a prefix (both formats are supported). |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [AccountObject](#account) | A JSON representation of a user account. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

/* somewhere in an async function
   fcl.account is the same as this function */
const getAccount = async (address) => {
  const account = await fcl.send([fcl.getAccount(address)]).then(fcl.decode);
  return account;
};
```

***

<h3>getBlock</h3>

最新(１番高さが高い)のブロック情報を返します。

📣 古いブロック情報を取得する時には、`fcl.atBlockId()`や`fcl.atBlockHeight()`を併用して使ってください。

⚠️他のビルダーと組み合わせる必要がない場合は、あらかじめ構築されたインタラクションの[`fcl.getblock(isSealed)`](#getblock)の使用を検討してください。

**Arguments**
| Name | Type | Default | Description |
|:-:|:-:|:-:|:-:|
| `isSealed` | boolean | false | If the latest block should be sealed or not. See [block states](#interaction). |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [BlockObject](#blockobject) | 他のビルダーと併用しない場合は、最新のブロックです。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const latestSealedBlock = await fcl
  .send([
    fcl.getBlock(true), /* isSealed = true */
  ])
  .then(fcl.decode);
```

***

<h3>atBlockHeight</h3>

指定したブロック高さのブロックに対する部分情報を返すビルダー関数です。

⚠️[`fcl.getBlock()`](#getblock)など他のインタラクションと組み合わせて使用すると、指定したブロック高さの完全な情報を取得できます。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `blockHeight` | number | The height of the block to execute the interaction at. |

**Returns**
| Type | Description |
|:-:|:-:|
| [Partial Interaction](#interaction) | A partial interaction to be paired with another interaction such as `fcl.getBlock()` or `fcl.getAccount()`. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

await fcl.send([fcl.getBlock(), fcl.atBlockHeight(123)]).then(fcl.decode);
```

***

<h3>atBlockId</h3>

指定したブロックIDのブロックに対する部分情報を返すビルダー関数です。

⚠️[`fcl.getBlock()`](#getblock)など他のインタラクションと組み合わせて使用すると、指定したブロックIDの完全な情報を取得できます。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `blockId` | string | The ID of the block to execute the interaction at. |

**Returns**
| Type | Description |
|:-:|:-:|
| [Partial Interaction](#interaction) | A partial interaction to be paired with another interaction such as `fcl.getBlock()` or `fcl.getAccount()`. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

await fcl.send([fcl.getBlock(), fcl.atBlockHeight(123)]).then(fcl.decode);
```

***

<h3>getBlockHeader</h3>

ブロックのヘッダー情報を返すビルダー関数です。

📣 古いブロック情報を取得するインタラクションを構築する時には、`fcl.atBlockId()`や`fcl.atBlockHeight()`を併用して使ってください。

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [BlockHeaderObject](#blockheaderobject) | 他のビルダーと組み合わせて使用しない場合は最新のブロックヘッダー。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const latestBlockHeader = await fcl
  .send([fcl.getBlockHeader()])
  .then(fcl.decode);

```

***

<h3>getEventsAtBlockHeightRange</h3>

指定したイベントの、指定したブロック高さ範囲内のすべてのインスタンスを返します。

⚠️指定するブロックの範囲は、現在のスポーク(定期的に行われるCadenceアップグレード)からでなければなりません。

⚠️指定するブロックの範囲は、1リクエストあたり250ブロック以下でなければなりません。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `eventName` | [EventName](#eventname) | The name of the event. |
| `fromBlockHeight` | number | The height of the block to start looking for events (inclusive). |
| `toBlockHeight` | number | The height of the block to stop looking for events (inclusive). |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [[EventObject](#event-object)] | An array of events that matched the eventName. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const events = await fcl
  .send([
    fcl.getEventsAtBlockHeightRange(
      'A.7e60df042a9c0868.FlowToken.TokensWithdrawn',
      35580624,
      35580624,
    ),
  ])
  .then(fcl.decode);
```
***

<h3>getEventsAtBlockIds</h3>

複数のブロックIDで指定されたブロック内で、特定のイベント（名前で指定）のすべてのインスタンスを返します。

⚠️指定するブロックの範囲は、現在のスポーク(定期的に行われるCadenceアップグレードのこと)からでなければなりません。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `eventName` | [EventName](#eventname) | The name of the event. |
| [`blockId`] | [number] |  The ids of the blocks to scan for events. |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [[EventObject](#event-object)] | An array of events that matched the eventName. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const events = await fcl
  .send([
    fcl.getEventsAtBlockIds('A.7e60df042a9c0868.FlowToken.TokensWithdrawn', [
      'c4f239d49e96d1e5fbcf1f31027a6e582e8c03fcd9954177b7723fdb03d938c7',
      '5dbaa85922eb194a3dc463c946cc01c866f2ff2b88f3e59e21c0d8d00113273f',
    ]),
  ])
  .then(fcl.decode);
```

***

<h3>getCollection</h3>

コレクションIDに対応するトランザクションIDリストを含んでいる全てのコレクションを返します。

⚠️指定するブロックの範囲は、現在のスポークからでなければなりません。過去のスポーク中に発行されたすべてのイベントは、現在利用できません。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `collectionID` | string | The id of the collection. |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [CollectionObject](#collectionobject) | An object with the id and a list of transactions within the requested collection. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const collection = await fcl
  .send([
    fcl.getCollection(
      'cccdb0c67d015dc7f6444e8f62a3244ed650215ed66b90603006c70c5ef1f6e5',
    ),
  ])
  .then(fcl.decode);
```

***

<h3>getTransactionStatus</h3>

[TransactionStatusObject](#transactionstatusobject) の形式でトランザクションのステータスを返します。

⚠️transactionID は現在のスポーク以降のでなければなりません。

📣このメソッドを直接呼び出すのではなく、[`fcl.tx(id)` を使ってトランザクションステータスをサブスクライブする](#tx)ことを検討してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `transactionId` | string | The transactionID returned when submitting a transaction. Example: `9dda5f281897389b99f103a1c6b180eec9dac870de846449a302103ce38453f3` |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [TransactionStatusObject](#transactionstatusobject) | Object representing the result/status of a transaction |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const status = await fcl
  .send([
    fcl.getTransactionStatus(
      '9dda5f281897389b99f103a1c6b180eec9dac870de846449a302103ce38453f3',
    ),
  ])
  .then(fcl.decode);
```

***

<h3>getTransaction</h3>

[トランザクションオブジェクト](#transactionobject)を返します。

⚠️transactionID は現在のスポーク以降のでなければなりません。

📣このメソッドを直接呼び出すのではなく、[`fcl.tx(id).onceSealed()`](#tx) を使用することを検討してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `transactionId` | string | The transactionID returned when submitting a transaction. Example: `9dda5f281897389b99f103a1c6b180eec9dac870de846449a302103ce38453f3` |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [TransactionObject](#transactionobject) | Object representing the result/status of a transaction |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const tx = await fcl
  .send([
    fcl.getTransaction(
      '9dda5f281897389b99f103a1c6b180eec9dac870de846449a302103ce38453f3',
    ),
  ])
  .then(fcl.decode);
```


***

<h3>subscribeEvents</h3>

:::note info
info
subscribeEvents SDK builderは、イベントのリスニングを開始するブロックを直接指定したい場合など、より高度な使用事例を対象としています。ほとんどの使用事例では、あらかじめ構築されたインタラクション[`fcl.events(eventTypes)`](#events)の使用を検討してください。
:::
一度デコードすると、[イベントストリーム接続](#eventstream)を返すビルドです。Access Nodeに対しWebSocket接続を確立し、指定されたパラメータでイベントを受信します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `opts` | `Object` | 以下のキーを持つオブジェクト: |
| `opts.startBlockId` | string \| undefined | The block ID to start listening for events. Example: `9dda5f281897389b99f103a1c6b180eec9dac870de846449a302103ce38453f3` |
| `opts.startHeight` | number \| undefined | The block height to start listening for events. Example: `123` |
| `opts.eventTypes` | string[] \| undefined | The event types to listen for. Example: `A.7e60df042a9c0868.FlowToken.TokensWithdrawn` |
| `opts.addresses` | string[] \| undefined | The addresses to listen for. Example: `0x7e60df042a9c0868` |
| `opts.contracts` | string[] \| undefined | The contracts to listen for. Example: `0x7e60df042a9c0868` |
| `opts.heartbeatInterval` | number \| undefined | The interval in milliseconds to send a heartbeat to the Access Node. Example: `10000` |

**Returns after decoding**
| Type | Description |
|:-:|:-:|
| [EventStreamConnection](#eventstream) | A connection to the event stream |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const eventStream = await fcl
  .send([
    fcl.subscribeEvents({
      eventTypes: 'A.7e60df042a9c0868.FlowToken.TokensWithdrawn',
    }),
  ])
  .then(fcl.decode);

eventStream.on('heartbeat', (heartbeat) => {
  console.log(heartbeat);
});

eventStream.on('events', (event) => {
  console.log(event);
});

eventStream.on('error', (error) => {
  console.log(error);
});

eventStream.on('end', () => {
  console.log('Connection closed');
});

eventStream.close();
```
***

<h3>getEvents (Deprecated)</h3>

Use [`fcl.getEventsAtBlockHeightRange`](#geteventsatblockheightrange) or [`fcl.getEventsAtBlockIds`](#geteventsatblockids).

***

<h3>getLatestBlock (Deprecated)</h3>

Use [`fcl.getBlock`](#getblock).

***

<h3>getBlockById (Deprecated)</h3>

Use [`fcl.getBlock`](#getblock) and [`fcl.atBlockId`](#atblockid).

***

<h3>getBlockByHeight (Deprecated)</h3>

Use [`fcl.getBlock`](#getblock) and [`fcl.atBlockHeight`](#atblockheight).

***

<h3>Utility Builders</h3>

これらのビルダーは、scriptやtransactionなどの他のビルダーと併用して使用されます。

> ⚠️**Recommendation**：これらのビルダーの使用が必要となる特定のユースケースがない限り、`fcl.query({...options}`または`fcl.mutate({...options})`でほとんどのケースの目的を達成できるはずです。

***

<h3>arg</h3>

`fcl.args[...] `と一緒に使用するユーティリティビルダーで、FCLでサポートされた引数を作成します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `value` | any | Any value that you are looking to pass to other builders. |
| `type` | [FType](#ftype) | A type supported by Flow. |

**Returns**
| Type | Description |
|:-:|:-:|
| [ArgumentObject](#argumentobject) | Holds the value and type passed in. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

await fcl
  .send([
    fcl.script`
      access(all) fun main(a: Int, b: Int): Int {
        return a + b
      }
    `,
    fcl.args([
      fcl.arg(5, fcl.t.Int), /* a */
      fcl.arg(4, fcl.t.Int), /* b */
    ]),
  ])
  .then(fcl.decode);
```
***

<h3>args</h3>

他のビルダーと組み合わせて使用するユーティリティビルダーで、値とサポートされている型を持つ引数を渡します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `args` | [[Argument Objects](#argumentobject)] | An array of arguments that you are looking to pass to other builders. |

**Returns**
| Type | Description |
|:-:|:-:|
| [Partial Interaction](#interaction) | An interaction that contains the arguments and types passed in. This alone is a partial and incomplete interaction. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

await fcl
  .send([
    fcl.script`
      access(all) fun main(a: Int, b: Int): Int {
        return a + b
      }
    `,
    fcl.args([
      fcl.arg(5, fcl.t.Int), /* a */
      fcl.arg(4, fcl.t.Int), /* b */
    ]),
  ])
  .then(fcl.decode); /* 9 */
```


***

<h3>Template Builders</h3>

> ⚠️**Recommended**: 以下の機能は、[`fcl.query({...options}`](#queryスクリプト)や[`fcl.mutate({...options})`](#mutateトランザクション)によって簡素化されており、以下の関数よりもこれらを使用することが推奨されます。

***

<h3>script</h3>

Cadenceのスクリプトを実行するのに使用します。

📣 `fcl.args(...)` と併用して、動的に引数を渡します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `CODE` | string | Should be valid Cadence script. |

**Returns**
| Type | Description |
|:-:|:-:|
| [Interaction](#interaction) | An interaction containing the code passed in. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const code = `
  access(all) fun main(): Int {
    return 5 + 4
  }
`;
const answer = await fcl.send([fcl.script(code)]).then(fcl.decode);
console.log(answer); // 9
```


***

<h3>transaction</h3>

Cadence トランザクションを実行するのに使用します。

⚠️`fcl.payer`、`fcl.proposer`、`fcl.authorizations`と一緒に使用する必要があります。

📣 `fcl.args[...]`と併用して、動的に引数を渡します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `CODE` | string | Should be valid a Cadence transaction. |

**Returns**
| Type | Description |
|:-:|:-:|
| [Partial Interaction](#interaction) | `fcl.payer`、`fcl.proposer`、`fcl.authorizations`と一緒に使用することで完全なやり取り可能なオブジェクトになります。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

/* a script only needs to resolve the arguments to the script */
const response = await fcl.send([fcl.script`${script}`, fcl.args(args)]);
/* note: response values are encoded, call await fcl.decode(response) to get JSON */

/* a transaction requires multiple 'builders' that need to be resolved prior to being sent to the chain - such as setting the authorizations. */
const response = await fcl.send([
  fcl.transaction`
    ${transaction}
    `,
  fcl.args(args),
  fcl.proposer(proposer),
  fcl.authorizations(authorizations),
  fcl.payer(payer),
  fcl.limit(9999),
]);
/* note: response contains several values (Cad) */
```

***

<h1>Pre-built Interactions(ショートハンドメソッド)</h1>

これらの関数は、チェーンへのインタラクションのsendとdecodeのステップをスキップした簡略化した方法です。さらに多くのpre-builtされたインタラクションがまもなく登場します。

<h3>account</h3>

公開アドレスからアカウントの詳細情報を返す、pre-builtされたインタラクション。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `address` | [Address](#address) | ユーザーアカウントのアドレス（プレフィックス付きorプレフィックスなし、両方の形式に対応）。 |

**Returns**
| Type | Description |
|:-:|:-:|
| [AccountObject](#accountobject) | A JSON representation of a user account. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
const account = await fcl.account('0x1d007d755706c469');
```
***

<h3>block</h3>

最新のブロック（オプションでsealedのものとそうで無いもの）を、IDまたは高さで返す、あらかじめpre-builtされたインタラクション。

**Arguments**
| Name | Type | Default | Description |
|:-:|:-:|:-:|:-:|
| `sealed` | boolean | false | If the latest block should be sealed or not. See [block states](#interaction). |
| `id` | string |  | ID of block to get. |
| `height` | int |   | Height of block to get.|

**Returns**
| Type | Description |
|:-:|:-:|
| [BlockObject](#blockobject) | A JSON representation of a block. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
await fcl.block(); /* get latest finalized block */
await fcl.block({ sealed: true }); /* get latest sealed block */
await fcl.block({
  id: '0b1bdfa9ddaaf31d53c584f208313557d622d1fedee1586ffc38fb5400979faa',
}); /* get block by id */
await fcl.block({ height: 56481953 }); /* get block by height */
```

***

<h3>latestBlock (Deprecated)</h3>

最新のブロック（オプションでsealedのものまたはそうで無いもの）を返す、pre-builtされたインタラクション。
**Arguments**
| Name | Type | Default | Description |
|:-:|:-:|:-:|:-:|
| `isSealed` | boolean | false | If the latest block should be sealed or not. See [block states](#interaction). |

**Returns**
| Type | Description |
|:-:|:-:|
| [BlockObject](#blockobject) | A JSON representation of a block. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
const latestBlock = await fcl.latestBlock();
```
***

<h1>Transaction Status Utility(tx情報)</h1>

<h3>tx</h3>

トランザクションで、（ポーリングによる）その後のステータス更新と確定した結果が利用可能になった際に取得するよう設定できるユーティリティ関数。 ⚠️ポーリングレートは`2500ms`に設定されており、トランザクションがsealedになるまでその間隔で更新します。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `transactionId` | string | A valid transaction id. |

**Returns**
| Name | Type | Description |
|:-:|:-:|:-:|
| `snapshot()` | function | Returns the current state of the transaction. |
| `subscribe(cb)` | function | Calls the `cb` passed in with the new transaction on a status change. |
| `onceFinalized()` | function | Provides the transaction once status `2` is returned. See [Tranasaction Statuses](#transaction-statuses). |
| `onceExecuted()` | function | Provides the transaction once status `3` is returned. See [Tranasaction Statuses](#transaction-statuses). |
| `onceSealed()` | function | Provides the transaction once status `4` is returned. See [Tranasaction Statuses](#transaction-statuses). |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';

const [txStatus, setTxStatus] = useState(null);
useEffect(() => fcl.tx(txId).subscribe(setTxStatus));
```

<h1>Event Polling Utility(イベント)</h1>

<h3>events</h3>

イベントで、（ポーリングによる）その後の取得可能なイベントがある際に取得できるようにするユーティリティ関数。 ⚠️ポーリングレートは`10000ms`に設定されており、新しいイベントを取得するためにその間隔で更新します。

Note：⚠️`fcl.eventPollRate`の値は、すべてのイベントサブスクライバのポーリングレートを変更するように設定**できる**場合があります。詳細は、[FCL Configuration](#configuration設定)を参照してください。

**Arguments**
| Name | Type | Description |
|:-:|:-:|:-:|
| `eventName` | string | A valid event name. |

**Returns**
| Name | Type | Description |
|:-:|:-:|:-:|
| `subscribe(cb)` | function | Calls the `cb` passed in with the new event. |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
/* in some react component */
fcl.events(eventName).subscribe((event) => {
  console.log(event);
});
```
**Examples**
* [Flow-view-source example](https://github.com/orodio/flow-view-source/blob/master/src/pages/event.comp.js)

<h1>Types, Interfaces, and Definitions(オブジェクトの定義)</h1>

<h3>Builders</h3>

Buildersはモジュール関数であり、`fcl.send([...builders]) `と結合してインタラクションを作成することができます。[インタラクション](#interaction)を作成するために必要なビルダーは、送信されるスクリプトまたはトランザクションに依存します。

***

<h3>Interaction</h3>

インタラクションは、チェーン上でアクションを実行するための情報を含むオブジェクトです。このオブジェクトはビルダーを通じて作成され、適切なアクセスノードAPI callに変換されます。インタラクションオブジェクトについては[こちら](https://github.com/onflow/fcl-js/blob/master/packages/sdk/src/interaction/interaction.js)をご覧ください。"partial" interactionとは、意図したチェーン上のアクションに必要な情報が十分でないインタラクションオブジェクトです。複数のpartial interactionを（ビルダーを通じて）結合して、完全なインタラクションを作成することができます。

***

<h3>CurrentUserObject</h3>

| Key | Value Type | Default | Description |
|:-:|:-:|:-:|:-:|
| `addr` | [Address](#address) | `null` | The public address of the current user |
| `cid` | string | `null` | Allows wallets to specify a [content identifier](https://docs.ipfs.tech/concepts/content-addressing/) for user metadata. |
| `expiresAt` | number | `null` | Allows wallets to specify a time-frame for a valid session. |
| `f_type` | string | `'USER'` | A type identifier used internally by FCL. |
| `f_vsn` | string | `'1.0.0'` | FCL protocol version. |
| `loggedIn` | boolean | `null` | If the user is logged in. |
| `services` | `[ServiceObject]` | `[]` | A list of trusted services that express ways of interacting with the current user's identity, including means to further discovery, [authentication, authorization](https://gist.github.com/orodio/a74293f65e83145ec8b968294808cf35#you-know-who-the-user-is), or other kinds of interactions. |

***

<h3>AuthorizationObject</h3>

FCLが現在のユーザーに代わってトランザクションを承認するために必要なインターフェースにこの型は準拠しています。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `addr` | [Address](#address) | 	The address of the authorizer |
| `signingFunction` | function | A function that allows FCL to sign using the authorization details and produce a valid signature. |
| `keyId` | number | The index of the key to use during authorization. (Multiple keys on an account is possible). |
| `sequenceNum` | number | A number that is incremented per transaction using they keyId. |

***

<h3>SignableObject</h3>

ユーザーの署名でメッセージに署名するためにFCLに必要なすべての情報を含むオブジェクト。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `addr` | [Address](#address) | The address of the authorizer |
| `keyId` | number | The index of the key to use during authorization. (Multiple keys on an account is possible). |
| `signature` | function | A [SigningFunction](#signing-function) that can produce a valid signature for a user from a message. |

***

<h3>AccountObject</h3>

Flowブロックチェーン上のアカウントのJSON表現
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `address` | [Address](#address) | The address of the account |
| `balance` | number | The FLOW balance of the account in 10^8. |
| `code` | Code | The code of any Cadence contracts stored in the account. |
| `contracts` | Object: [Contract](#contract) | An object with keys as the contract name deployed and the value as the the cadence string. |
| `keys` | [[KeyObject](#keyobject)] | Any contracts deployed to this account. |

***

<h3>Address</h3>

| Value Type | Description |
|:-:|:-:|
| string(formatted) | A valid Flow address should be 16 characters in length. A `0x` prefix is optional during inputs. eg. `f8d6e0586b0a20c1` |

***

<h3>ArgumentObject</h3>

An argument object created by `fcl.arg(value,type)`
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `value` | any | Any value to be used as an argument to a builder. |
| `xform` | [FType](#ftype) | Any of the supported types on Flow. |

***

<h3>ArgumentFunction</h3>

`fcl.arg`関数とfcl型の`t`を受け取り、`fcl.arg(value,type)`の配列を返す関数

`(arg, t) => Array<Arg>`

| Parameter Name | Value Type | Description |
|:-:|:-:|:-:|
| `arg` | function | A function that returns an [ArgumentObject](#argumentobject) - `fcl.arg`. |
| `t` | [FType](#ftype) | Flowでサポートされているすべての型にアクセスできるオブジェクト |

**Returns**
| Value Type | Description |
|:-:|:-:|
| `[fcl.args]` | Array of `fcl.args` |

***

<h3>Authorization Function</h3>

承認関数(authorization function)は、署名しようとしているユーザーの情報を生み出し、署名関数は、その情報を使用して署名を生成します。

⚠️この関数は常に非同期です。

📣 デフォルトでは、FCLは現在のユーザー（ブラウザのみでサインインしている場合）の承認オブジェクトを生成する`fcl.authz`を公開しています。このインタフェースに準拠した独自の関数に承認オブジェクトが必要な場所で置き換えてください。（補足：特にバックエンドでは必要です）
| Parameter Name | Value Type | Description |
|:-:|:-:|:-:|
| `account` | [AccountObject](#accountobject) | The account of the user that is going to sign. |

**Returns**
| Value Type | Description |
|:-:|:-:|
| `Promise<[AuthorizationObject](#authorizationobject)>` | The object that contains all the information needed by FCL to authorize a user's transaction. |

**Usage**
```ruby
const authorizationFunction = async (account) => {
    /* authorization function need to return an account */
    const { address, keys } = account
    const tempId = `${address}-${keys[process.env.minterAccountIndex]}`;
    const keyId = Number(KEY_ID);
    let signingFunction = async signable => {
      return {
        keyId,
        addr: fcl.withPrefix(address),
        signature: sign(process.env.FLOW_MINTER_PRIVATE_KEY, signable.message), // signing function, read below
      }
    }
    return {
    ...account,
    address,
    keyId,
    tempId,
    signingFunction,
  }
```
* [Detailed explanation](https://github.com/onflow/fcl-js/blob/master/packages/fcl/src/wallet-provider-spec/authorization-function.md)

***

<h3>Signing Function</h3>

ペイロードを消費し、トランザクションのための署名を生成します。

⚠️この関数は常に非同期です。

📣独自の署名関数(signing function)を書くのは、独自のカスタム承認関数(authorization function)を書いている場合のみにしてください。

**Payload**

注：これらの値は、最初の引数のペイロードオブジェクトから削除されます。
| Parameter Name | Value Type | Description |
|:-:|:-:|:-:|
| `message` | string | The encoded string which needs to be used to produce the signature. |
| `addr` | string | The encoded string which needs to be used to produce the signature. |
| `keyId` | string | The encoded string which needs to be used to produce the signature. |
| `roles` | string | The encoded string which needs to be used to produce the signature. |
| `voucher` | object | 生トランザクション情報。追加の安全とメッセージの信頼性欠如を補うため、メッセージの作成に使用することができます。 |

**Returns**
| Value Type | Description |
|:-:|:-:|
| `Promise<[SignableObject](#signableobject)>` | ユーザーのトランザクションを認証するのにFCLが必要なすべての情報を含むオブジェクト。 |

**Usage**
```ruby
import * as fcl from '@onflow/fcl';
import { ec as EC } from 'elliptic';
import { SHA3 } from 'sha3';
const ec: EC = new EC('p256');

const produceSignature = (privateKey, msg) => {
  const key = ec.keyFromPrivate(Buffer.from(privateKey, 'hex'));
  const sig = key.sign(this.hashMsg(msg));
  const n = 32;
  const r = sig.r.toArrayLike(Buffer, 'be', n);
  const s = sig.s.toArrayLike(Buffer, 'be', n);
  return Buffer.concat([r, s]).toString('hex');
};

const signingFunction = ({
  message, /* The encoded string which needs to be used to produce the signature. */
  addr, /* The address of the Flow Account this signature is to be produced for. */
  keyId, /* The keyId of the key which is to be used to produce the signature. */
  roles: {
    proposer, /* A Boolean representing if this signature to be produced for a proposer. */
    authorizer, /* A Boolean representing if this signature to be produced for a authorizer. */
    payer, /* A Boolean representing if this signature to be produced for a payer. */
  },
  voucher, /* The raw transactions information, can be used to create the message for additional safety and lack of trust in the supplied message. */
}) => {
  return {
    addr, /* The address of the Flow Account this signature was produced for. */
    keyId, /* The keyId for which key was used to produce the signature. */
    signature: produceSignature(message), /* The hex encoded string representing the signature of the message. */
  };
};
```
**Examples:**
* [Detailed explanation](https://github.com/onflow/fcl-js/blob/master/packages/fcl/src/wallet-provider-spec/authorization-function.md)

***

<h3>TransactionObject</h3>

| Key | Value Type | Description |
|:-:|:-:|:-:|
| `args` | object | A list of encoded Cadence values passed into this transaction. These have not been decoded by the JS-SDK. |
| `authorizers` | [[Address](#address)] | A list of the accounts that are authorizing this transaction to mutate to their on-chain account state. [詳しくはこちら](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signer-roles)。 |
| `envelopeSignatures` | [[SignableObject](#signableobject)] | A list of signatures generated by the payer role. [詳しくはこちら](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signing-a-transaction)。 |
| `gasLimit` | number | The maximum number of computational units that can be used to execute this transaction. [詳しくはこちら](https://qiita.com/flowcadence/items/c4c24a01ec3d6b7429e2). |
| `payer` | [Address](#address) | The account that pays the fee for this transaction. [詳しくはこちら](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signer-roles)。 |
| `payloadSignatures` | [[SignableObject](#signableobject)] | A list of signatures generated by the proposer and authorizer roles. [詳しくはこちら](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signing-a-transaction)。 |
| `proposalKey` | [[ProposalKey](#proposalkeyobject)] | The account key used to propose this transaction |
| `referenceBlockId` | string | A reference to the block used to calculate the expiry of this transaction |
| `script` | string | The UTF-8 encoded Cadence source code that defines the execution logic for this transaction |

***

<h3>TransactionRolesObject</h3>

| Key Name | Value Type | Description |
|:-:|:-:|:-:|
| proposer | boolean | A Boolean representing if this signature to be produced for a proposer. |
| authorizer | boolean | A Boolean representing if this signature to be produced for an authorizer. |
| payer | boolean | A Boolean representing if this signature to be produced for a payer. |

各トランザクション・ロールの意味については、[singing roles](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#signer-roles)を参照してください。

***

<h3>TransactionStatusObject</h3>

| Key | Value Type | Description |
|:-:|:-:|:-:|
| `blockId` | string | ID of the block that contains the transaction. |
| `events` | [[EventObject](#event-object)] | An array of events that were emitted during the transaction. |
| `status` | [TransactionStatus](#transaction-statuses) | The status of the transaction on the blockchain. |
| `statusString` | [TransactionStatus](#transaction-statuses) | The `status` as as descriptive text (e.g. "FINALIZED"). |
| `errorMessage` | string | An error message if it exists. Default is an empty string `''`. |
| `statusCode` | number | The pass/fail status. 0 indicates the transaction succeeded, 1 indicates it failed. |

***

<h3>EventName</h3>

| Value Type | Description |
|:-:|:-:|
| string(formatted) | A event name in Flow must follow the format `A.{AccountAddress}.{ContractName}.{EventName}` eg. `A.ba1132bc08f82fe2.Debug.Log` |

***

<h3>Contract</h3>

| Value Type | Description |
|:-:|:-:|
| string(formatted) | A formatted string that is a valid cadence contract. |

***

<h3>KeyObject</h3>

これは、Flowブロックチェーン上のキーのJSON表現です。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `index` | number | The address of the account |
| `publicKey` | string | The public portion of a public/private key pair |
| `signAlgo` | number | An index referring to one of `ECDSA_P256` or `ECDSA_secp256k1` |
| `hashAlgo` | number | An index referring to one of `SHA2_256` or `SHA3_256` |
| `weight` | number | A number between 1 and 1000 indicating the relative weight to other keys on the account. |
| `sequenceNumber` | number | This number is incremented for every transaction signed using this key. |
| `revoked` | boolean | If this key has been disabled for use. |

***

<h3>ProposalKeyObject</h3>

ProposalKeyはアカウントキーで、トランザクションを提案するために使用されます。

提案キーは、アカウント上の特定のキーと、そのキーの最新のシーケンス番号をもとに作られします。このシーケンス番号は、リプレイ攻撃を防止するために使用されます。

シーケンス番号の詳細については、[こちら](https://qiita.com/flowcadence/items/6393a2af33f82475a7ca#sequence-numbers)をご覧ください。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `address` | [Address](#address) | The address of the account |
| `keyIndex` | number | The index of the account key being referenced |
| `sequenceNumber` | number | The sequence number associated with this account key for this transaction |


***

<h3>BlockObject</h3>

Flowブロックチェーン上のブロックのJSON表現です。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `id` | string | The id of the block. |
| `parentId` | string | The id of the parent block. |
| `height` | number | The height of the block. |
| `timestamp` | object | Contains time related fields. |
| `collectionGuarantees` | 	[[CollectionGuaranteeObject](#collectionguaranteeobject)] | Contains the ids of collections included in the block. |
| `blockSeals` | [SealedBlockObject] | The details of which nodes executed and sealed the blocks. |
| `signatures` | Uint8Array([numbers]) | All signatures. |

***

<h3>BlockHeaderObject</h3>

ブロックのヘッダー値のみを含む[BlockObject](#blockobject) のサブセットです。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `id` | string | The id of the block. |
| `parentId` | string | The id of the parent block. |
| `height` | number | The height of the block. |
| `timestamp` | object | Contains time related fields. |

***

<h3>CollectionGuaranteeObject</h3>

1つのブロックに含まれているコレクションです。(コレクションとは、同じブロックに含まれるトランザクションのリストです。)
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `collectionId` | string | The id of the block |
| `signatures` | [SignatureObject](#signatureobject) | All signatures |

***

<h3>CollectionObject</h3>

コレクションとは、同じブロックに含まれるトランザクションのリストです。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `id` | string | The id of the collection. |
| `transactionIds` | [string] | The ids of the transactions included in the collection. |

***

<h3>ResponseObject</h3>

`fcl.send(...)`から返されるFCLのすべてのレスポンスのフォーマット。キーの値と説明の詳細については、[こちら](https://github.com/onflow/fcl-js/tree/master/packages/sdk/src/response)をご覧ください。
| Key |
|:-:|
| `tag` |
| `transaction` |
| `transactionStatus` |
| `transactionId` |
| `encodedData` |
| `events` |
| `account` |
| `block` |
| `blockHeader` |
| `latestBlock` |
| `collection` |

***

<h3>Event Object</h3>

| Key | Value Type | Description |
|:-:|:-:|:-:|
| `blockId` | string | ID of the block that contains the event. |
| `blockHeight` | number | Height of the block that contains the event. |
| `blockTimestamp` | string | The timestamp of when the block was sealed in a `DateString` format. eg. `'2021-06-25T13:42:04.227Z'` |
| `type` | [EventName](#eventname) | A string containing the event name. |
| `transactionId` | string | Can be used to query transaction information, eg. via a Flow block explorer. |
| `transactionIndex` | number | Used to prevent replay attacks. |
| `eventIndex` | number | Used to prevent replay attacks. |
| `data` | any | The data emitted from the event. |

***

<h3>Transaction Statuses</h3>

トランザクションのステータスは、フローブロックチェーンのネットワークと、トランザクションが完了し確定するまでのどの段階にあるかによって異なります。
| Status Code | Description |
|:-:|:-:|
| `0` | Unknown |
| `1` | Transaction Pending - Awaiting Finalization |
| `2` | Transaction Finalized - Awaiting Execution |
| `3` | Transaction Executed - Awaiting Sealing |
| `4` | Transaction Sealed - Transaction Complete. At this point the transaction result has been committed to the blockchain. |
| `5` | Transaction Expired |

***

<h3>GRPC Statuses</h3>

アクセスノードのGRPCの実装は、標準GRPC Coreステータスコード仕様に準拠しています。[こちら](https://grpc.github.io/grpc/core/md_doc_statuscodes.html)をご覧ください。

***

<h3>FType</h3>

FCL arguments must specify one of the following support types for each value passed in.
| 1 | 2 |
|:-:|:-:|
| `UInt` | `fcl.arg(1, t.UInt)` |
| `UInt8` | `fcl.arg(1, t.UInt8)` |
| `UInt16` | `fcl.arg(1, t.UInt16)` |
| `UInt32` | `fcl.arg(1, t.UInt32)` |
| `UInt64` | `fcl.arg(1, t.UInt64)` |
| `UInt128` | `fcl.arg(1, t.UInt128)` |
| `UInt256` | `fcl.arg(1, t.UInt256)` |
| `Int` | `fcl.arg(1, t.Int)` |
| `Int8` | `fcl.arg(1, t.Int8)` |
| `Int16` | `fcl.arg(1, t.Int16)` |
| `Int32` | `fcl.arg(1, t.Int32)` |
| `Int64` | `fcl.arg(1, t.Int64)` |
| `Int128` | `fcl.arg(1, t.Int128)` |
| `Int256` | `fcl.arg(1, t.Int256)` |
| `Word8` | `fcl.arg(1, t.Word8)` |
| `Word16` | `fcl.arg(1, t.Word16)` |
| `Word32` | `fcl.arg(1, t.Word32)` |
| `Word64` | `fcl.arg(1, t.Word64)` |
| `UFix64` | `fcl.arg("0.123", t.UFix64)` |
| `Fix64` | `fcl.arg("0.123", t.Fix64)` |
| `String` | `fcl.arg("ABC", t.String)` |
| `Character` | `fcl.arg("c", t.String)` |
| `Bool` | `fcl.arg(true, t.String)` |
| `Address` | `fcl.arg("0xABC123DEF456", t.Address)` |
| `Optional | `fcl.arg("DEF", t.Optional(t.String))` |
| `Array` | `fcl.args([ fcl.arg(["First", "Second"], t.Array(t.String)) ])` |
| `Dictionary` | `fcl.args([fcl.arg([{key: 1, value: "one"}, {key: 2, value: "two"}], t.Dictionary({key: t.Int, value: t.String}))])` |
| `Path` | `fcl.args([fcl.arg([{key: 1, value: "one"}, {key: 2, value: "two"}], t.Dictionary({key: t.Int, value: t.String}))])` |

***

<h3>StreamConnection</h3>

１つのストリーム接続は１つのオブジェクトであり、あらゆる WebSocket データストリームから一般的なデータをサブスクライブします。これはすべてのストリーム接続の基本形です。`close` と `error` の 2 つのチャンネルは、ストリームの終了や発生したエラーを通知するために使用されるため、常に利用可能です。
```ruby
interface StreamConnection<ChannelMap extends { [name: string]: any }> {
  /* Subscribe to a channel */
  on<C extends keyof ChannelMap>(
    channel: C,
    listener: (data: ChannelMap[C]) => void,
  ): this;
  on(event: 'close', listener: () => void): this;
  on(event: 'error', listener: (err: any) => void): this;

  /* Unsubscribe from a channel */
  off<C extends keyof ChannelMap>(
    event: C,
    listener: (data: ChannelMap[C]) => void,
  ): this;
  off(event: 'close', listener: () => void): this;
  off(event: 'error', listener: (err: any) => void): this;

  /* Close the connection */
  close(): void;
}
```
**Usage**
```ruby
import { StreamConnection } from "@onflow/typedefs"

const stream: StreamConnection = ...

stream.on("close", () => {
  /* Handle close */
})

stream.on("error", (err) => {
  /* Handle error */
})

stream.close()
```

***

<h3>EventStream</h3>

イベントストリームは、イベントとブロックハートビートを発行するストリーム接続です。接続パラメータに基づき、ハートビートは少なくとも固定ブロック高インターバルと同じ頻度で発行されます。これは、[StreamConnection](#streamconnection)の特定の変形です。
```ruby
type EventStream = StreamConnection<{
  events: Event[];
  heartbeat: BlockHeartbeat;
}>;
```
**Usage**
```ruby
import { EventStream } from "@onflow/typedefs"

const stream: EventStream = ...

stream.on("events", (events) => {
  /* Handle events */
})

stream.on("heartbeat", (heartbeat) => {
  /* Handle heartbeat */
})

/* Close the stream */
stream.close()
```

***

<h3>BlockHeartbeat</h3>

```ruby
export interface BlockHeartbeat {
  blockId: string;
  blockHeight: number;
  timestamp: string;
}
```
**Usage**
```ruby
import { BlockHeartbeat } from "@onflow/typedefs"

const heartbeat: BlockHeartbeat = ...
```

***

<h3>SignatureObject</h3>

署名オブジェクトは、特定のメッセージの署名、およびそのメッセージに署名したアカウントと keyId を表現するために使用されます。
| Key | Value Type | Description |
|:-:|:-:|:-:|
| `addr` | [Address](#address) | the address of the account which this signature has been generated for |
| `keyId` | number | The index of the key to use during authorization. (Multiple keys on an account is possible). |
| `signature` | string | a hexidecimal-encoded string representation of the generated signature |



*Last updated on **Dec 3, 2024** by **Jordan Ribbink***

翻訳元

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

***
<b>[Previous << Flow Client Library (FCL)](https://qiita.com/flowcadence/items/4174cc0ae785b1ddb1d6)
</b>

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

<b>[Next >> FCL SDK Reference](https://qiita.com/flowcadence/items/c1a1364b2dba4262bdc1)</b>