バックエンドで実行するためにはウォレットが作成したアドレスでは上手くいきません。ウォレットが作成した秘密鍵はウォレットにアクセスすることでしか取得できないからです。これはバックエンドでトランザクションを行いたい時に.exeなどの実行ファイルだけでは実行できないことを意味します。

そこで、自分たちで秘密鍵とブロックチェーンアドレスを作成します。そしてそれらを使ってバックエンドからトランザクションを実行します。

まず、その前にFlow CLIというツールで flow init を実行したら何ができているのかを紹介します。

{
	"contracts": {
	},
	"dependencies": {
		"Burner": {
			"source": "mainnet://f233dcee88fe0abe.Burner",
			"hash": "71af18e227984cd434a3ad00bb2f3618b76482842bae920ee55662c37c8bf331",
			"block_height": 149816757,
			"aliases": {
				"emulator": "f8d6e0586b0a20c7",
				"mainnet": "f233dcee88fe0abe",
				"testnet": "9a0766d93b6608b7"
			}
		},
		"FlowToken": {
			"source": "mainnet://1654653399040a61.FlowToken",
			"hash": "f82389e2412624ffa439836b00b42e6605b0c00802a4e485bc95b8930a7eac38",
			"block_height": 149816757,
			"aliases": {
				"emulator": "0ae53cb6e3f42a79",
				"mainnet": "1654653399040a61",
				"testnet": "7e60df042a9c0868"
			}
		},
		"FungibleToken": {
			"source": "mainnet://f233dcee88fe0abe.FungibleToken",
			"hash": "3b04b3191e0c5d4d9ee3ce9c671b11985d29bf2732a5721b526cc8523c536f8f",
			"block_height": 149816757,
			"aliases": {
				"emulator": "ee82856bf20e2aa6",
				"mainnet": "f233dcee88fe0abe",
				"testnet": "9a0766d93b6608b7"
			}
		},
		"FungibleTokenMetadataViews": {
			"source": "mainnet://f233dcee88fe0abe.FungibleTokenMetadataViews",
			"hash": "70477f80fd7678466c224507e9689f68f72a9e697128d5ea54d19961ec856b3c",
			"block_height": 149816757,
			"aliases": {
				"emulator": "ee82856bf20e2aa6",
				"mainnet": "f233dcee88fe0abe",
				"testnet": "9a0766d93b6608b7"
			}
		},
		"MetadataViews": {
			"source": "mainnet://1d7e57aa55817448.MetadataViews",
			"hash": "b290b7906d901882b4b62e596225fb2f10defb5eaaab4a09368f3aee0e9c18b1",
			"block_height": 149816757,
			"aliases": {
				"emulator": "f8d6e0586b0a20c7",
				"mainnet": "1d7e57aa55817448",
				"testnet": "631e88ae7f1d7c20"
			}
		},
		"NonFungibleToken": {
			"source": "mainnet://1d7e57aa55817448.NonFungibleToken",
			"hash": "a258de1abddcdb50afc929e74aca87161d0083588f6abf2b369672e64cf4a403",
			"block_height": 149816757,
			"aliases": {
				"emulator": "f8d6e0586b0a20c7",
				"mainnet": "1d7e57aa55817448",
				"testnet": "631e88ae7f1d7c20"
			}
		},
		"ViewResolver": {
			"source": "mainnet://1d7e57aa55817448.ViewResolver",
			"hash": "374a1994046bac9f6228b4843cb32393ef40554df9bd9907a702d098a2987bde",
			"block_height": 149816757,
			"aliases": {
				"emulator": "f8d6e0586b0a20c7",
				"mainnet": "1d7e57aa55817448",
				"testnet": "631e88ae7f1d7c20"
			}
		}
	},
	"networks": {
		"emulator": "127.0.0.1:3569",
		"mainnet": "access.mainnet.nodes.onflow.org:9000",
		"testnet": "access.devnet.nodes.onflow.org:9000"
	},
	"accounts": {
		"emulator-account": {
			"address": "f8d6e0586b0a20c7",
			"key": {
				"type": "file",
				"location": "emulator-account.pkey"
			}
		}
	},
	"deployments": {
		"mainnet": {
		},
		"testnet": {
		}
	}
}

こういう感じのJSONがflow.jsonファイルに作成されています。このflow.jsonがスマートコントラクトをデプロイする時の全ての参照先になります。

最初は"accounts"に"emulator-account"だけあって、"testnet-account"や"mainnet-account"がありません。また、"deployments"が最初はflow init実行した直後は無いですが、ここは今後必要になってきます。

アカウントを作成する

これはFlow CLIを使って作成します。

flow accounts create

実行すると、以下のような出力がされます。

Address	 0x348175517cb1c79e
Balance	 0.00200000
Keys		 1

Key 0	Public Key		 e21fd469bf39be5718fbd16f6444c1c0cef51ec40db865df8a9dc90c443b68946aa7a63d6083666109864511b6c8d589a4cc7202b3257c34c3d1a7885c3de880
		Weight			 1000
		Signature Algorithm	 ECDSA_P256
		Hash Algorithm		 SHA3_256
		Revoked 		 false
		Sequence Number 	 0
		Index 			 0

Contracts Deployed: 0

ECDSA_P256アルゴリズムでPrivate KeyとPublic Key、ブロックチェーンアドレス が一度に作成されます。

flow.jsonを見てみます。

	"accounts": {
		"emulator-account": {
			"address": "f8d6e0586b0a20c7",
			"key": {
				"type": "file",
				"location": "emulator-account.pkey"
			}
		},
		"testnet-account": {
			"address": "348175517cb1c79e",
			"key": {
				"type": "file",
				"location": "testnet-account.pkey"
			}
		}
	},

このように作成されたブロックチェーンアドレス(348175517cb1c79e)がすでにセットされています。Public Keyは見当たりませんが、実はアドレスを生成したときにそこに引数として渡されています。Scanサイト(FlowScan)でこのアドレスを検索するとそこでPublic Keyを見つけることができます。

testnet-account.pkeyというファイルがflow.jsonと同じ階層に作成されているので、それを開いてみるとPrivate Keyが見つかります。

同様にメインネットのアカウントも作成します。

flow accounts create

対象のネットワークにmainnetを選択するとflow.jsonは以下のようになります。

	"accounts": {
		"emulator-account": {
			"address": "f8d6e0586b0a20c7",
			"key": {
				"type": "file",
				"location": "emulator-account.pkey"
			}
		},
		"mainnet-account": {
			"address": "deef3052ad5a0289",
			"key": {
				"type": "file",
				"location": "mainnet-account.pkey"
			}
		},
		"testnet-account": {
			"address": "348175517cb1c79e",
			"key": {
				"type": "file",
				"location": "testnet-account.pkey"
			}
		}
	}

スマートコントラクトをデプロイする

この生成したアカウントにスマートコントラクトをデプロイすることで、好きな時にコントラクトメソッドをトランザクションで実行することができます。Private Keyがウォレットにではなく、testnet-account.pkeyやmainnet-account.pkeyにあるのでこれを.envファイルに貼り付けることで、どこからでもトランザクションを実行することができます。

flow.jsonファイルと同じ階層にcadence/contractsフォルダがすでにあります。そこにHelloWorld.cdcファイルを作成します。そこに以下を貼り付けて保存します。

access(all) contract HelloWorld {
  // Declare a public field of type String.
  //
  // All fields must be initialized in the init() function.
  access(all) var greeting: String

  // Public function that sets our friendly greeting!
  // In your own applications you may want to tighten up this access control.
  access(all) fun changeGreeting(newGreeting: String) {
    self.greeting = newGreeting
  }

  // Public function that returns our friendly greeting!
  access(all) fun hello(): String {
      return self.greeting
  }

  // The init() function is required if the contract contains any fields.
  init() {
    self.greeting = "Hello, World!"
  }
}

ではデプロイしましょう。

flow.jsonを開きます。

	"contracts": {
		"HelloWorld": {
			"source": "./cadence/contracts/HelloWorld.cdc",
			"aliases": {
				"emulator": "f8d6e0586b0a20c7",
				"mainnet": "deef3052ad5a0289",
				"testnet": "348175517cb1c79e"
			}
		}
	},

"emulator"のアドレスは常に"f8d6e0586b0a20c7"です。これは変わりません。

"HelloWorld"の部分はコントラクト名と合わせます。"testnet"と"mainnet"はこれからデプロイするアドレスです。先ほど作成ずみのアドレスを指定します。

次に以下を記入します。

	"deployments": {
		"mainnet": {
			"mainnet-account": [
				"HelloWorld"
			]
		},
		"testnet": {
			"testnet-account": [
				"HelloWorld"
			]
		}
	}

"mainnet-account"と"testnet-account"の部分はflow accounts createコマンドを実行したときに指定した名前です。そのため、人によっては"mainnet-acc"だったり、"testnet-acc"だったりします。入力したアカウント名を入れます。その下に配列を作り、"HelloWorld"をセットします。（一度に複数のコントラクトをデプロイできます）

そして以下を実行します。

flow project deploy --network testnet

おそらく失敗します。Σ＼(￣д￣;)ﾅﾝﾃﾞﾔﾈﾝ

出力結果はこう出ます。

❌ Failed to deploy contract HelloWorld: failed to deploy contract HelloWorld: [Error Code: 1103] error caused by: 1 error occurred:
	* storage limit check failed: [Error Code: 1103] The account with address (348175517cb1c79e) uses 1930 bytes of storage which is over its capacity (0 bytes). Capacity can be increased by adding FLOW tokens to the account.

このstorage limit check failed: [Error Code: 1103]というのは開発していると必ず１回は見ることになります。これはトークンを持っていないよ、ということなので、トークンを補充します。そうすればそこからトランザクションフィーが支払われて実行が成功します。

https://faucet.flow.com/fund-account

にアクセスしてブロックチェーンアドレスを入力するとテストネット用のトークンを100,000もらえます。

再度実行するとこのように表示されるはずです。

Deploying 1 contracts for accounts: testnet-account

HelloWorld -> 0x348175517cb1c79e (a811542caa8f4ce5e897669d887b7b7c12c741e2c798e0f920b5440ab6e2f83e) 

🎉 All contracts deployed successfully

更新する時は以下のコマンドを実行します。

flow project deploy --network testnet --update

スマートコントラクトのフィールドを変更していない限り更新に成功します。（フィールド: initの中で初期化が必要なプロパティ）

Hello, World!の実行

トランザクションの実行

/cadence/transactionsの下にChangeGreeting.cdcファイルを生成します。

そして以下を貼り付けて保存します。

import "HelloWorld"

transaction(greeting: String) {

  prepare(acct: &Account) {
    log(acct.address)
  }

  execute {
    HelloWorld.changeGreeting(newGreeting: greeting)
  }
}

以下のコマンドを実行します。

flow transactions send ./cadence/transactions/ChangeGreeting.cdc "Hello" --network testnet --signer testnet-account

以下のように結果が返されます。

Go言語でもNode.jsでもできます。もちろんOS実行をするのであればFlow CLIはLinuxでもインストールできますので、Pythonでも呼び出して実行することができます。

スクリプトの実行

/cadence/scriptsの下にGetGreeting.cdcというファイルを作成し、以下を貼り付けて保存します。

import "HelloWorld"

access(all) fun main(): String {
  return HelloWorld.hello()
}

以下を実行します。

flow scripts execute ./cadence/scripts/GetGreeting.cdc --network testnet

以下が返されます。

Result: "Hello"

Go言語、Node.jsで実行する時はGeminiなどの生成AIに聞きながら行うと自分で調べるより早く実装できたりします。

秘密鍵は.envファイル等に入れて決してGithubにアップロードしないでください。Private Keyさえあれば以下を実行されてあっという間に全額抜き取られます。

const fcl = require("@onflow/fcl");
const { SHA3 } = require("sha3");
var EC = require("elliptic").ec;
var ec = new EC("p256");
require("dotenv").config();

fcl
  .config()
  .put("flow.network", "mainnet")
  .put("accessNode.api", "https://rest-mainnet.onflow.org");

// CHANGE THESE THINGS FOR YOU
const PRIVATE_KEY = process.env.PRIVATE_KEY;
const ADDRESS = process.env.ADDRESS;
const KEY_ID = parseInt(process.env.KEY_ID);

const hash = (message) => {
  const sha = new SHA3(256);
  sha.update(Buffer.from(message, "hex"));
  return sha.digest();
};

const sign = (message) => {
  const key = ec.keyFromPrivate(Buffer.from(PRIVATE_KEY, "hex"));
  const sig = key.sign(hash(message)); // hashMsgHex -> hash
  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");
};

async function authorizationFunction(account) {
  return {
    ...account,
    tempId: `${ADDRESS}-${KEY_ID}`,
    addr: fcl.sansPrefix(ADDRESS),
    keyId: Number(KEY_ID),
    signingFunction: async (signable) => {
      return {
        addr: fcl.withPrefix(ADDRESS),
        keyId: Number(KEY_ID),
        signature: sign(signable.message),
      };
    },
  };
}

async function sendTx() {
  const addr = process.env.RECIPIENT_ADDRESS;
  const transactionId = await fcl.mutate({
    cadence: `
      import FungibleToken from 0xf233dcee88fe0abe
      import FlowToken from 0x1654653399040a61

      transaction(amount: UFix64, to: Address) {
        let vault: @FlowToken.Vault

        prepare(signer: auth(BorrowValue) &Account) {
          self.vault <- signer.storage
            .borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(from: /storage/flowTokenVault)!
            .withdraw(amount: amount) as! @FlowToken.Vault
        }
        execute {
          getAccount(to)
            .capabilities
            .get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
            .borrow()!
            .deposit(from: <-self.vault)
        }
      }
    `,
    args: (arg, t) => [arg(100.0, t.UFix64), arg(addr, t.Address)],
    payer: authorizationFunction,
    proposer: authorizationFunction,
    authorizations: [authorizationFunction],
    limit: 999,
  });

  console.log({ transactionId });
  fcl.tx(transactionId).subscribe((res) => {
    console.log(res);
  });
}

sendTx();

これはNode.jsのコードですが、Goでは少し違う形になります。

ここで書いている内容はここやここを参考にしてください。鍵のアルゴリズム、PRIVATE_KEY、KEY_IDの部分以外は同じ書き方になります。あくまで同じようなことが書いてあるな、と理解するだけで大丈夫です。大事なのはPrivate Keyを決して公開しない事です。

上記のコードをsendFlow.jsのようなファイルに保存してnode ./sendFlow.jsを実行すれば、Flowトークンを好きな時に他のアカウントに送ることができます。よく使用します。

How to declare

let represents a constant, and var represents a variable.

pub fun main {
   var a: Int = 2 // Regular types cannot contain nil (null).
   var a: Int? = nil // To allow variables to hold nil, use an Optional Type.
   var b Int = a!  // To convert an Optional type to a regular variable, use !. (In this case, it's nil, so it will result in an error.)
}

In Cadence, it is common to convert an optional type to a regular type. Using optional binding (the if let statement) simplifies this process, as the variable within the if let block is no longer optional.

Types

Boolean type

let boolVar: Bool = true

Int type

let int8: Int8 = 127 // -128~127
let int16: Int16 = 32767 // -32768~32767
let int32: Int32 = 2147483647 // -2147483648~2147483647
let int64: Int64 = 9223372036854775807 // -9223372036854775808~9223372036854775807
let int128: Int128 = 9223372036854775808 // -2^127~2^127 − 1
let int256: Int256 = 9223372036854775808 // -2^255~2^255 − 1

UInt type

let uint8: UInt8 = 255 // 0~255
let uint16: UInt16 = 65535 // 0~65535
let uint32: UInt32 = 4294967295 // 0~4294967295
let uint64: UInt64 = 18446744073709551615 // 0~18446744073709551615
let uint128: UInt128 = 18446744073709551616 // 0~2^128 − 1
let uint256: UInt256 = 18446744073709551616 // 0~2^256 − 1

Arbitrary-precision type (Int/UInt)

let integer: Int = 1 // Arbitrary-precision (unbounded)
let uinteger: UInt = 1 // Arbitrary-precision (unbounded)

Word type

Unsigned integer types that do not perform overflow or underflow checks, i.e., those that wrap around, have the prefix “Word” and can represent values within the following range.

let nilWord: Word8? = Word8.fromString("1024") // nil, out of bounds, 0~255
let word16: Word16? = Word16.fromString("255") // 0~65535
let word32: Word32? = Word32.fromString("255") // 0~4294967295
let word64: Word64? = Word64.fromString("255") // 0~18446744073709551615

Fix / UFix type

let fix64: Fix64? = Fix64.fromString("-0.1") // ok, -92233720368.54775808~92233720368.54775807
let ufix64: UFix64? = UFix64.fromString("-0.1") // nil, 0.0~184467440737.09551615

Address type

let some: Address = 0x436164656E636521 // UInt64 length. (Max:18446744073709551615)

AnyStruct / AnyResource type

All types are classified as either AnyStruct or AnyResource. The AnyStruct type can represent all types except for Resource types.

var someStruct: AnyStruct = 1 // Can represent all types except Resource type
var someResource: @AnyResource <- create TestResource()

Always prefix the resource type with the @ directive. Use the <- operator for moves.

Never type

 let x: Never = nil

Return type of the panic function

Character / String type

let char: Character = "\u{FC}"
let someString: String = "Hello, world!"

Functions for each type

Int / Address type functions

/* Convert a number to a string */
let int8Number: Int8 = 127
let int8str String = int8Number.toString()


/* Returns a byte array in big-endian order */
let largeNumber: Int32 = 1234567890
let arr: [UInt8] = largeNumber.toBigEndianBytes() //[73, 150, 2, 210]


/* Convert a string to a number */
let int8str: String = "42"
let int8number: Int64? = Int64.fromString(int8str)


/* Return the maximum value of a number */
let max = UInt8.max // 255


/* Return the minimum value of a number */
let min = UInt8.min // 0


/* Convert a FixedPointNumber to a string */
let fix64number: Fix64 = 1.23
let fix64str String = fix64number.toString()


/* Convert an Address to a string */
let shortAddress: Address = 0x1
let str: String = shortAddress.toString()  // "0x0000000000000001"


/* Convert an Address to a UInt8 array */
let someAddress: Address = 0x436164656E636521
someAddress.toBytes()  // is [67, 97, 100, 101, 110, 99, 101, 33]

String type functions

/* Get the length of a string */
let example: String = "hello"
let length: Int = example.length // 5


/* Convert a string to a byte array using UTF8 encoding */
let str: String = "hello"
let utf8: [UInt8] = str.utf8()


/* Concatenate strings */
let str1 = "hello"
let str2 = "world"
let helloWorld = str1.concat(str2) // "helloworld"


/* Get a part of a string */
let example = "helloworld"
let slice = example.slice(from: 3, upTo: 6) // "low"


/* Convert a string to a byte array represented as a hexadecimal string */
let example = "436164656e636521"
example.decodeHex() // is [67, 97, 100, 101, 110, 99, 101, 33]


/* Convert a string to lowercase */
let example = "Flowers"
example.toLower() // `flowers`


/* Convert a byte array to a hexadecimal string */
let data = [1 as UInt8, 2, 3, 0xCA, 0xDE]
String.encodeHex(data) // is "010203cade"


/* Get one character from a string */
let str = "abc"
let c: Character = str[0] // is the Character "a"

Character type functions

/* Convert a character to a string */
let c: Character = "x"
c.toString()  // is "x"


/* Convert an array of characters to a string */
let rawUwU: [Character] = ["U", "w", "U"]
let uwu: String = String.fromCharacters(rawUwU) // "UwU" 

Collection Types

Array type

How to declare

They can be declared within contract, struct, or resource types, as well as within transaction code. When defined within a smart contract, initialization via init is required.

access(all) contract SampleContract {
    access(contract) var allNames: [String]
    init() {
      self.allNames = []
    }
 }

A Contract is also a type, but in this case, the address where it is deployed is included as part of the type definition. Consequently, Struct and Resource types are never confused with types defined within other Contracts.

Array type functions

/* Retrieve the length of an array */
self.allNames.length


/* Concatenate arrays */
self.allNames.concat(allNames2)


/* Check if an array contains a value */
self.allNames.contains("Kitty")


/* Add a value to array */
self.allNames.append("Jane") // This function mutates the array.


/* Add multiple values to an array */
self.allNames.appendAll("Jane", "Daisy") // This function mutates the array.


/* Get the index of a value in an array */
self.allNames.firstIndex(of: "Daisy")


/* Get a portion of an array */
self.allNames.slice(from: 1, upTo: 3)


/* Insert a value at any position in an array */
self.allNames.insert(at: 2, "Daisy") // This function mutates the array.


/* Remove a value from an array */
self.allNames.remove(at: 1) // This function mutates the array.


/* Remove the first value from an array */
self.allNames.removeFirst() // This function mutates the array.


/* Remove the last value from an array */
self.allNames.removeLast() // This function mutates the array.

Dictionary type

How to declare

They can be declared within contract, struct, or resource types, as well as within transaction code. When defined within a smart contract, initialization via init is required.

access(all) var luckeyNumbers: {String: Int}
init() {
  self.luckeyNumbers = {}
}

When self is referenced within a struct type, it represents the struct type; within a resource type, it represents the resource type; and within a contract, it represents the contract type.

Dictionary type functions

/* Insert a value */
self.luckeyNumbers["Daisy"] = 7


/* ・If you want to raise an error when "Daisy" is not present in `luckeyNumbers`, you can achieve this by using a `pre` block. */
pre {
    self.luckeyNumbers.contains("Daisy"): "Not in luckeyNumbers"
}


/* Get all keys from a Dictionary */
self.luckeyNumbers.keys


/* Get all values from a Dictionary */
self.luckeyNumbers.values // This method cannot be used with a Dictionary containing resources (resources cannot be moved without the <- operator).


/* Insert a value at any position in a Dictionary */
self.luckeyNumbers.insert(key: "Jessica", 42) // If a value already exists, it is returned as an Optional type.


/* Retrieve a value from a Dictionary */
self.luckeyNumbers.remove(key: "Joe") // If a value is present, it returns that value as an Optional type; otherwise, it returns nil.


/* Check if a Dictionary contains a value */
self.luckeyNumbers.containsKey("Kitty")


/* Iterates over all keys in the Dictionary */
self.luckeyNumbers.forEachKey(fun (key: String): Bool {
    // The returned boolean value signals whether to continue
    // true = `continue`
    // false = `break`
    return true
})

pre and post blocks

The pre{} block contains validation logic to be checked before the transaction is executed,

while the post{} block contains validation logic to verify the transaction's validity immediately before it is included in the blockchain.

As the name implies, the pre block is used to verify the validity of values ​​at the beginning of a method. If a value is invalid, a panic (transaction failure) occurs, and the string following the colon (:) is displayed in the transaction result output.

Similarly, the post block is used to verify the validity of values ​​at the end of a method. If a value is invalid, a panic (transaction failure) occurs, and the string following the colon (:) is displayed in the transaction result output.

pre and post blocks can also be used in transaction code; transaction processing proceeds in the order: prepare block -> pre block -> execute block -> post block. (In principle, anything that can be written in a smart contract—except for event declarations—can also be written in transaction code.)

event

You can declare it within the smart contract and invoke it during transaction execution; it can be called from either a smart contract or transaction code. When invoking it, you can pass arguments of the types specified in the event declaration, and by monitoring these in Go or JavaScript, you can track what is happening. Retrieving events is slightly more complex than retrieving blockchain information based on a transaction ID.

Cadence is the smart contract language written in Go. There are only four concepts to learn: variables, collection types (arrays and dictionaries), structs, and resources. Yet, once a smart contract is deployed, it enables not only financial management but also the creation of systems—such as unmanned vegetable stands or financial platforms for ride-sharing—in just a few dozen lines of code by updating and referencing data. You can even build features like game ranking systems in a similar amount of code.

The Cadence language is often referred to as a resource-oriented language. A party holding a resource can execute its internal methods, and the owner stores that resource in the blockchain's internal storage.

Non-resource types (variables, arrays/dictionaries, and structs) do not physically move, so they are not stored in any specific account's storage; instead, they are accessible to everyone. Resources, on the other hand, play a central role in smart contracts because, fundamentally, only their owner can invoke their internal methods; consequently, they are stored in the owner's storage.

When looking at smart contracts, one often sees a structure like the following.

contract A {

  access(all) resource  B {
    access(all) fun setRankingAndDeliverPrize() {
    }
  }

  init {
    self.account.storage.save(<- new B(), to: /storage/B)
  }
}

The smart contract deployer is represented as self.account within the smart contract. Since the init function executes only once—at the time of deployment—this type of code is used when the goal is to create a single, system-critical resource. In the example above, this means that only the smart contract deployer owns Resource B, and only that account can execute the contract's setRankingAndDeliverPrize method. Because this blockchain (Flow) supports scheduled execution, it enables fair, automated operations—such as recalculating rankings and distributing prize money to the top three teams every week.

Regarding the deep technical relationship between the Flow team (Dapper Labs) and the original Diem/Libra team at Meta:

Move & Cadence Shared Roots

While Flow and Libra/Diem were developed in parallel, the Dapper Labs team and Meta's crypto research team collaborated extensively through technical working groups in the 2018–2020 era.

Both teams shared the same fundamental thesis: existing blockchains (like Ethereum's EVM) were structurally unsafe and poorly suited for mainstream consumer applications and NFTs.

1. Resource-Oriented Architecture: Meta created the Move language for Libra, while Dapper Labs created Cadence for Flow. Both languages adopted the "Resource-Oriented Programming" paradigm—a concept originally inspired by Rust's linear type system where digital assets are treated as physical objects in memory that cannot be duplicated, implicit-dropped, or re-entered.

2. Technical Exchange: Engineers from Dapper Labs and Meta regularly cross-pollinated ideas regarding resource safety, access control capabilities, and account abstractions during the initial design phases of both languages.

Why Instagram Supported Flow at NFT Feature Launch

When Meta launched its native NFT and digital collectibles feature on Instagram in May 2022, Flow was chosen as one of the primary launch blockchains alongside Ethereum and Polygon.

This choice was directly tied to those technical roots and operational history:

• Mass-Consumer Scaling: Flow was designed specifically for high-throughput consumer apps (like NBA Top Shot), making it a natural fit for Instagram's massive user base without exposing users to high gas fees or network congestion.

• Shared Developer Philosophy: Because Meta's internal crypto teams were already intimately familiar with Cadence's resource model and Flow's account architecture through their earlier Libra-era working groups, integrating Flow into Instagram's backend infrastructure was smooth and architecturally aligned with Meta's standards.

  ---

  The Flow team frequently held working group sessions with Meta’s Libra (later renamed Diem) foundation, driven by a shared awareness of issues facing existing blockchains. However, it was the Flow team—not Meta’s development team—that ignited the NFT boom. The Cadence smart contract language, written in Go (a language ergonomically superior to Rust), is characterized by being easy to write and learn, making the process of programming enjoyable.

  ---

  Demystifying Cadence: Why Resource-Oriented Programming Prevents Exploits at Compile Time

  In conventional smart contract environments like Ethereum’s EVM, digital assets (like ERC-20 tokens or ERC-721 NFTs) are represented as entries in a central database dictionary. To transfer a token, a contract modifies integer balances mapped to user addresses (balances[from] -= amount; balances[to] += amount).

  This pattern is prone to catastrophic vulnerabilities—such as reentrancy attacks, integer overflows, and unauthorized balance manipulation—because assets do not exist as real objects.

  Flow's Cadence solves this by introducing Resource-Oriented Programming.

Three Technical Pillars of Cadence

1. Linear Types & Assets as "Physical Objects"

   In Cadence, resources represent real-value assets. They are governed by linear typing rules derived from Rust:

   • Cannot be Copied: A resource cannot be duplicated (let clone = resource throws a compile-time error).

   • Cannot be Implicitly Dropped: If a resource is moved into a function scope, it must be explicitly moved into account storage or destroyed using the destroy keyword.

   • Must occupy exactly one location at any time.

// Defining a Resource NFT
access(all) resource NFT {
    access(all) let id: UInt64
    init(id: UInt64) {
        self.id = id
    }
}

// Creating and transferring a resource
access(all) fun mintAndStore(account: &Account) {
    // Uses the move operator '<-' instead of equality '='
    let newNFT <- create NFT(id: 1001)
    
    // The asset MUST be moved to storage, otherwise the compiler throws an error
    account.storage.save(<-newNFT, to: /storage/MyNFT)
}

2. The Move Operator (<-)

To enforce that resources cannot be accidentally overwritten, Cadence uses the explicit move operator <- rather than the standard assignment operator =. This visually and syntactically alerts developers that ownership of an asset is being transferred.

3. Capability-Based Access Control

Instead of checking msg.sender == owner at runtime (a common source of authorization bugs in Solidity), Cadence uses Capabilities. Accounts issue unforgeable references to their private storage paths, delegating precise permissions (e.g., "read-only" vs. "deposit-only") without exposing the underlying asset.

The language itself is similar to Swift. Since the creator of CryptoKitties is a former Apple engineer who worked on Keynote around 2010, the language is highly compatible with Apple's development ecosystem.

You can write everything—including financial calculations, game data management (such as rankings), and asset distribution—within a single piece of code. Furthermore, simply by registering a resource to self, you can freely execute these processes from the backend.

通常のCapabilityはsigner.capabilitiesに対して公開しますが、Capabilityの委任時はsigner.inboxに対して公開します。

通常のCapabilityの公開

/* Create a Thief resource */
signer.storage
    .save(<- MMORPG.createThiefResource(payment: <- payment),
            to: /storage/MMORPGThiefResource)

/* リソースのaccess(all)のフィールドをCapabilityで公開する */
let cap = signer.capabilities
    .storage
    .issue<&MMORPG.Thief>(/storage/MMORPGThiefResource)

signer.capabilities
    .publish(cap, at: /public/MMORPGThiefResource)
                    }

委任時のCapabilityの公開

/* Issue a resource capability for ThiefAbility1 entitlement */
let capability = signer.capabilities
    .storage
    .issue<auth(MMORPG.ThiefAbility1) &MMORPG.Thief>
                                (/storage/MMORPGThiefResource)

/* Publish the capability for the specified recipient */
signer.inbox
    .publish(
        capability,
        name: "PoisonMakingSkill",
        recipient: recipient
    )

recipientは委任する相手のアドレスです。

委任された能力(Capability)を使用する

/* Claim the capability published by buddy */
let capability = signer.inbox
    .claim<auth(MMORPG.ThiefAbility1) &MMORPG.Thief>(
        "PoisonMakingSkill",
        provider: providerAddress
    )
capability!.borrow()!.PoisonMaking(battleId: battleId)

providerAddressは委任したアカウントのアドレス

委任された Capability の一覧表示と UI 設計

Flow の Inbox 仕様上、委任データは受取側へのストレージスパムを防ぐため、受取人（Recipient）のアカウントではなく発行者（Provider）のストレージに保持されます。

そのため、実務の Web3 ゲーム開発では「発行者が公開中の委任一覧スクリプト」や「オンチェーンイベントをオフチェーン DB でインデックスしたデータ」を活用して、受取可能な能力を UI にリアルタイム表示します。

発行中（委任中）の Capability を一覧取得するスクリプト

発行者（Provider）が「誰にどの能力を委任したまま未受取になっているか」を確認、あるいはフロントエンドで利用可能な能力を特定するためのスクリプトです。

import MMORPG from 0xMMORPGAddress

// UI表示用のデータ構造体
access(all) struct InboxItemData {
    access(all) let inboxName: String
    access(all) let ability: String

    init(inboxName: String, ability: String) {
        self.inboxName = inboxName
        self.ability = ability
    }
}

/* クエリー処理 */
access(all) fun main(providerAddress: Address): [InboxItemData] {
    let account = getAccount(providerAddress)
    let inboxItems: [InboxItemData] = []

    // 発行者のアカウントで現在公開・委任中の Inbox 名一覧を取得
    let inboxStorageNames = account.inbox.getNames()

    for name in inboxStorageNames {
        // 具象型 &MMORPG.Thief として中身を安全に参照 (peek)
        if let cap = account.inbox.peek<&MMORPG.Thief>(name: name) {
            if let thief = cap.borrow() {
                inboxItems.append(InboxItemData(
                    inboxName: name,
                    ability: thief.getAbilityDetail()
                ))
            }
        }
    }

    return inboxItems
}

オフチェーン連携と UI 表示の流れ

1. イベント検知と DB 保存: 発行者が signer.inbox.publish(...) を実行すると、Flow のシステムイベント（flow.AccountInboxPublished）が発火します。ゲームのバックエンド（インデクサー）でこれを検知し、providerAddress、recipientAddress、inboxName をデータベースへ保存します。

2. 利用可能スキルの UI レンダリング: 受取人（Recipient）がログインした際、DB から「自分宛てに届いている委任一覧」を取得して UI 上に「仲間から借りられるスキル」として表示します。

3. 安全な Claim と実行: UI から対象のスキルを選択すると、保存されている providerAddress と name を渡して signer.inbox.claim トランザクションを実行し、即座にゲーム内で能力を発動できます。

ゲーム・UI 設計におけるメリット

• ブラインド Claim の防止: プレイヤーは事前に DB やスクリプト経由で「どの仲間から、どんなスキルが委任されているか」を確認してから Claim できます。

• リアルタイム通知・バフ表示: 仲間からスキルが委任された瞬間に「パーティメンバーから支援スキルが届きました！」という通知バッジを表示可能です。

• ガス代ゼロでの事前確認: スクリプト（Read-only）やオフチェーンキャッシュを利用するため、不要なガス代をかけることなく UI を更新できます。

access(all) fun rollDice(): UInt64 {
    // modulo: 6 returns 0, 1, 2, 3, 4, or 5
    let rawRoll: UInt64 = revertibleRandom(modulo: 6)
    return rawRoll + 1
}

現在時刻の取得

self.execTime = getCurrentBlock().timestamp // 秒単位まで

乱数生成と現在時刻取得はグローバルメソッドでありimportは何も必要ありません。

型変換

Cast

let integer: Int = 1
// This is an upcast.
let number = integer as Number // number = 1 and has type Number.  (as はDowncastには使えません)

Conditional Downcast

let something: AnyStruct = 1
let number: Int? = something as? Int    // 1
let boolean: Bool? = something as? Bool // nil (as?はDowncastに使えます。subtypeでなくCast出来ない場合はnilを返す)

Forced Downcast

let something: AnyStruct = 1
let number: Int? = something as! Int  // 1 (as! はDowncastに使えます。 subtypeでない場合はnilを返す)

Forced Unwrap (!)

let c: Int? = 3
let d: Int = c!

Resource Interface

インターフェイスは、実装しなければならない動作（関数やフィールド）の規約を定義するものです。

access(all) resource interface IGreeting {
    access(all) let greeting: String
}

access(all) resource Greeting: IGreeting {
    access(all) let greeting: String
    init() {
        self.greeting = "Hello, World!"
    }
}

access(all) fun createRestrictedGreeting(): @{IGreeting} {
    return <- create Greeting()
}

• インターフェイス型として扱う場合は、@{IGreeting} のように指定します。

• メソッドやフィールドへの詳細なアクセス制限を行いたい場合は、Entitlement を使用して制御します。

(若干、Cadence v1.0以前とCadence v1.0では変更が発生しています。 @Greeting{IGreeting} 構文は廃止され、@{IGreeting} のように指定するなど。)

Operator

=

var a = 4

<-

// リソースを空の変数またはコンテナに移動します。
// 空でないと判断できる場合コンパイルエラーとなります。代わりに<-!を使用してください
return <- create Arms(attack: attack)

<-!

// リソースを Optional (@T?) に代入します。その際、現在の値が nil であることを前提とします（nil でない場合はパニックします）。
self.equippedWeapon <-! newWeapon

<->

// どちらもdestroyすることなく、2つのリソースをアトミックに入れ替えます。
var mainHand: @Arms <- create Arms(name: "Excalibur")
var storage: @Arms? <- nil
mainHand <-> storage

arithmetic(+, -, *, /, %)

let a = 1 + 2 // is 3

super-types (Upcast & Downcast)

// 抽象型 Integer へのアップキャストと、演算実行のための具象型 Int8 へのダウンキャスト（as!）
let x: Integer = 3 as Int8
let y: Integer = 4 as Int8 
let z: Integer = (x as! Int8) + (y as! Int8)
// 1. Storing an Int8 in an Integer variable is an upcast.
// 2. Similarly, 4 is created as Int8 and upcast to Integer.
// 3. Integer is an abstract super-type / interface which does not allow direct arithmetic. Therefore, x and y must be explicitly downcast back to their concrete type using as!.

Ternary Conditional

let x: Int = 1 > 2 ? 3 : 4     // 4
let y: Int? = 1 > 2 ? nil : 3  // 3

Nil-Coalescing (??)

let a: Int? = nil
let b: Int = a ?? 42 // Optional型がnilでなければその値を返し、nilであれば代替の値を返す。)

!

let a = true
let b = !a // false

&&

true && true    // true
true && false   // false

||

false || true   // true
false || false  // false

==

let x: Int? = 1
x == nil  // false

// Comparisons of different levels of optionals are possible.
let x: Int? = 2
let y: Int?? = 2
x == y    // true

let a: Int? = nil            // nil
let b: Int?? = nil           // nil (outer level is nil)
let c: Int?? = (nil as Int?) // Some(nil) (inner level is nil)

a == b // true
b == c // false (b is nil, but c contains an optional holding nil!)

!=

let x: Int? = 1
x != nil  // true

// Comparisons of different levels of optionals are possible.
let x: Int? = 2
let y: Int?? = 2
x != y    // false

<

 1 < 2  // true
 2 < 1  // false

<=

 1 <= 1  // true
 2 <= 1  // false

>

 1 > 1  // false
 2 > 1  // true

>=

 1 >= 1  // true
 1 >= 2  // false

Bitwise operator

Bitwise AND (&)

let firstFiveBits = 0b11111000
let lastFiveBits  = 0b00011111
let middleTwoBits = firstFiveBits & lastFiveBits  // 0b00011000

Bitwise OR (|)

let someBits = 0b10110010
let moreBits = 0b01011110
let combinedbits = someBits | moreBits  // 0b11111110

Bitwise XOR (^)

let firstBits = 0b00010100
let otherBits = 0b00000101
let outputBits = firstBits ^ otherBits  // 0b00010001

Bitwise LEFT SHIFT (<<)

let someBits = 4  // 0b00000100
let shiftedBits = someBits << 2   // 0b00010000

Bitwise RIGHT SHIFT (>>)

let someBits = 8  // 0b00001000
let shiftedBits = someBits >> 2   // 0b00000010

  access(all) struct Info {

    access(contract) var orderQueue: [Order]

    /* setter */
    access(contract) fun setOrder(execTime: UFix64) {
      var order = Order(execTime: execTime)
      self.orderQueue.append(order)
    }

    init() {
      self.orderQueue = []
    }
  }

Struct の初期化方法

access(all) contract RideShare {
    access(self) let info: Info

    access(all) fun getInfo(): Info {
        return self.info
    }

    init() {
        self.info = Info()
    }
}

ここではContract型のinit内で初期化していますが、一つ上のコードで書いたようにStruct型のメソッド内で初期化することもできます。

Struct型の中で別のStruct型を持つことができます。

Resourceの宣言方法

  access(all) resource Admin {

    access(all) var name: String

    init(name: String) {
      self.data = name
    }
  }

Resourceの初期化方法

リソースはStructと違って必ずアカウントのストレージに保存しなければならないので、もしスマートコントラクトのデプロイ時に初期化を行いたい場合は以下のようにします。

access(all) contract RideShare {

       :

    init() {
        self.account.storage.save( <- create Admin("Admin"), to: /storage/RideShareAdmin)
    }
}

create キーワードを使用します。

createキーワードは必ずスマートコントラクト内に書く必要があります。（createキーワードはトランザクションコード内で使用出来ない）

例

    access(all) fun createWarriorResource(payment: @FlowToken.Vault): @MMORPG.Warrior {
        pre {
            payment.balance == 5.0: "Payment must be 5.0 FLOW."
        }

        let warrior <- create Warrior()
        MMORPG.FlowTokenVault.borrow()!.deposit(from: <- payment) 

        return <- warrior
    }

支払いに応じてリソースを作成しています。このメソッドをトランザクション内から実行します。

: @MMORPG.Warrior 

となっている通り、リソースをトランザクションコードに返す場合、返却する型の前には @ をつけます。

トランザクション内でストレージにリソースを保存

/* Create a Warrior resource */
signer.storage
    .save(<- MMORPG.createWarriorResource(payment: <- payment),
            to: /storage/MMORPGWarriorResource)

トランザクション内からcreateWarriorResourceメソッドを呼んでいます。

リソースはContract内でしか生成できないので、管理しやすく、管理番号をつけることが容易になります。

コントラクト内で管理番号やCapabilityを持てる

access(all) contract RideShare {

    access(self) var totalDrivers: UInt // Driver ID
    access(self) let FlowTokenVault: Capability<&{FungibleToken.Receiver}>

    init() {
        self.totalDrivers = 0
        self.FlowTokenVault = self.account.capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
    }
}

このようにContractやStruct、Resourceの中に持てる変数or定数はフィールド(Field)と呼ばれ、必ずinit内で初期化します。フィールドが一つもなければinitは不要です。

ResourceとStructは初期化時に引数を渡せます。Contractの初期化時に引数を渡すにはトランザクションコードのsigner.contracts.addに引数を渡します。

スマートコントラクトのデプロイ時に引数を渡す

transaction(contractName: String, code: String, title: String) {
    prepare(signer: auth(AddContract) &Account) {
        
        signer.contracts.add(
            name: contractName,
            code: code.utf8,
            gameTitle: title // 引数1
        )
    }
}

access(all) contract MyGameItem {
    access(all) var gameTitle: String

    init(gameTitle: String) {
        self.gameTitle = gameTitle
    }
}

まとめ

- 特徴 -

構造体:

• 静的変数のように使える。但し、厳格に型を定める必要がある。

• 宣言時は必ずaccess(all)であり、構造体の型は公開される。

• init以外での構造体の値書き換えにはaccess(contract)より小さいアクセス修飾子がついたSetter関数が必要

リソース:

• クラスオブジェクトに近い

• ポインタの概念を持つ (borrowで拝借することでストレージから移動せずともフィールドにアクセスできる)

• 宣言時は必ずaccess(all)でありクラスの型は公開される

• create演算子でオブジェクトを生成し、オブジェクトはストレージに保存される

• cpu消費を避ける為、基本的にはポインタを通じてresourceのフィールド/メソッドにアクセスする（移動はトランザクションコストが余計にかかる為）

• ストレージ間を移動できる。所有できる。

両者に共通:

• インタフェース(抽象型)を継承できる

• 任意の数のインタフェースを継承することができる

• Swift言語に近いがJava言語にも文法的に似ている(インタフェースを型にするインターセクション<&{FungibleToken.Receiver}> はJava言語と同じ書き方で、このように<&{}>で囲む。そのためJavaエンジニアにとっても親しみやすい文法となっている)

- アクセス方法/保存場所 -

構造体:

• スマートコントラクトのaccess(all)メソッドが入り口となって値を読み書きできる

• スマートコントラクトがデプロイされたアカウントのストレージ内に保存される

リソース:

• スマートコントラクトのaccess(all)メソッドを介してリソースを生成でき、アカウントのストレージ内に保存される

• リソースのメソッドを通じてスマートコントラクトの構造体の値も読み書きできる（逆は構造的に不可能）

• リソースが他のリソースを保持する事も可能である

スマートコントラクトの一例

import "FlowToken"
import "FungibleToken"

access(all) contract MMORPG8 {

  access(self) let FlowTokenVault: Capability<&{FungibleToken.Receiver}>
  access(self) let info: Info
  access(self) var totalGamePlayers: UInt // Player ID

  access(all) entitlement ThiefAbility1
  access(all) entitlement ThiefAbility2
  access(all) entitlement WarriorAbility1
  access(all) entitlement WarriorAbility2

  access(all) event ESportsGamerInitiated(battleId: Int, player1Address: Address, player2Address: Address)

  /* 構造体 */
  access(all) struct Info {

    /* fields */
    access(contract) var battleQueue: [GameBattle]
    access(contract) var basicAbility: {String: String}     // リソース別の基本アビリティ
    access(contract) var basicAttackInfo: {String: [UInt8]} // システム側から通常攻撃トランザクションを行うための情報

    /* setter  <Return: Battle ID> */
    access(contract) fun newGameBattle(
      player1Address: Address,
      player2Address: Address,
      lifeOfPlayer1: UInt8,
      lifeOfPlayer2: UInt8,
      reward: UFix64
    ): Int {
      var battle = GameBattle(
        player1Address: player1Address,
        player2Address: player2Address,
        lifeOfPlayer1: lifeOfPlayer1,
        lifeOfPlayer2: lifeOfPlayer2,
        reward: reward
      )
      self.battleQueue.append(battle)
      return self.battleQueue.length - 1
    }

    /* setter */
    access(contract) fun updateGameBattle(
      battleId: Int,
      target: String?,
      lifeChange: UInt8,
      isDamage: Bool
    ) {
      if (target != nil) {
        self.battleQueue[battleId]!.setPlayerLife(target: target!, lifeChange: lifeChange, isDamage: isDamage)
      } else {
        self.battleQueue[battleId]!.setEnemyLife(damage: lifeChange) // 敵への攻撃は全体攻撃しかない..
      }
    }

    /* init */
    init() {
      self.battleQueue = []
      self.basicAbility = {
       "Warrior-BasicAttack": "Rage Attack",
       "Warrior-ShareableAbility": "LargeRecoveryShield",
       "Thief-BasicAttack": "Whip Attack",
       "Thief-ShareableAbility": "PoisonMaking",
       "Enemy-BasicAttack": "A Crushing Blow"
      }
      self.basicAttackInfo = {
        "Warrior": [1, 3], // [GroupAttack?, damageVolume] (Rage Attack)
        "Thief": [1, 1], // [GroupAttack?, damageVolume] (Whip Attack
        "Enemy": [0, 4] // [GroupAttack?, damageVolume] (A Crushing Blow)
      }
    }
  }

  /* Info内の構造体 */
  access(all) struct GameBattle {

    /* fields */
    access(all) let execTime: UFix64
    access(all) let player1Address: Address
    access(all) let player2Address: Address
    access(all) var lifeOfPlayer1: UInt8
    access(all) var lifeOfPlayer2: UInt8
    access(all) var enemy1Life: UInt8
    access(all) var enemy2Life: UInt8
    access(all) let reward: UFix64

    /* setter(ダメージまたは回復) */
    access(contract) fun setPlayerLife(target: String, lifeChange: UInt8, isDamage: Bool) {
      if (target == "TeamPlayer1") {
        if (isDamage) {
          self.lifeOfPlayer1 = self.lifeOfPlayer1 < lifeChange ? 0 : self.lifeOfPlayer1 - lifeChange
        } else {
          self.lifeOfPlayer1 = self.lifeOfPlayer1 + lifeChange
        }
      } else if (target == "TeamPlayer2") {
        if (isDamage) {
          self.lifeOfPlayer2 = self.lifeOfPlayer2 < lifeChange ? 0 : self.lifeOfPlayer2 - lifeChange
        } else {
          self.lifeOfPlayer2 = self.lifeOfPlayer2 + lifeChange
        }
      }
    }
    /* setter(敵への全体攻撃) */
    access(contract) fun setEnemyLife(damage: UInt8) {
      self.enemy1Life = self.enemy1Life < damage ? 0 : self.enemy1Life - damage
      self.enemy2Life = self.enemy2Life < damage ? 0 : self.enemy2Life - damage
    }

    /* init */
    init(player1Address: Address, player2Address: Address, lifeOfPlayer1: UInt8, lifeOfPlayer2: UInt8, reward: UFix64) {
      let modulo: UInt8 = 3
      self.execTime = getCurrentBlock().timestamp
      self.player1Address = player1Address
      self.player2Address = player2Address
      self.lifeOfPlayer1 = lifeOfPlayer1
      self.lifeOfPlayer2 = lifeOfPlayer2

      // 両方戦士タイプなら悪魔を登場させる
      if (lifeOfPlayer1 > 5 && lifeOfPlayer2 > 5) {
        self.enemy2Life = 9 + revertibleRandom(modulo: modulo) // 9 ~ 11の整数
      } else {
        self.enemy2Life = 5 + revertibleRandom(modulo: modulo) // 5 ~ 7の整数
      }
      self.enemy1Life = 8 + revertibleRandom(modulo: modulo) // 8 ~ 10の整数
      self.reward = reward
    }
  }

  // GET
  access(all) fun getInfo(): Info {
    return self.info
  }

  // PUT
  access(all) fun newGameBattle(
    payment: @FlowToken.Vault,
    player1Address: Address,
    player2Address: Address,
    lifeOfPlayer1: UInt8,
    lifeOfPlayer2: UInt8
  ) {
    let battleId = self.info.newGameBattle(
      player1Address: player1Address,
      player2Address: player2Address,
      lifeOfPlayer1: lifeOfPlayer1,
      lifeOfPlayer2: lifeOfPlayer2,
      reward: payment.balance * 2.0)

    emit ESportsGamerInitiated(battleId: battleId, player1Address: player1Address, player2Address: player2Address)

    // Game Feeをシステムアカウントに保存
    self.FlowTokenVault.borrow()!.deposit(from: <- payment)
  }

  access(all) resource Thief {
    access(all) let id: UInt
    access(all) let maxLife: UInt8

    access(ThiefAbility1) fun PoisonMaking(battleId: Int) {
      MMORPG8.info.updateGameBattle(battleId: battleId, target: nil, lifeChange: 6, isDamage: true)
    }
    access(ThiefAbility2) fun WhipAttack(battleId: Int) {
      MMORPG8.info.updateGameBattle(battleId: battleId, target: nil, lifeChange: 1, isDamage: true)
    }
    
    init() {
      MMORPG8.totalGamePlayers = MMORPG8.totalGamePlayers + 1
      self.id = MMORPG8.totalGamePlayers
      self.maxLife = 5
    }
  }

  access(all) resource Warrior {
    access(all) let id: UInt
    access(all) let maxLife: UInt8

    access(WarriorAbility1) fun LargeRecoveryShield(battleId: Int, target: String) {
      MMORPG8.info.updateGameBattle(battleId: battleId, target: target, lifeChange: 4, isDamage: false)
    }
    access(WarriorAbility2) fun RageAttack(battleId: Int) {
      MMORPG8.info.updateGameBattle(battleId: battleId, target: nil, lifeChange: 3, isDamage: true)
    }

    init() {
      MMORPG8.totalGamePlayers = MMORPG8.totalGamePlayers + 1
      self.id = MMORPG8.totalGamePlayers
      self.maxLife = 8
    }
  }

  access(all) resource Admin {
    access(all) fun payRewards(recipient1: Address, recipient2: Address, reward: UFix64) {
      // Pay the reward.
      let reward1 <- MMORPG8.account
        .storage
        .borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(from: /storage/flowTokenVault)!
        .withdraw(amount: reward) as! @FlowToken.Vault

      getAccount(recipient1)
        .capabilities
        .get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
        .borrow()!.deposit(from: <- reward1)

      let reward2 <- MMORPG8.account
        .storage
        .borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(from: /storage/flowTokenVault)!
        .withdraw(amount: reward) as! @FlowToken.Vault

      getAccount(recipient2)
        .capabilities
        .get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
        .borrow()!.deposit(from: <- reward2)
    }

    access(all) fun basicAttack(battleId: Int, target: String?, resourceName: String) {
      MMORPG8.info.updateGameBattle(battleId: battleId, target: target, lifeChange: MMORPG8.info.basicAttackInfo[resourceName]![1], isDamage: true)
    }
  }

  access(all) fun createWarriorResource(payment: @FlowToken.Vault): @MMORPG8.Warrior {
    pre {
      payment.balance == 5.0: "Cost of resource must be 5.0FLOW coin."
    }
    let _resource <- create Warrior() // resourceは予約語なので_をつけてます

    MMORPG8.FlowTokenVault.borrow()!.deposit(from: <- payment) // 代金徴収
    return <- _resource
  }

  access(all) fun createThiefResource(payment: @FlowToken.Vault): @MMORPG8.Thief {
    pre {
      payment.balance == 5.0: "Cost of resource must be 5.0FLOW coin."
    }
    let _resource <- create Thief()

    MMORPG8.FlowTokenVault.borrow()!.deposit(from: <- payment) // 代金徴収
    return <- _resource
  }

  init() {
    self.info = Info()
    self.FlowTokenVault = self.account.capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
    self.totalGamePlayers = 0
    self.account.storage.save( <- create Admin(), to: /storage/MMORPG8Admin)
  }
}

スマートコントラクトは内部のフィールドに変更があると更新ができません。

その為、フィールドを追加したい場合、コントラクト名を変更するか、デプロイするアカウントを変更する必要があります。コントラクトは削除できないため、"*削除&再デプロイ"*はできません。

トランザクションコード

transactionから始まるCadence言語で書かれた実行メソッドです。スマートコントラクトをimportしそのスマートコントラクトのメソッドを実行することができます。スマートコントラクトのメソッドはaccess(all)メソッドであれば誰でも呼び出せます。

例

  const txId = await fcl.mutate({
      cadence: `
          import CookStocker from 0xb576a3926d239682

          transaction(id: String, add: [String], remove: [String]) {
              prepare(signer: &Account) {
                  CookStocker.setCookStockerInfo(id: id, add: add, remove: remove)
              }
              execute {
                  log("success")
              }
          }
      `,
      args: (arg, t) => [
          arg(id.toString(), t.String),
          arg(add, t.Array(t.String)),
          arg(remove, t.Array(t.String)),
      ],

トランザクションは値を返すことができません。トランザクションはトランザクションIDを返します。このトランザクションIDを使用してトランザクション結果を確認します。

例

fcl.tx(txId).subscribe((res: any) => {
  if (res.status === 4 && !res.errorMessage) {
    isProcessing = false; // ローディングを停止
    syncBalance(); // 残高を更新
    changeScene(); // 次の処理へ
  } else if (res.errorMessage) {
    isProcessing = false;
    alert(res.errorMessage); // トランザクションがpanicで出力した内容もしくは残高不足などのエラーメッセージが含まれます。
  }
});

prepareブロック

prepare(signer: &Account) {

prepareブロックの引数にはトランザクションに署名したアカウントの数だけそのアカウントの情報が渡されます。

Entitlement

エンタイトルメントと呼びます。「権利」という意味になり、スマートコントラクトの中で宣言することでトランザクションコードでも使用可能になります。

例

import "FlowToken"
import "FungibleToken"

transaction(to: Address) {
    let sentVault: @{FungibleToken.Vault}

    prepare(signer: auth(BorrowValue) &Account) {
        // Hardcoded amount: 5.0
        let vaultRef = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
            from: /storage/flowTokenVault
        ) ?? panic("Could not borrow reference to the owner's Vault!")

        self.sentVault <- vaultRef.withdraw(amount: 5.0)
    }

    execute {
        let receiverRef = getAccount(to)
            .capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
            .borrow()
            ?? panic("Could not borrow receiver reference to the recipient's Vault!")

        receiverRef.deposit(from: <-self.sentVault)
    }
}

これは署名したアカウントから5.0FLOWを引き出してtransactionブロックの引数のtoアドレスに対して振り込んでいます。

ごく一般的な送金処理です。

FungibleTokenコントラクトの中などで宣言されたEntitlementはトランザクションコード内でauth()で囲んで使用します。FungibleToken.WithdrawがEntitlementです。BorrowValueはストレージに対するEntitlementです。

どうしても慣れる方が早いので「習うより慣れろ」、という学習スタイルになります。

上記のコードはもっと短くできます。

import "FlowToken"
import "FungibleToken"

transaction(to: Address) {
    prepare(signer: auth(BorrowValue) &Account) {
        // Hardcoded amount: 5.0
        let vaultRef = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
            from: /storage/flowTokenVault)
            ?? panic("Could not borrow reference to the owner's Vault")
        let sentVault <- vaultRef.withdraw(amount: 5.0)

        let receiverRef = getAccount(to)
            .capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
            .borrow()
            ?? panic("Could not borrow receiver reference to the recipient's Vault")
        receiverRef.deposit(from: <-sentVault)
    }
}

executeブロックは署名したアカウントの情報が引数に渡されません。そのため、prepareブロックに必要な情報が全て揃っているため、ここに必要なロジックを書くだけでトランザクションは成立します。transactionブロックの外側にも変数を宣言することができ、その変数を使用してexecuteブロックに値を渡してメイン処理を行う、というのがマナーの良い書き方になります。（しかし、コードが短い方が視認性が良いと考える人はprepareブロックだけを使用します。実際一つ前のコードと見比べてください。明らかにexecuteブロック無しの方が分かりやすいです。手続き型言語のCOBOLのように利用したい場合は、transactionブロックの中で使用できるprepare ブロック、preブロック、execute ブロック、postブロック全てを使用するのもありだと思います。）

クエリー(query)

トランザクションは値を返さずトランザクションIDを返しますが、クエリーは値を指定した型で返します。

export const getInfo = async function (id) {
  const result = await fcl.query({
    cadence: `
    import CookStocker from 0x1234abcd5678efgh

    access(all) fun main(id: String): CookStocker.VegeData? {
        return CookStocker.getCookStockerInfo(id: id)
    }
    `,
    args: (arg, t) => [arg(id, t.String)],
  });
  return result;
};

access(all) fun mainブロックに対し、:をつけて取得する値の型を指定します。CookStocker.VegeData?というOptional型を返します。Resouce型であれば先頭に@がつくので自動的にVegeDataはCookStockerコントラクトのStruct(構造体)であることが分かります。

スマートコントラクトで独自の型を持つのは一般的にContract型とStruct型とResource型だけです。(EventやEntitlementも型と呼ぶ場合はそれも含みます)

ブロックチェーンにアクセスするのは主にこの２つ、トランザクションとクエリーですが、もう一つブロックチェーンにアクセスする方法があります。Eventsです。

Events

例

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

// Subscribe / Query events by event name and block range
const events = await fcl.events("A.0xContractAddress.ContractName.EventName")
  .fromBlockHeight(10000000)
  .toBlockHeight(10000100)
  .subscribe((event) => {
    console.log("Event received:", event);
  });

tx

トランザクション結果をすぐに取得したい場合はEventsではなくtxメソッドを使用します。

fcl.tx(txId).subscribe((res: any) => {
  if (res.status === 4 && !res.errorMessage) {
    isProcessing = false; // ローディングを停止
    syncBalance(); // 残高を更新 (中ではfcl.queryを行っています)
    changeScene(); // 次の処理へ
  } else if (res.errorMessage) {
    isProcessing = false;
    alert(res.errorMessage); // トランザクションがpanicで出力した内容もしくは残高不足などのエラーメッセージが含まれます。
  }
});

クエリーとトランザクションの違い

クエリーは値を変更しようとするとpanicが起こります。(トランザクションフィーを渡していないのでそもそも変更ができない)

１分間に複数回クエリーを発行することを実現する為にはノードを契約するという手法があります。

無料のノードを使用したい場合は以下のようにAccess Nodeを指定します。

  let isTestnet = true;
  if (isTestnet) {
    fcl.config({
      "discovery.wallet": "https://lab.blsqui.net/authn",
      "accessNode.api": "https://rest-testnet.onflow.org",// <-無料
      "flow.network": "testnet",
      "app.detail.title": "Your IP Title here",
      "app.detail.icon": "Your IP Icon URL here",
    });
  } else {
    fcl.config({
      "discovery.wallet": "https://wallet.blsqui.net/authn",
      "accessNode.api": "https://rest-mainnet.onflow.org",// <-無料
      "flow.network": "mainnet",
      "app.detail.title": "Your IP Title here",
      "app.detail.icon": "Your IP Icon URL here",
    });
  }

無料の公開ノードは通常１秒間にリクエスト回数を１回までに押さえておけばエラーになりません。レートリミットを超えても１秒間に１回は正しく値を返してくれることがあります。

リソースのメソッドはaccess(all)であっても決して所有者以外は呼び出すことはできません。(リソースはアカウントストレージ内に保存されるため所有者以外はアクセスできないからです) しかし、viewResolver または Capabilityを使用すると呼び出すことが可能になります。

viewResolverとCapability

あるユーザーがそのリソースに対する「ケイパビリティ（Capability）」を公開していない限り、スクリプトは別のユーザーのプライベートな /storage/ からリソースを任意に読み込んだり借用したりすることはできません。そのため、リソースのデータはメソッドがaccess(all)であってもCapability無しでは決して所有者以外は呼び出すことはできません。

調査するには、主に2つの方法があります。

例1: ViewResolver & MetadataViews

こちらはViewを使用する方法でコントラクト内で設定する様式が細かい為、難易度は高めです。以下は一例。

import MetadataViews from 0x631edd8282631f7b

access(all) fun main(address: Address, id: UInt64): AnyStruct? {
    // Get public account reference
    let account = getAccount(address)

    // Borrow public capability/collection reference
    let collectionRef = account.capabilities.borrow<&{MetadataViews.ResolverCollection}>(
        /public/MyNFTCollection
    ) ?? panic("Could not borrow public collection reference")

    // Resolve the view data safely
    let view = collectionRef.borrowViewResolver(id: id)
    return view.resolveView(Type<MetadataViews.Display>())
}

例2: Capabilityの基本的な使い方を利用する

こちらの方が独自性のあるコードを書けます。

/* スマートコントラクト */
access(all) contract GameItem {
    // Declare Entitlement for write/privileged actions
    access(all) entitlement ManageItem

    access(all) resource Arms {
        access(all) var level: UInt64

        init() { self.level = 10 }

        // PUBLIC: Anyone holding an un-entitled capability can call this
        access(all) fun getLevel(): UInt64 {
            return self.level
        }

        // PROTECTED: Only callers holding auth(ManageItem) capability can call this
        access(ManageItem) fun levelUp() {
            self.level = self.level + 1
        }
    }
}

/* ここからトランザクション: リソースを署名者のストレージに格納 */
import GameItem from 0xCONTRACT_ADDRESS

transaction {
    prepare(signer: &Account) {
        // Save resource
        signer.storage.save(<-GameItem.createArms(), to: /storage/MyArms)

        /* Issue un-entitled capability(auth(ManageItem)がついていないので持ち主以外はlevelUpメソッドを呼び出せません) */
        let cap = signer.capabilities.storage.issue<&GameItem.Arms>(/storage/MyArms)

        /* Publish to /public/ ストレージ */
        signer.capabilities.publish(cap, at: /public/MyArms)
    }
}

/* クエリー処理 */
import GameItem from 0xCONTRACT_ADDRESS

access(all) fun main(player: Address): UInt64 {
    let ref = getAccount(player)
        .capabilities
        .borrow<&GameItem.Arms>(/public/MyArms)
        ?? panic("Could not borrow public capability")

    // Can call access(all) method directly.
    return ref.getLevel()
}

リソースの作成と保存は、「Struct（構造体）と Resource（リソース）の全体像」でも述べます。

Capability

Capabilityは人が保持している（ストレージに保存されている）リソースのメソッドを呼び出すことができます。リソースをストレージに保存する時、ユーザーはストレージに対する保存を許可する署名を行います。その時同時に、どれぐらいまでそのリソースに対するアクセスを人(システム)に許可するかをEntitlementと一緒にCapability で設定します。Entitlement を付けなかったCapabilityはaccess(all)メソッドだけが他人でもアクセスできます。Capabilityを公開しなければ、access(all)も呼び出すことは不可能ですが、署名者はトランザクション時に自由にアクセスできますので特段不都合がある訳ではありません。ゲームであれば必要な情報は構造体(Struct)にまとめておく方が圧倒的に便利であり、Capabilityが必要になるのは(能力<Capability>を委任したい場合など)複雑なシステムだけということが往々にしてあります。

1. Capabilityを発行する（auth()がついてないのでaccess(all)のメソッドのみ呼べます）

   let cap = signer.capabilities.storage.issue<&GameItem.Arms>(/storage/MyArms)
   

2. Capabilityを公開する

   signer.capabilities.publish(cap, at: /public/MyArms)
   

3. Capabilityを拝借する

    let ref = getAccount(player)
        .capabilities
        .borrow<&GameItem.Arms>(/public/MyArms)
        ?? panic("Could not borrow public capability")

４. Capabilityを通じて呼び出す。

return ref.getLevel()

EntitlementをつけてCapabilityを発行する時は以下のようにします。（1.と違ってauth(GameItem.ManageItem)がついています）

let entitledCap = signer.capabilities.storage.issue<
            auth(GameItem.ManageItem) &GameItem.Arms
        >(/storage/MyArms)

Capabilityは必要に迫られるまでは作成しないので最初は気にする必要はありません。

アクセス修飾子

access(all)         権限なくアクセス可能
access(contract)    コントラクト内からであればアクセス可能
access(self)        リソースまたはStruct内からのみアクセス可能
access(Entitlement) 宣言したEntitlementの権限を持っていればアクセス可能

例:
access(ManageItem) fun levelUp() {
  self.level = self.level + 1
}

ウォレットアカウントの情報を取得する

fcl.currentUser().subscribe((newVal: any) => {
    user = newVal;
    syncBalance();
});

Flowネイティブ通貨の残高を取得する

  // Get Player's balance
  async function syncBalance() {
    if (!user?.addr) {
      esportsBalance = '-';
      return;
    };
    const account = await fcl.account(user.addr);
    esportsBalance = String(account.balance);

    if (!esportsBalance.includes('.')) {
      const num = parseFloat(esportsBalance) / 100000000;
      esportsBalance = num.toLocaleString('en-US', {
        minimumFractionDigits: 2,
        maximumFractionDigits: 8
      });
    }
  }

ブロックチェーンシステムを作るに当たり、最初に覚えておかなければならないことはこれぐらいです。これだけ覚えておけば誰でも決済システム・eスポーツを作れます。

宣言方法

letは定数を、varは変数を表します。

pub fun main {
   var a: Int = 2 // 通常の型はnil(ヌル)を含むことができません。
   var a: Int? = nil // 変数にnilを入れられるようにするには、Optional Typeを使用します。
   var b: Int = a!  // Optional Typeをから通常の変数に変換するには ! を使用します。(この場合はnilなのでエラーになります)
}

Cadenceでは、Optional Typeから通常のTypeに変換することがよくあります。そのような場合、Optional Binding ( =if let文 )を使って実装すると、実装が簡単になります。(if letの中に入る変数はOptionalではなくなります)

型の種類

Boolean型

let boolVar: Bool = true

Int型

let int8: Int8 = 127 // -128~127
let int16: Int16 = 32767 // -32768~32767
let int32: Int32 = 2147483647 // -2147483648~2147483647
let int64: Int64 = 9223372036854775807 // -9223372036854775808~9223372036854775807
let int128: Int128 = 9223372036854775808 // -2^127~2^127 − 1
let int256: Int256 = 9223372036854775808 // -2^255~2^255 − 1

UInt型

let uint8: UInt8 = 255 // 0~255
let uint16: UInt16 = 65535 // 0~65535
let uint32: UInt32 = 4294967295 // 0~4294967295
let uint64: UInt64 = 18446744073709551615 // 0~18446744073709551615
let uint128: UInt128 = 18446744073709551616 // 0~2^128 − 1
let uint256: UInt256 = 18446744073709551616 // 0~2^256 − 1

任意精度型 (Int/UInt)

let integer: Int = 1 // 任意精度（理論上無制限 / メモリ依存） / Arbitrary-precision (unbounded)
let uinteger: UInt = 1 // 任意精度（理論上無制限 / メモリ依存） / Arbitrary-precision (unbounded)

Word型

オーバーフロー，アンダーフローのチェックを行わない，すなわちラップアラウンドする符号なし整数型は，Wordの接頭辞を持ち，以下の範囲の値を表現することができます。

let nilWord: Word8? = Word8.fromString("1024") // nil, out of bounds, 0~255
let word16: Word16? = Word16.fromString("255") // 0~65535
let word32: Word32? = Word32.fromString("255") // 0~4294967295
let word64: Word64? = Word64.fromString("255") // 0~18446744073709551615

Fix / UFix型

let fix64: Fix64? = Fix64.fromString("-0.1") // ok, -92233720368.54775808~92233720368.54775807
let ufix64: UFix64? = UFix64.fromString("-0.1") // nil, 0.0~184467440737.09551615

Address型

let some: Address = 0x436164656E636521 // UInt64 length. (Max:18446744073709551615)

AnyStruct / AnyResource型

全ての型は AnyStruct 型か AnyResource 型に分類されます。Resource型以外の全ての型をAnyStruct 型は表現できます。

var someStruct: AnyStruct = 1 // Resource型以外の全ての型を表現できる
var someResource: @AnyResource <- create TestResource()

Resourceの型の前には必ず@指示子をつけます。移動には <- 演算子を使います。

Never型

 let x: Never = nil

panic関数の戻り値の型です。

Character / String型

let char: Character = "\u{FC}"
let someString: String = "Hello, world!"

各型の関数

数値型・Address型 の関数

・数値を文字列に変換する
let int8Number: Int8 = 127
let int8str String = int8Number.toString()


・big-endian の順でバイト配列を返す
let largeNumber: Int32 = 1234567890
let arr: [UInt8] = largeNumber.toBigEndianBytes() //[73, 150, 2, 210]


・文字列を数値に変換する
let int8str: String = "42"
let int8number: Int64? = Int64.fromString(int8str)


・数値の最大値を返す
let max = UInt8.max // 255


・数値の最小値を返す
let min = UInt8.min // 0


・FixedPointNumberを文字列に変換する
let fix64number: Fix64 = 1.23
let fix64str String = fix64number.toString()


・Addressを文字列に変換する
let shortAddress: Address = 0x1
let str: String = shortAddress.toString()  // "0x0000000000000001"


・AddressをUInt8配列に変換する
let someAddress: Address = 0x436164656E636521
someAddress.toBytes()  // is [67, 97, 100, 101, 110, 99, 101, 33]

String型の関数

・文字列の長さを取得する
let example: String = "hello"
let length: Int = example.length // 5


・文字列をUTF8エンコードによるバイト配列に変換する
let str: String = "hello"
let utf8: [UInt8] = str.utf8()


・文字列を結合する
let str1 = "hello"
let str2 = "world"
let helloWorld = str1.concat(str2) // "helloworld"


・文字列の一部を取得する
let example = "helloworld"
let slice = example.slice(from: 3, upTo: 6) // "low"


・文字列を16進文字列で表されるバイト配列に変換する
let example = "436164656e636521"
example.decodeHex() // is [67, 97, 100, 101, 110, 99, 101, 33]


・文字列を小文字に変換する
let example = "Flowers"
example.toLower() // `flowers`


・バイト配列を16進文字列に変換する
let data = [1 as UInt8, 2, 3, 0xCA, 0xDE]
String.encodeHex(data) // is "010203cade"


・文字列から１文字取得する
let str = "abc"
let c: Character = str[0] // is the Character "a"

Character型の関数

・Characterを文字列に変換する
let c: Character = "x"
c.toString()  // is "x"


・Characterの配列を文字列に変換する
let rawUwU: [Character] = ["U", "w", "U"]
let uwu: String = String.fromCharacters(rawUwU) // "UwU" 

Collection

Array型

宣言方法

Contract型の中、Struct型の中、Resource型の中で宣言できます。また、トランザクションコードの中でも宣言できます。スマートコントラクトの中で記載する場合は init による初期化が必要です。

access(all) contract SampleContract {
    access(contract) var allNames: [String]
    init() {
      self.allNames = []
    }
 }

Contractも型ですが、この場合デプロイが行われているアドレスも含めて型とみなされます。そのためStructとResourceの型は他のContractの内部の型と混同されることはありません。

Array型の関数

・ 配列の長さを取得する
self.allNames.length


・配列を結合する
self.allNames.concat(allNames2)


・配列が値を含むかを判定する
self.allNames.contains("Kitty")


・配列に値を追加する
self.allNames.append("Jane") // This function mutates the array.


・配列に複数の値を追加する
self.allNames.appendAll("Jane", "Daisy") // This function mutates the array.


・配列に値を含む場所のインデックスを取得する
self.allNames.firstIndex(of: "Daisy")


・配列の一部を取得する
self.allNames.slice(from: 1, upTo: 3)


・配列の任意の場所に値を挿入する
self.allNames.insert(at: 2, "Daisy") // This function mutates the array.


・配列から値を取り除く
self.allNames.remove(at: 1) // This function mutates the array.


・配列から最初の値を取り除く
self.allNames.removeFirst() // This function mutates the array.


・配列から最後の値を取り除く
self.allNames.removeLast() // This function mutates the array.

Dictionary型

Dictionaryの宣言方法

Contract型の中、Struct型の中、Resource型の中で宣言できます。また、トランザクションコードの中でも宣言できます。スマートコントラクトの中で記載する場合は init による初期化が必要です。

access(all) var luckeyNumbers: {String: Int}
init() {
  self.luckeyNumbers = {}
}

Struct型の中でselfを参照するとStructの型を、Resource型の中でselfを参照するとResourceの型を、Contractの中でselfを参照するとContractの型をそれぞれselfは表します。

Dictionaryの関数

・値を挿入する
self.luckeyNumbers["Daisy"] = 7


・luckeyNumbers に "Daisy" が存在しない場合にエラーを発生させたい場合は、`pre`ブロックを使用することで実現できます
pre {
    self.luckeyNumbers.contains("Daisy"): "Not in luckeyNumbers"
}


・Dictionaryのすべてのキーを取得する
self.luckeyNumbers.keys


・Dictionaryのすべての値を取得する
self.luckeyNumbers.values // このメソッドはリソースを含むDictionaryでは使用できない（リソースは <- オペレーターなしで移動することはできない）


・Dictionaryの任意の場所に値を挿入する
self.luckeyNumbers.insert(key: "Jessica", 42) // 既に値が入っている場合はOptional型でその値を返します。そうでない場合はnilを返します。


・Dictionaryから値を取り出す
self.luckeyNumbers.remove(key: "Joe") // 値が入っている場合はOptional型でその値を返します。そうでない場合はnilを返します。


・Dictionaryが値を含むかを判定する
self.luckeyNumbers.containsKey("Kitty")


・Dictionaryのすべてのキーを繰り返し処理する
self.luckeyNumbers.forEachKey(fun (key: String): Bool {
    // The returned boolean value signals whether to continue
    // true = `continue`
    // false = `break`
    return true
})

preブロックとpostブロック

pre{}ブロックはtransactionが実行される前に確認したい検証ロジック、

post{}ブロックはブロックチェーンに含まれる直前に取引の有効性を確認したい検証ロジックです。

preブロックはその名の通り、メソッドの最初で値の有効性を確認するときに使用します。値が有効でない場合パニック(トランザクション失敗)となり、 : 以降の文字列がトランザクション結果出力時に出力されます。

postブロックはその名の通り、メソッドの最後で値の有効性を確認するときに使用します。値が有効でない場合パニック(トランザクション失敗)となり、 : 以降の文字列がトランザクション結果出力時に出力されます。

pre, postはトランザクションコードでも使用でき、トランザクションの処理はprepareブロック -> preブロック -> executeブロック -> postブロックの順番に進行します。（基本的にeventの宣言以外、スマートコントラクトに書けるものはトランザクションコードでも書けます。）

event

スマートコントラクトの中に宣言し、トランザクション実行時に呼び出します。スマートコントラクトからでもトランザクションコードからでも呼び出せます。呼び出し時、Event宣言時に指定した型の引数を渡すことができ、それをGo言語やJavascriptで監視することで何が起きているかを知ることができます。Event取得処理はトランザクションIDを元にブロックチェーン情報を取得する処理より少し難易度が高いです。

Go言語で書かれたスマートコントラクト用言語です。この言語では変数、Collection型(配列・ディクショナリ)、Struct(構造体)、リソースの4種類しか覚える事はありません。しかし、スマートコントラクトをデプロイしておけば、お金の管理が出来るだけでなく、その情報を更新したり参照することで、無人野菜販売所やライドシェアの金融取引システム等が数十行で書けます。また、ゲーム向けのランキングシステムなんかも数十行で書けます。

Cadence言語はよくResource Oriented (リソース指向)言語と呼ばれます。リソースを持っている人はそのリソースの内部メソッドを実行することができ、リソースの持ち主はそのリソースをブロックチェーン内部のストレージに保存します。

リソース以外 (変数 / 配列・ディクショナリ / 構造体) は物理的に移動しないので特定のアカウントストレージに保存することはしません。そして誰でも共通にアクセスすることができます。リソースは基本的にその所有者しか内部メソッドを呼び出せないことからスマートコントラクトの中心的役割を担うことになり、所有者のストレージに保管されます。

スマートコントラクトを見るとよく以下のような形が見られます。

contract A {

  access(all) resource  B {
    access(all) fun setRankingAndDeliverPrize() {
    }
  }

  init {
    self.account.storage.save(<- new B(), to: /storage/B)
  }
}

スマートコントラクトのデプロイ者はスマートコントラクトの中ではself.accountと表現されます。そしてinitはスマートコントラクトのデプロイ時の一回しか実行されないため、システム上重要なリソースをひとつしか生成したくない場合にこのようなコードが書かれます。上記だとBリソースはスマートコントラクトのデプロイ者だけが所有できることになります。そしてそのアカウントだけがスマートコントラクトのsetRankingAndDeliverPrize メソッドを実行できます。このブロックチェーン(Flow)では予約実行が可能なので、一週間おきにランキングを再計算し、上位3チームに賞金を配布する、といった公正な自動運用が可能となります。

Regarding the deep technical relationship between the Flow team (Dapper Labs) and the original Diem/Libra team at Meta:

Move & Cadence Shared Roots

While Flow and Libra/Diem were developed in parallel, the Dapper Labs team and Meta's crypto research team collaborated extensively through technical working groups in the 2018–2020 era.

Both teams shared the same fundamental thesis: existing blockchains (like Ethereum's EVM) were structurally unsafe and poorly suited for mainstream consumer applications and NFTs.

1. Resource-Oriented Architecture: Meta created the Move language for Libra, while Dapper Labs created Cadence for Flow. Both languages adopted the "Resource-Oriented Programming" paradigm—a concept originally inspired by Rust's linear type system where digital assets are treated as physical objects in memory that cannot be duplicated, implicit-dropped, or re-entered.

2. Technical Exchange: Engineers from Dapper Labs and Meta regularly cross-pollinated ideas regarding resource safety, access control capabilities, and account abstractions during the initial design phases of both languages.

Why Instagram Supported Flow at NFT Feature Launch

When Meta launched its native NFT and digital collectibles feature on Instagram in May 2022, Flow was chosen as one of the primary launch blockchains alongside Ethereum and Polygon.

This choice was directly tied to those technical roots and operational history:

• Mass-Consumer Scaling: Flow was designed specifically for high-throughput consumer apps (like NBA Top Shot), making it a natural fit for Instagram's massive user base without exposing users to high gas fees or network congestion.

• Shared Developer Philosophy: Because Meta's internal crypto teams were already intimately familiar with Cadence's resource model and Flow's account architecture through their earlier Libra-era working groups, integrating Flow into Instagram's backend infrastructure was smooth and architecturally aligned with Meta's standards.

Flow TeamはMeta（メタ）のLibra (後年、Diemと改称) 財団とワーキンググループを頻繁に開催していました。それは共通の既存ブロックチェーンに対する問題意識があったからでした。ただ、NFTブームを引き起こしたのはMetaの開発チームではなくFlowチームの方でした。人間工学的にRustより優れたGo言語で書かれていたCadenceスマートコントラクト言語は書くのが簡単で覚えやすく、プログラムを書くのが楽しい、という特徴があります。

Why Resource-Oriented Programming Prevents Exploits at Compile Time

Ethereum（EVM）などの従来のスマートコントラクトでは、トークンを送金する際は、コントラクト内の残高テーブルを更新する処理（balances[from] -= amount; balances[to] += amount）を行います。しかし、この構造はリエントラント攻撃（再入攻撃）や不正な書き換え、権限チェック漏れなど、バグや資産紛失を引き起こす最大の要因となっていました。FlowのCadenceは、これを「リソース指向プログラミング (Resource-Oriented Programming)」によって根本から解決しました。

Cadenceにおける3つの技術的柱

1. 線形型システムと「実体」としてのデジタル資産

Cadenceにおける「リソース」は、Rustの線形型システムに着想を得た実体オブジェクトです。

• 複製（コピー）の不可: コピー処理はコンパイルエラーになります。

• 暗黙の破棄の不可: 生成されたリソースは、アカウントのストレージに保存されるか、destroy キーワードで明示的に破棄されない限りコンパイルが通りません。

• 常に空間上に1つしか存在しない: ダブルスペンディングが物理的に不可能な設計

// リソース（SomeResource）の定義
access(all) resource SomeResource {
    access(all) let id: UInt64
    init(id: UInt64) {
        self.id = id
    }
}

// リソースの生成とアカウントへの移動
access(all) fun mintAndStore(account: &Account) {
    // 代入 '=' ではなく、移動演算子 '<-' を使用
    let newNFT <- create SomeResource(id: 1001)
    
    // リソースをストレージに移動させないとコンパイルエラーが発生する
    account.storage.save(<-newNFT, to: /storage/SomeResource)
}

2. 移動演算子 (<-) による明確な視覚化

資産の上書き事故を防ぐため、通常の代入演算子 = ではなく、専用の移動演算子 <- を使用します。これにより、コード上で「資産の所有権がどこからどこへ移動したか」が一目で判別できます。

3. ケーパビリティ（Capability）ベースのアクセス制御

Solidityのように実行時に msg.sender == owner などの権限チェック（ヒューマンエラーの温床）を行うのではなく、CadenceではCapability（操作権限への参照）を発行します。「閲覧のみ」「受領のみ」といった最小限のアクセス権限を第三者に安全に委任できます。

言語としてはSwiftに似ています。Crypto Kitties作者が元AppleでKeynoteを2010年ごろ開発していたエンジニアであったため、Appleの開発した情報と親和性が非常にあります。

１枚のプログラミングコードにお金の計算、ランキングなどゲーム情報の管理、資産の分配などを全て書くことができます。それもResourceをselfに対して登録しておくだけでバックエンドから自由にこれらの処理を行うことができます。

日本らしさには、えっこんな方法があったの？というちょっと裏ワザっぽいけど丁寧に作り込まれた奥の深さと、誰も見放さない万人に優しく接する設計が伺えます。

前者には才能が必要ですが、何故か日本の作品はこれができるものが多いですね。

というのが日本らしさの特徴ですが、メタバースのゲームには没入感を売りにしたものであっても(金銭面の臭いがする独特の雰囲気もあります)、なかなか日本人で新規でやろうとする人は少ないように感じます。

メタバースという言葉自体海外から来たものだし、RPGが日本では伝統的に強く、メタバースの面白さがいまいち伝わって来ません。でも伝わってこないだけで、海外ではマインクラフトが大人気なように、没入感があるゲームが大好きです。

日本人はRPG以外を食わず嫌いしているだけです。メタバースゲームでRPGをやってみるのも面白いかも知れませんが、ここは海外で流行っているなら日本らしさを組み合わせたらウケるかもしれない、と考える方がしっくり来ます。

ここでもう一度、日本らしさの定義を。「えっこんな方法があったの？というちょっと裏ワザっぽいけど丁寧に作り込まれた奥の深さ」です。これはアニメのフリーレンとか見ていると同感していただけると思います。

実はこれ、没入感そのものですよね？ポケモンの絶妙な難易度設定、例えばタケシ戦のイワークとか洞窟の攻略とかすごい没入感があります。

考察

でもフリーレンを見ていたら人気の秘訣は「万人受け」も重要な要素だな、と感じます。子供が気に入らないものは作らない、という徹底した万人受けを日本発の作品は狙っています。

メタバースと言えば大人ばっかりが注目しますが、大人向けだとそれはもう日本らしさではなくなってしまうんですよね。

日本人はメタバースという言葉に惑わされている気がします。日本らしさを素で出せればそこには没入感が出来ます。

やはりここは日本の考えと海外の大人気ぶりを融合させるべきだと思います。

Q. そこでBlsquiは何をできるのか？

**A. まず第一に言いたいのは、真正さを出せる事です。**例えばランキングです。スマートコントラクトではチート行為が出来ません。ブロックチェーンのスマートコントラクトは世界で同じものが使われます。チートのないランキングを誰でも作れますし、イカサマや海賊版は一気にその地位を失います。

Blsquiならeスポーツウォレットだからゲームのブリーフィング機能があり、没入感を出せます。スマートコントラクトもMPCでワンクリックでデプロイできます。これは心強いはずです。

Q. Blsquiで没入感を出せる機能は？

**A. 日本人が作った、Flow初の MPC&FLIX ウォレットです。**ドキドキを与える機能と誰でも使える操作性が特徴です。万人受け=安全さを最優先にした信じられないくらいの量の、安全設計を組み合わせています。他にはハンヅオン(**Plug-And-Play)**でプレイヤー同士でアイテムを交換したり、アイテムを売ってポイントや現金を獲得したりすることができます。

でも一番大事なのはスマートコントラクトを書くのが楽しい、ということです。今AIのおかげで全てのプログラムはAIが作れます。ですが、メタバースのスマートコントラクトは今あなたが書けばきっとAIが驚嘆します。AIが知らないことを作っていることになるのですから。

実際、Blsquiを作ってる時は楽しかったですよ。AIが知らないことを作っていく感じがずっとしてて。最近ではUnreal EngineのゲームにLocal Loopbackでブロックチェーンの機能を組み込むっていうのが今のAIでは考えつかないものらしいです。ブロックチェーンはまだまだ固定観念が強力です。そこをスマートコントラクトを書いて世界を驚かすのはアリだと思います。

スマートコントラクトを書くのはいかに楽しいか、それは自分オリジナルのメタバース作品を生み出せる新規性にあります。あなたもスマートコントラクトを書いてみませんか？

https://blsqui.net/technical-docs/creators-four-pillars#smart-contract

この情報をnpmでインストールしたFCL(Flow Client)に渡すと、トランザクションが実行できます。非常に簡単です。

トランザクションはスマートコントラクトのデータ書き換えや、ウォレット間で"もの"を移動させるといったことができます。

FCLに渡したFLIX情報はウォレットが受け取ります。ウォレットはそのFLIXが正規のものか徹底的に検証した後、ウォレットが持つ署名用の鍵で署名します。（俗にいう秘密鍵。当社は多層構造です）署名済みの封筒をFCLに返してトランザクション実行となります。

とまぁ、Web3とだけ聞くと軽く聞こえますが、内部は非常に最新技術です。

トランザクションは色々なことができます。お金を引き出したり、考え次第で無限に色々なことができます。ですが一つのスマートコントラクトで採用しているトランザクションはせいぜい3〜５つぐらいまでです。ゲームであればそれが常に実行されるわけです。引数はまた別で、本体となるコードはほぼ固定されます。

BlsquiはこのコードをID管理し、そのIDを他のトランザクションコードに埋め込むことも可能です。スマートコントラクトがBlsquiTerminalというコントラクトをインポートしていれば、ウォレット間の移動はBlsqui TerminalがそのFLIX IDを実行することで代わりに行えます。

ウォレットに保存させた”もの”の中にFLIXという名のトランザクションコードが埋め込まれている感じです。その”もの”はBlsqui Terminalの中でカード形式で表示されます。

これで何ができるのか。

まず、スマートコントラクトを１クリックでデプロイできます。（デプロイもスマートコントラクトが引数で、コードは定型のコードだからです）

今、カブトムシがブームですよね？例えば「ムシバトル」というゲームを例にします。

カブトムシやクワガタを戦わせるゲームをUnreal Engineで作ります。そこでBlsqui SDKにFLIX IDを渡してLocal Loopbackで勝者に署名を実行してもらいます。

Blsquiターミナルでは勝利して獲得したクワガタカードが表示されます。それはBlsqui Terminal上で知り合い（仲間）にあげる（Transfer）ことができます。ゲームはその処理をする必要がありません。Blsquiが代わりにFLIXを実行します。

これがBlsqui eスポーツウォレットのコア機能、FLIXです。

ですが、最初書いた通り、FCLを使用します。BlsquiはFLIXを本格採用した初のウォレットですので、スポンサーを募集しています。私どもだけでFlow財団と渡り歩くのはちょっと心細いためです。スポンサーを急募しています。LinkedInのメッセージからでも構いません、お待ちしています。

また、賞品の贈与にも使えます。BlsquiTerminalコントラクトには売り戻し用のFLIX IDも埋め込むことができます。プレイヤーは好きな時にそれをポイントステーブルコインにBlsqui Terminal上で換金することができます。

最後はちょっとパチンコみたいな3点方式みたいになりましたが、eスポーツというのは勝利＝当事者の実力なので、法律で定められている賭け事の定義には当てはまりません。（当事者がその実力を持って獲得した場合賭け事とみなさない、と明文化されています。）本来は購入したアイテムを売ることを目的にしたRPGゲーム用に考えたFLIXですから何割で売れるかはスマートコントラクトを開発する側で設定します。当社は実行の代行だけです。

スマートコントラクトはこちら

import "FlowToken"
import "FungibleToken"

access(all) contract RideShare {

  access(self) let FlowTokenVault: Capability<&{FungibleToken.Receiver}>
  access(self) let DriverFlowTokenVault: {UInt: Capability<&{FungibleToken.Receiver}>}
  access(self) let info: Info
  access(self) var totalDrivers: UInt // Driver ID

  /* 構造体 */
  access(all) struct Info {

    access(contract) var driverData: {UInt: DriverData}
    access(contract) var orderQueue: [Order]

    /* setter */
    access(contract) fun setDriver(id: UInt, keys: [String], values: [String]): UInt {
      if let saved = self.driverData[id] {
        for index, key in keys {
          saved.set(key: key, value: values[index])
        }
        self.driverData[id] = saved // 更新
        return id
      } else {
        // 新規登録
        RideShare.totalDrivers = RideShare.totalDrivers + 1
        var data = DriverData()
        for index, key in keys {
          data.set(key: key, value: values[index])
        }
        self.driverData[RideShare.totalDrivers] = data
        return RideShare.totalDrivers
      }
    }

    access(contract) fun setOrder(execTime: UFix64, driverId: UInt, start: String, goal: String, wage: UFix64) {
      var order = Order(execTime: execTime, driverId: driverId, start: start, goal: goal, wage: wage)
      self.orderQueue.append(order)
      
    }

    init() {
      self.driverData = {}
      self.orderQueue = []
    }
  }


  /* Info内の構造体 */
  access(all) struct DriverData {

    access(contract) var data: {String: String}

    /* setter */
    access(contract) fun set(key: String, value: String) {
      self.data[key] = value
    }

    init() {
      self.data = {}
    }
  }

  /* Info内の構造体 */
  access(all) struct Order {

    access(all) let execTime: UFix64
    access(all) let driverId: UInt
    access(all) let start: String
    access(all) let goal: String
    access(all) let wage: UFix64

    init(execTime: UFix64, driverId: UInt, start: String, goal: String, wage: UFix64) {
      self.execTime = execTime
      self.driverId = driverId
      self.start = start
      self.goal = goal
      self.wage = wage
    }
  }

  // GET
  access(all) fun getInfo(): Info {
    return self.info
  }
  // PUT
  access(all) fun setDriverInfo(driverId: UInt, keys: [String], values: [String], flow_vault_receiver: Capability<&{FungibleToken.Receiver}>?) {
    let _driverId = RideShare.info.setDriver(id: driverId, keys: keys, values: values)
    if (flow_vault_receiver != nil) {
      RideShare.DriverFlowTokenVault[_driverId] = flow_vault_receiver
    }
  }

  // PUT
  access(all) fun newOrder(payment: @FlowToken.Vault, execTime: UFix64, driverId: UInt, start: String, goal: String) {
    self.info.setOrder(execTime: execTime, driverId: driverId, start: start, goal: goal, wage: payment.balance * 0.97)
    self.FlowTokenVault.borrow()!.deposit(from: <- payment)
  }

  access(all) resource Admin {
    // ORDER COMPLETE
    access(all) fun payWage(driverId: UInt, wage: UFix64) {
      pre {
        RideShare.DriverFlowTokenVault[driverId] != nil: "Deposit destination is nil, so we can't send wage."
      }
      // Pay the wage.
      let wage <- RideShare.account.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(from: /storage/flowTokenVault)!.withdraw(amount: wage) as! @FlowToken.Vault
      RideShare.DriverFlowTokenVault[driverId]!.borrow()!.deposit(from: <- wage)
    }
  }

  init() {
    self.info = Info()
    self.FlowTokenVault = self.account.capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
    self.DriverFlowTokenVault = {}
    self.totalDrivers = 0
    self.account.storage.save( <- create Admin(), to: /storage/RideShareAdmin)
  }
}

ここでリソース(resource)が初登場します。access(all) resource Admin {

専売的にスマートコントラクトが持っているメソッドでトランザクションを実行する為には、リソースが不可欠だからです。誰でもシステム運営者の所持金を送金できたら、資金が盗難されて困るからです。

スマートコントラクトをデプロイする時（init）にデプロイアカウントに対してAdminというResourceを持たせています。self.account.storage.save( <- create Admin(), to: /storage/RideShareAdmin)

スマートコントラクトのリソースに定義されたメソッドはそのリソースの持ち主にしか呼び出せません。このリソースがドライバーに対して賃金を支払う役割を果たします。（バックエンドで秘密鍵を保持していればバックエンドサーバーが自動でこれを行えます。つまりリソースの保持者かどうかは秘密鍵があっているかどうかで判定します。SSHログインと同じですね。そのため、秘密鍵が１箇所に集約されていないBlsquiはゲームユーザーの権利を守る上で強固なんですね。）

さぁ、あとはスマートコントラクト内部のメソッドを呼ぶ実装をするだけです。

structとresourceの違い

struct:

• 静的変数のNoSQL、但し厳格に型を定める

• 宣言時はaccess(all)であり、構造体の型は公開される

• init以外での値の書き換えにはsetterが必要

resource:

• クラスオブジェクトに近い

• ポインタの概念を持つ

• 宣言時はaccess(all)でありクラスの型は公開される

• create演算子でオブジェクトを生成し、オブジェクトはストレージに保存される

• cpu消費を避ける為、基本的にポインタを通じてresourceのメソッドを呼ぶ

• 動くことができ、ストレージ間を移動する(=所有できる)

注文読み取り

• スマートコントラクトの構造体の情報を取得します。

import { query } from "@onflow/fcl";

export const getRideShareInfo = async function () {
  const result = await query({
    cadence: `
        import "RideShare"

        access(all) fun main(): RideShare.Info? {
            return RideShare.getInfo()
        }
    `,
    args: (arg, t) => [],
  });
  return result;
};

• 複数のアカウントの所持金を取得する

export const getBalances = async function (address) {
    let driverAddress;
    if (import.meta.env && import.meta.env.VITE_DRIVER_ADDRESS) {
        driverAddress = import.meta.env.VITE_DRIVER_ADDRESS;
   }
    const systemAddress = "0xb576a3926d239682";
    const result = await query({
        cadence: `
            import "FlowToken"
            import "FungibleToken"
            access(all) fun main(
                address: Address,
                driverAddress: Address,
                systemAddress: Address
            ): [UFix64] {

                let vaultRef = getAccount(address)
                    .capabilities
                    .borrow<&FlowToken.Vault>(/public/flowTokenBalance)
                    ?? panic("Something wrong happened.")
                let driverVaultRef = getAccount(driverAddress)
                    .capabilities
                    .borrow<&FlowToken.Vault>(/public/flowTokenBalance)
                    ?? panic("Something wrong happened.")
                let systemVaultRef = getAccount(systemAddress)
                    .capabilities
                    .borrow<&FlowToken.Vault>(/public/flowTokenBalance)
                    ?? panic("Something wrong happened.")

                var addresses: [UFix64] = []
                addresses.append(vaultRef.balance)
                addresses.append(driverVaultRef.balance)
                addresses.append(systemVaultRef.balance)
                return addresses
            }
        `,
        args: (arg, t) => [
            arg(address, t.Address),
            arg(driverAddress, t.Address),
            arg(systemAddress, t.Address),
        ],
    });
    return result;
};

RideShareスマートコントラクト内に登録ドライバー全員のアドレスを保存しておくことで、クエリー時にドライバー全員のアドレスを取得することで、ドライバー全員の所持金を一度に取得することも可能です。

トランザクションの送信

• クリプトによる支払い（リソースのストレージ移動はアプリ利用者による署名が必要な処理です）

import { mutate, authz } from "@onflow/fcl";

const formatUFix64 = (num) => Number(num).toFixed(8);

export const newOrder = async function (
    execDateTime,
    driverId,
    start,
    goal,
    price
) {
    const txId = await mutate({
        cadence: `
            import "RideShare"
            import "FlowToken"
            import "FungibleToken"

            transaction(
                execTime: UFix64,
                driverId: UInt,
                start: String,
                goal: String,
                price: UFix64
            ) {
                prepare(signer: auth(BorrowValue) &Account) {
                    let payment <- signer
                        .storage
                        .borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: /storage/flowTokenVault)!
                        .withdraw(amount: price) as! @FlowToken.Vault

                    RideShare.newOrder(
                        payment: <- payment, // リソースを移動する時は <- (Linear Types記号)を使用
                        execTime: execTime,
                        driverId: driverId,
                        start: start,
                        goal: goal
                    )
                }
                execute {
               }
            }
        `,
    args: (arg, t) => [
            arg(formatUFix64(new Date(execDateTime).getTime() / 1000), t.UFix64),
            arg(driverId, t.UInt),
            arg(start, t.String),
            arg(goal, t.String),
            arg(formatUFix64(price), t.UFix64),
        ],

        proposer: authz,
        payer: authz,
        authorizations: [authz],
        limit: 999,
    });
    console.log(txId);
    return txId;
};

このjavascriptメソッドを呼び出すことでRideShareサービスに注文を発行し、同時に支払われたクリプトは一時的にシステムアカウントが受け取ります。注文が実行された時,ドライバーにその内の97%を支払います。3%は支払いマージンとして利益とします。

トランザクションのprepareメソッドはexecuteメソッドと違い、引数にsigner(署名者アカウントのオブジェクト)が入ります。そのためsignerが必要な処理はprepareメソッド内に書きます。

transactionメソッドにはprepare, execute以外にもpreとpostが存在し、トランザクションの処理はprepare -> pre -> execute -> postの順番に進行します。

• ドライバーを登録する処理 (秘密鍵をバックエンドで保持していればバックエンドで実行可能)

import RideShare from 0xb576a3926d239682
import FlowToken from 0x1654653399040a61
import FungibleToken from 0xf233dcee88fe0abe

transaction(driverId: UInt, driverAddress: Address, keys: [String], values: [String]) {
    prepare() {
        let FlowTokenReceiver = getAccount(driverAddress)
            .capabilities
            .get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)

        RideShare.setDriverInfo(driverId: driverId, keys: keys, values: values, 
            flow_vault_receiver: FlowTokenReceiver)
    }
    execute {
        log("success")
    }
}

• ドライバーに報酬を支払う処理

const transaction = `

    import RideShare from 0xb576a3926d239682

    transaction(driverId: UInt, wage: UFix64) {
        prepare(signer: auth(BorrowValue) &Account) {
            let RideShareAdmin = signer
                .storage
                .borrow<&RideShare.Admin>(from: /storage/RideShareAdmin)
                ?? panic("Could not borrow reference to the Administrator Resource.")

            RideShareAdmin.payWage(driverId: driverId, wage: wage)
        }
        execute {
        }
    }
`;

ドライバーに報酬を支払う事はシステムによる特権なので、Adminリソースがその役割を果たします。

こういったシステムはバックエンドで秘密鍵を保持しておくのが通常なので、以下のようなコードで承認関数(authFunctionとauthFunctionForProposer)を自作して自動実行します。

import { config, sansPrefix, withPrefix, mutate, tx } from "@onflow/fcl";


txId = await mutate({
      cadence: transaction,
      args: (arg, t) => [
          arg(message.driverId, t.UInt),
          arg(message.wage, t.UFix64),
      ],
      proposer: authFunctionForProposer,
      payer: authFunction,
      authorizations: [authFunction],
      limit: 999,
});
console.log(`txId: ${txId}`);

tx(txId).subscribe((res) => {
    console.log(res);
});

これはNode.jsによる実行ですが、Go言語でもできます。(FlowとCadenceはGoで書かれているので親和性も高いです)

トランザクション承認を担う関数は少し長いですがこのようになります。

try {

    var IT_KEY_ID = 0;
    if (fs.existsSync('/tmp/sequence.txt')) {
        IT_KEY_ID = parseInt(fs.readFileSync('/tmp/sequence.txt', { encoding: 'utf8' }));
    } else {
        IT_KEY_ID = 10;
    }
    IT_KEY_ID = !IT_KEY_ID || IT_KEY_ID >= 10 ? 0 : IT_KEY_ID + 1;
    fs.writeFileSync('/tmp/sequence.txt', IT_KEY_ID.toString());

    console.log('IT_KEY_ID', IT_KEY_ID);

    // CHANGE THESE THINGS FOR YOU
    const PRIVATE_KEY = fs.readFileSync('testnet-account.pkey', { encoding: 'utf8' });
    const ADDRESS = '0x975b04756864e9ea';
    const KEY_ID = 0;

    const hash = (message) => {
        const sha = new SHA3(256);
        sha.update(Buffer.from(message, 'hex'));
        return sha.digest();
    };

    const sign = (message) => {
        const key = ec.keyFromPrivate(Buffer.from(PRIVATE_KEY, 'hex'));
        const sig = key.sign(hash(message)); // hashMsgHex -> hash
        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');
    };

    async function authFunction(account) {
        return {
            ...account,
            tempId: `${ADDRESS}-${KEY_ID}`,
            addr: sansPrefix(ADDRESS),
            keyId: Number(KEY_ID),
            signingFunction: async (signable) => {
                return {
                    addr: withPrefix(ADDRESS),
                    keyId: Number(KEY_ID),
                    signature: sign(signable.message)
                };
            }
        };
    }
    async function authFunctionForProposer(account) {
        return {
            ...account,
            tempId: `${ADDRESS}-${IT_KEY_ID}`,
            addr: sansPrefix(ADDRESS),
            keyId: Number(IT_KEY_ID),
            signingFunction: async (signable) => {
                return {
                    addr: withPrefix(ADDRESS),
                    keyId: Number(IT_KEY_ID),
                    signature: sign(signable.message)
                };
            }
        };
    }

IT_KEY_ID = !IT_KEY_ID || IT_KEY_ID >= 10 ? 0 : IT_KEY_ID + 1;は何をしているかというと、バックエンドでは連続でトランザクションを実行することになると思いますが、ブロックチェーン側は連続処理に対し、KEY_IDの変更を求めてきます。（リプレイアタックの防止）

txId = await mutate({
   cadence: transaction,
   args: (arg, t) => [arg(gamerId, t.UInt), arg(outcome, t.Bool)],
   proposer: authFunctionForProposer, // キーをサイクルする承認関数
   payer: authFunction,               // キーをサイクルしない承認関数
   authorizations: [authFunction],    // キーをサイクルしない承認関数
   limit: 999,
});

(サンプルコードはこちらにあります。)

これでドライバーが売り上げの97%を取得できるアプリが明日からでも運用できます。

ブロックチェーンの情報はjavascript があれば取得できます。今、どんな組み込みソフトウェアでもWebKitは使えるはずですので、つまり、全ての機器はブロックチェーンから情報を取得することができます。

今から、この画像にあるような無人野菜販売所のアプリを作ります。

(無人野菜販売所に立てかけたQRコードで支払ってもらう購入手数料が0のシステムです)

ではスマートコントラクトから見ていきましょう。ベースはCookStockerスマートコントラクトで、違うところは在庫の概念を追加したこととお金を徴収できるようにしたところです。差分は以下です。

import "FlowToken"
import "FungibleToken"

access(all) contract VegeSeller {

   access(self) let FlowTokenVault: Capability<&{FungibleToken.Receiver}>

まず、お金を徴収できるコントラクト（FlowTokenとFungibleToken）をインポートします。

本当は入金先を生産者別に用意すべきですが、ここではとりあえずこのコントラクトをデプロイしているアカウントに全ての代金を入金させます。

/* setter */
access(contract) fun set(id: String, add: [String], addAmount: [UInt8], remove: [String]) {
    if let saved = self.data[id] {
        for index, name in add {
            saved.set(category: name, amount: addAmount[index])
        }
        for name in remove {
            saved.unset(category: name)
        }
        // Save
        self.data[id] = saved

差分の１つ目です。forループにindexがありますので、これを使用してsetメソッドを生産者による在庫調整のメソッドに変えていきます。但し、forループをあまり大量に実行するとトランザクション費用が比例して上がることになります。

2行目のIf let で取得したオブジェクトの要素(saved となっている変数)は変更しても、再度オブジェクト(self.data)にセットしないとスマートコントラクト内で変更は反映されません。(1番下の行)

access(contract) fun buy(id: String, buy: [String]) {
    if let saved = self.data[id] {
        for name in buy {
            if (saved.data[name] == nil) {
                panic("The stock is empty.")
            }
            saved.set(category: name, amount: saved.data[name]! - 1)
        }
        // Save
        self.data[id] = saved
     } else {
        panic("No data.")
     }
}

購入処理（在庫の野菜数を減少させる処理）のスマートコントラクトのコードです。

/* setter */
access(contract) fun set(category: String, amount: UInt8) {
    self.data[category] = amount
}

在庫処理のコードです。前回のスマートコントラクトで日時を入れていたところを数値に置き換えただけです。

// BUY
access(all) fun buyVege(id: String, amount: @FlowToken.Vault, buy: [String]) {
    self.info.buy(id: id, buy: buy)
    self.FlowTokenVault.borrow()!.deposit(from: <- amount)
}

購入処理のメソッドの始まりのコードです。このメソッドに対して外部のjavascriptからfclを使ってトランザクション送信することで購入処理を実行することができます。3行目ではこのスマートコントラクトをデプロイしているアカウントに対して代金を入金しています。

    init() {
        self.info = Info()
        self.FlowTokenVault =  self.account
            .capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
    }
}

最後に、このスマートコントラクトをデプロしているアドレスを入金先にして完成です。

全体のスマートコントラクトは以下です。

import "FlowToken"
import "FungibleToken"

access(all) contract VegeSeller {

    access(self) let FlowTokenVault: Capability<&{FungibleToken.Receiver}>
    access(self) let info: Info

    /* 構造体 */
    access(all) struct Info {

       access(contract) var data: {String: VegeData}

        /* setter */
       access(contract) fun set(id: String, add: [String], addAmount: [UInt8], remove: [String]) {
           if let saved = self.data[id] {
               for index, name in add {
                   saved.set(category: name, amount: addAmount[index])
               }
               for name in remove {
                   saved.unset(category: name)
               }
               // Save
               self.data[id] = saved
           } else {
               var data = VegeData()
               for index, name in add {
                   data.set(category: name, amount: addAmount[index])
               }
               for name in remove {
                   data.unset(category: name)
               }
               self.data[id] = data
           }
       }
       access(contract) fun buy(id: String, buy: [String]) {
          if let saved = self.data[id] {
              for name in buy {
                  if (saved.data[name] == nil) {
                      panic("The stock is empty.")
                  }
                  saved.set(category: name, amount: saved.data[name]! - 1)
              }
              // Save
              self.data[id] = saved
          } else {
              panic("No data.")
          }
       }

       init() {
          self.data = {}
       }
    }

    /* Info内の構造体 */
    access(all) struct VegeData {

       access(contract) var data: {String: UInt8}

       /* setter */
       access(contract) fun set(category: String, amount: UInt8) {
          self.data[category] = amount
       }

       access(contract) fun unset(category: String) {
          self.data[category] = nil
       }

       init() {
          self.data = {}
       }
    }

    // GET
    access(all) fun getVegeSellerInfo(id: String): VegeData? {
       return self.info.data[id]
    }
    // PUT
    access(all) fun setVegeSellerInfo(id: String, add: [String], addAmount: [UInt8], remove: [String]) {
       self.info.set(id: id, add: add, addAmount: addAmount, remove: remove)
    }
    // BUY
    access(all) fun buyVege(id: String, amount: @FlowToken.Vault, buy: [String]) {
       self.info.buy(id: id, buy: buy)
       self.FlowTokenVault.borrow()!.deposit(from: <- amount)
    }

    init() {
        self.info = Info()
        self.FlowTokenVault = self.account
            .capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)
    }
}

このスマートコントラクトを blsqui.net のウェブサイトの左上にあるデプロイボタンでデプロイします。

buyVegeメソッドのamount引数が@FlowToken.Vaultという特別な型を持ってます(灰色の部分)。これはリソースの型を表します。Cadence言語においてResourceの型は特別な型なので@をつける仕様になっています。

&{FungibleToken.Receiver}となっている部分はこれはインタフェースを型にする時に使用します。&{}でインタフェースを型にする（インターセクションと呼ばれます）のはJava言語にもあるようで結構普遍的な書き方です。Entitlementというインタフェースの簡易版がでていますので現在はあまり使われなくなりましたが、以前はCapabilityを公開する時に、Capabilityのインタフェースを型にするため、この&{}を使用していました。

野菜購入のトランザクション

flow_blockchainフォルダにtransactions.jsファイルを新規作成します。

import { mutate, authz } from “@onflow/fcl";

export const buyVege = async function (id, buy, price) {
    const txId = await mutate({
        cadence: `
            import "VegeSeller"
            import "FlowToken"
            import "FungibleToken"

            transaction(id: String, buy: [String], price: UFix64) {
                prepare(signer: auth(BorrowValue) &Account) {
                    let payment <- signer
                        .storage
                        .borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: /storage/flowTokenVault)!
                        .withdraw(amount: price) as! @FlowToken.Vault
                    VegeSeller.buyVege(id: id, amount: <- payment, buy: buy)
                }
                execute {
                    log("success")
                }
            }
        `,
        args: (arg, t) => [
            arg(id.toString(), t.String),
            arg(buy, t.Array(t.String)),
           arg(price, t.UFix64),
        ],
        proposer: authz,
        payer: authz,
        authorizations: [authz],
        limit: 999,
    });
    console.log(txId);
    return txId;
};

（コードはこちらにあります。）

これを実行すると野菜を購入するためにお金を支払うことを承認するように求めるポップアップがログインしているユーザが見ている画面に表示されます。

(このポップアップはiFrameによるものですが、それはウォレットプロバイダーが自由に設定することができます。ブラウザの別タブに承認画面を出させることも出来ます。)

fclが提供しているmutateメソッドはトランザクションIDを返します。これをFlowscanのホームページ (https://www.flowscan.io/) に貼り付けるとトランザクションが成功したかどうかをすぐに分かりますので、大体の場合はどこかにログとして残しておきます。

txメソッドのsubscribeで得られるステータスを確認し、ステータスがSEALEDになったら購入者に解錠ボタンを押してもらい、無人野菜販売所の野菜ストッカーは内蔵されるWebKitがブロックチェーンと通信し野菜が購入がされたかを確認し、アンロックする機能だけがあればシステムとして完成です。

今から、この画像にあるような冷蔵庫にある野菜保存室の管理アプリを作ります。(野菜を購入した日付をブロックチェーンで管理するアプリです)

では作りましょう。まずはスマートコントラクトからです。CookStocker.cdcというファイルをflow_blockchain/cadence/contractsフォルダの中に作ります。以下を入力しましょう。

access(all) contract CookStocker {

  access(self) let info: Info

  /* 構造体 */
  access(all) struct Info {

    access(contract) var data: {String: VegeData}

    /* setter */
    access(contract) fun set(id: String, add: [String], remove: [String]) {
      if let saved = self.data[id] {
        for name in add {
          saved.set(category: name, bought_at: getCurrentBlock().timestamp)
        }
        for name in remove {
          saved.unset(category: name)
        }
        // Save
        self.data[id] = saved
      } else {
        var data = VegeData()
        for name in add {
          data.set(category: name, bought_at: getCurrentBlock().timestamp)
        }
        for name in remove {
          data.unset(category: name)
        }
        self.data[id] = data
      }
    }

    access(contract) fun delete(id: String) {
      self.data[id] = nil
    }

    init() {
      self.data = {}
    }
  }

  /* Info内の構造体 */
  access(all) struct VegeData {

    access(contract) var data: {String: UFix64?}

    /* setter */
    access(contract) fun set(category: String, bought_at: UFix64) {
      self.data[category] = bought_at
    }

    access(contract) fun unset(category: String) {
      self.data[category] = nil
    }

    init() {
      self.data = {}
    }
  }

  // GET
  access(all) fun getCookStockerInfo(id: String): VegeData? {
    return self.info.data[id]
  }
  // PUT
  access(all) fun setCookStockerInfo(id: String, add: [String], remove: [String]) {
    self.info.set(id: id, add: add, remove: remove);
  }
  // DELETE
  access(all) fun deleteCookStockerInfo(id: String) {
    self.info.delete(id: id)
  }

  init() {
    self.info = Info()
  }
}

黄色と黄緑色で表示されているのは型です。addとremove引数が[String]となっていることからこれらは文字列の配列ということになります。紫色で表示されている nilとはnullのことです。(Cadenceではnullをnilと表現します。)

Swiftと文法がよく似ており、特に if let 文はSwift言語の特徴ですので、わからない所に出会ったら"Swift"と一緒に検索して調べるといいと思います。セミコロンはあってもなくてもいいです。

getCurrentBlock().timestamp は秒単位でブロックが生成される時間をエポック秒で取得します。(秒単位ですので、date関数に渡す時には後ろに’000’をつける必要があります)

このスマートコントラクトを blsqui.net のウェブサイトの左上にあるデプロイボタンでデプロイします。

スマートコントラクトに保存された情報を取得

まず、fcl (Flow Client Library)を用意する必要がありますので、インストールします。

npm install @onflow/fcl

このコマンドをTerminalで実行するとfclがJavaScriptで使えるようになります。Svelteだとフレームワーク設定が必要ないので簡単に開発に着手できます。

次に、以下のようなメソッドを用意します。(言語はJavascriptです) flow_blockchainフォルダにscripts.jsというファイルを新規作成して以下を入力します。

import { query } from "@onflow/fcl";

export const getInfo = async function (id) {
  const result = await query({
    cadence: `
    import CookStocker from 0x1234abcd5678efgh

    access(all) fun main(id: String): CookStocker.VegeData? {
        return CookStocker.getCookStockerInfo(id: id)
    }
    `,
    args: (arg, t) => [arg(id, t.String)],
  });
  return result;
};

（コードはこちらにあります。）

このJavascriptファイルは大体、flow_blockchainフォルダの下ぐらいに置きますがどこに配置しても構いません。

このメソッドはCookStockerスマートコントラクトに保存されている情報を取得するgetCookStockerInfoというメソッドを実行してその情報を返します。

あとはこのscripts.jsファイル内でexportされているgetInfoメソッドを呼び出すだけです。

import { config } from "@onflow/fcl";
import { getInfo } from '../../flow_blockchain/scripts';

config({
    'flow.network': 'testnet',
    'accessNode.api': 'https://rest-testnet.onflow.org',
});

const id = localStorage.getItem('ID') || Math.random().toString();
localStorage.setItem('ID', id);

setInterval(async () => {
    info = await getInfo(id);
    console.log(info); <- ここでブラウザのConsoleにログを出しています
}, 1500); (1秒おき以上だと無料で呼び出せます)

 {#each Object.keys(list) as name}
     <VegeCard name={name} pastDate={
         info ? new Date(parseInt(info.data[name]) * 1000).getTime() : null
     } />
 {/each}

最初はまだ情報がコントラクトに登録されていないのでnullがConsoleに出力されます。

スマートコントラクトに情報を保存する

スマートコントラクトのコード内に、ブロックチェーンに保存するメソッドと、保存データを削除するメソッドが書かれています。

スマートコントラクトにデータの保存を行うトランザクションは以下のように記述します。

import { mutate } from "@onflow/fcl";

  const txId = await mutate({
      cadence: `
          import CookStocker from 0xb576a3926d239682

          transaction(id: String, add: [String], remove: [String]) {
              prepare(signer: &Account) {
                  CookStocker.setCookStockerInfo(id: id, add: add, remove: remove)
              }
              execute {
                  log("success")
              }
          }
      `,
      args: (arg, t) => [
          arg(id.toString(), t.String),
          arg(add, t.Array(t.String)),
          arg(remove, t.Array(t.String)),
      ],

この下に承認関数が来るのですが、とりあえず省きます。

スマートコントラクトのsetCookStockerInfoメソッドを呼び出して引数に保存したい情報を渡しています。

全削除ボタンを押した時のトランザクションのメソッド

const txId = await mutate({
    cadence: `
        import CookStocker from 0xb576a3926d239682

        transaction(id: String) {
            prepare(signer: &Account) {
                CookStocker.deleteCookStockerInfo(id: id)
            }
            execute {
                log("success")
            }
        }
    `,
    args: (arg, t) => [arg(id.toString(), t.String)],

こちらのコードも承認関数を省いています。引数にはブロックチェーンに渡す値をセットしています。id.toString()となっている部分ですね。

idとはユーザー別に保存を管理するための識別子です。

スマートコントラクトの全削除を行うところのコードを見てみましょう。

    access(contract) fun delete(id: String) {
      self.data[id] = nil
    }

削除していますね。

もう一回スマートコントラクトの構造体のところを見てみましょう。

  access(self) let info: Info

  /* 構造体 */
  access(all) struct Info {

    access(contract) var data: {String: VegeData}

    /* setter */
    access(contract) fun set(id: String, add: [String], remove: [String]) {
      if let saved = self.data[id] {
        for name in add {
          saved.set(category: name, bought_at: getCurrentBlock().timestamp)
        }
        for name in remove {
          saved.unset(category: name)
        }
        // Save
        self.data[id] = saved
      } else {
        var data = VegeData()
        for name in add {
          data.set(category: name, bought_at: getCurrentBlock().timestamp)
        }
        for name in remove {
          data.unset(category: name)
        }
        self.data[id] = data
      }
    }

    access(contract) fun delete(id: String) {
      self.data[id] = nil
    }

    init() {
      self.data = {}
    }
  }

  /* Info内の構造体 */
  access(all) struct VegeData {

    access(contract) var data: {String: UFix64?}

    /* setter */
    access(contract) fun set(category: String, bought_at: UFix64) {
      self.data[category] = bought_at
    }

    access(contract) fun unset(category: String) {
      self.data[category] = nil
    }

    init() {
      self.data = {}
    }
  }

スマートコントラクトの構造体は複雑な構造のデータを保存することができます。（だから構造体。）

一番上に access(self) let info: Info というのが見えますね。これはスマートコントラクトにinfoというフィールドがあり、それはInfo型であることを示しています。

だからスマートコントラクトの中では

  access(all) fun getCookStockerInfo(id: String): VegeData? {
    return self.info.data[id]
  }

このようにして スマートコントラクトのinfoフィールドのデータにアクセスすることができます。

このコードの１行目の後ろをよくみるとVegeData?というのが見えますね。これはinfo.data が 以下のように定義されているためです。

  access(all) struct Info {

    access(contract) var data: {String: VegeData}

あとは簡単VegeDataという構造体を新しく作るだけです。

基本的に変数や配列以上に複雑な構造を作ろうとすると、それは全て構造体になります。構造体のフィールドがやはり変数や配列より複雑であればそれも構造体です。

慣れれば簡単、基本的な文法はSwiftというモダン言語と同じです。

今回は基本部分だけ。

この構造体の情報はスマートコントラクトを保存しているアカウント（つまりデプロイしているアカウント）に保存されます。

何に役立つかというと、消えない、世界で共通の情報として使うことができます。

構造体はスマートコントラクトをデプロイした人であれば、その情報を変えることは簡単なので、あくまでスマートコントラクトのロジックで必要な情報の格納先として使うのが正しい使い方だと思います。

だから、賞品やトロフィー🏆などは構造体内では扱いません。

主な機能

ゲーム開発者は Blsqui SDK を導入することで、Point-to-Pointステーブルコインや独自ブランドのトークン、暗号資産をゲーム内決済へと手軽に組み込むことが可能です。さらに、ステーブルコイン等のスマートコントラクトをワンクリックで安全にデプロイできる、堅牢なブロックチェーンインフラも標準提供します。

独自のポイントベースのステーブルコインをゲーム内通貨として利用可能

弊社の最先端インフラを使用したサービスを利用するメリット

1. すべての開発者およびユーザーが、決済手数料無料で決済画面機能を利用できます。 

2. Unreal EngineやUnity、Godotのマルチゲームエンジンに対応した、ガス代が不要なステーブルコイン決済を実現します。 

3. MPC-CMP（マルチパーティ計算）閾値署名技術を搭載。高速な処理速度を維持したまま、堅牢な多層鍵管理セキュリティを提供いたします。 

4. 事前設定不要のネイティブウォレット層を同時提供。従来なら数週間を要した決済機能の組み込みをわずか1~2時間へと短縮できます。

5. ユーザーが自信をもって決済できるスマートコントラクトコードのレジストリシステムを搭載。（FLIXシステム）これにより決済画面に多言語に対応した決済の説明表示が可能です。

弊社の決済インフラはエンタープライズグレードのネットワークを使用しており、最先端のインフラ環境となっています

1. DNSから弊社サーバーのIPアドレス追跡を隠蔽するIP Maskingを実施しています。 

2. トランザクション履歴の追跡にCDN Functions を利用し、低遅延を実現、また、ブロックチェーンAPI情報の完全抽象化を実現しています。 

3. AI活用のAnti-DDoS機能により分散型大規模DoS攻撃に対応しています。 

4. Threat Filteringにより、APIに対するあらゆる怪しい攻撃を遮断しています。

ブロックチェーンAPI情報の完全抽象化を実現

Blsqui SDK が外部から取得する情報はブロックチェーンAPIによる影響がゲーム内に及ばない設計になっています。APIのバージョンアップ等でレスポンス形式が変わったとしてもゲーム内SDKがアップデートを強いられることは、決してありません。

世界300都市で最新のCDN Functionによる抽象化ロジックが同時に展開され、ゲーム内SDKには最適化されたレスポンスのみが提供されます(下図)。これにより、JSONの解析に必要となるメモリ使用量も最小限に抑えることができます。

{
  "status": "SEALED",
  "txId": "fb1272c57c...",
  "nonce": "fb1272c57c...",
  "errorMessage": null,
  "payer": "fb1272c57c...",
  "amount": "10.00",
  "currency": "USDC",
  "timestamp": 1722052603
}

私達のビジョン

10年以上にわたり、ゲーム開発者はクレジットカードの決済手数料として2〜3%を支払うことに加え、従来のプラットフォーム運営会社に対して総収益の30%を差し出すことを余儀なくされてきました。

Blsquiはこうした障壁を解消するため、「ポイント・ツー・ポイント（共通ポイントをブロックチェーンのステーブルコインとして決済する仕組み）」のチェックアウトフローを採​​用することにしました。また、Blsqui SDKにおいてRFC 8252に着想を得たローカルHTTPループバックによるゲーム中にスムーズに決済スクリーンを表示する機能を実現してきました。トランザクションID（txId）を、Unreal EngineやUnity、Godotといったネイティブゲームエンジン内で生成された決済参照番号へと安全に受け渡します。

ゲームパブリッシャー向け Blsqui SDKの主な特徴

• パブリッシャーは収益の100%を受け取ることができます。

• 支払いはプレイヤーのウォレットからパブリッシャーの受取用ウォレットへ直接送金されます。銀行など仲介が介在しないことから、支払いの保留や取り消しのリスクがありません。

• eスポーツのプレイヤーは生体認証（Face ID / Touch ID / パスキー）を含むパスキーを使用して決済取引を承認します。

• Unreal EngineおよびUnity、Godot用SDKにより、ゲーム開発者はわずか1行のコード（ BlsquiSDK.RequestTransaction() ）で決済フローを実装できます。

よくある質問（FAQ）

Q. Blsqui はどのようにして「手数料ゼロの決済画面」を実現しているのですか？

A. Blsqui は、従来のクレジットカードネットワークや中間決済業者を介さない中間マージンが不要となるようなアーキテクチャを採用しています。

Q. Blsqui Payment SDK が対応しているゲームエンジンは何ですか？

A. Unreal Engine、Unity、Godot Engine 向けの軽量なパブリック SDK に加え、ネイティブ Web アプリケーション向けの Web API を提供しています。

Q. サポートされているステーブルコインは何ですか？

A. 現在 Blsqui は、ポイントベースの一般的なステーブルコインとブロックチェーンのネイティブ通貨であるFLOWに対応しています。また近いうちに、USDC や PYUSD などの主要な米ドル連動型トークンにも対応予定です。

Q. ワンクリックでの安全なスマートコントラクトデプロイはどうして可能ですか？

A. Blsquiは、誰でもスマートコントラクトを即座にデプロイできる多層鍵管理セキュリティ搭載ウォレットシステムを構築しており、コントラクト追加処理である signerAccount.contracts.add(...) を組み込んだ専用のUI画面がFLIXを介して提供されるため、高度なブロックチェーン知識や手動の環境設定を行うことなく、安全なワンクリックデプロイを実現しています。

Get Started Today

以下は Unreal Engine 5 の格闘ゲームにポイントステーブルコインおよび仮想通貨決済の機能を実装した様子です。(Chrome Extension やシードフレーズ等は一切不用。) 

Blsqui eスポーツウォレット は即座にスマートコントラクトをデプロイできることからゲーム開発者は様々な賞金、景品、アイテム配布ロジックをシームレスにゲームに組み込むことができます。ソースコードをFLIXレジストリで管理しておき、 FLIX IDをBlsqui SDKに渡すだけでキャプションやアイコンなどバラエティに富んだ署名画面のeSportsブロックチェーンゲームを自社のリソースを消費することなく開発することができます。

https://www.youtube.com/watch?v=dzjDuH_fbTY

TEM Technologies Co. LLC / Blsqui Wallet Division

URL: https://blsqui.net/contact

Major Features

By integrating the Blsqui SDK, game developers can effortlessly incorporate Point-to-Point stablecoins, custom-branded tokens, and cryptocurrencies into their in-game payment systems. Furthermore, it comes standard with a robust blockchain infrastructure that enables secure, one-click deployment of smart contracts, including stablecoins.

Utilize your own point-based stablecoins as in-game currency

Benefits of Our State-of-the-Art Infrastructure

1. All developers and users can utilize the checkout screen functionality with absolutely zero transaction fees.

2. Delivers gasless stablecoin payments with multi-engine support for Unreal Engine, Unity, and Godot.

3. Powered by MPC-CMP (Multi-Party Computation) threshold signature technology, providing robust, multi-layered key management security without compromising processing speed.

4. Includes a pre-configured native wallet layer out of the box. This reduces the payment integration timeline from several weeks to just 1–2 hours.

5. Features a smart contract code registry system (the FLIX system) that empowers users to transact with confidence. This enables multi-lingual payment descriptions to be displayed directly on the checkout screen.

Complete Abstraction of Blockchain API Data

The Blsqui SDK is designed so that external data retrieval completely isolates the game client from any blockchain API changes. Even if an API version update alters the response format, game developers will never be forced to update the in-game SDK.

State-of-the-art CDN Functions deploy abstraction logic simultaneously across 300 cities worldwide, delivering only optimized responses to the in-game SDK (see below). Consequently, this minimizes the memory footprint required for JSON parsing on the game engine side.

{
  "status": "SEALED",
  "txId": "fb1272c57c...",
  "nonce": "fb1272c57c...",
  "errorMessage": null,
  "payer": "fb1272c57c...",
  "amount": "10.00",
  "currency": "USDC",
  "timestamp": 1722052603
}

Our Vision

For over a decade, game developers have been forced to surrender 30% of their gross revenue to traditional platform operators, in addition to paying 2–3% in credit card transaction fees.

To dismantle these barriers, Blsqui has adopted a "Point-to-Point" checkout flow (a system that processes common reward points as blockchain-based stablecoins). Furthermore, inspired by RFC 8252, the Blsqui SDK utilizes local HTTP loopbacks to smoothly display the checkout screen during gameplay. It securely passes the transaction ID (txId) to payment reference numbers generated directly within native game engines like Unreal Engine, Unity, and Godot.

Key Benefits of the Blsqui SDK for Game Publishers:

• Publishers retain 100% of their revenue.

• Payments are routed directly from the player's wallet to the publisher's receiving wallet. With no banks or intermediaries involved, there are zero risks of payment holds or chargebacks.

• eSports players authorize payment transactions using Passkeys, including biometric authentication (Face ID / Touch ID).

• With the SDKs for Unreal Engine, Unity, and Godot, game developers can implement the entire payment flow with just a single line of code (BlsquiSDK.RequestTransaction()).

Frequently Asked Questions (FAQ)

Q. How does Blsqui achieve a "zero-fee checkout screen"?

A. Blsqui utilizes an architecture that bypasses traditional credit card networks and payment intermediaries, eliminating the need for intermediary margins and fees.

Q. Which game engines does the Blsqui Payment SDK support?

A. We provide lightweight public SDKs for Unreal Engine, Unity, and Godot Engine, alongside a Web API for native web applications.

Q. Which stablecoins are supported?

A. Currently, Blsqui supports popular point-based stablecoins and FLOW, a native blockchain currency. In the near future, we will also support major USD-pegged tokens such as USDC and PYUSD.

Q. How is secure, one-click smart contract deployment possible?

A. Blsqui features a wallet system equipped with multi-layered key management security that allows anyone to deploy smart contracts instantly out-of-the-box. Because a dedicated UI screen executing the contract addition logic signerAccount.contracts.add(...) is provided via the FLIX system, it enables secure, one-click deployments without requiring advanced blockchain knowledge or manual environment configurations.

Get Started Today

Below is a demonstration of point-based stablecoin and cryptocurrency payments implemented in an Unreal Engine fighting game. (No Chrome Extensions or seed phrases required.)

Because the Blsqui eSports Wallet can instantly deploy smart contracts, game developers can seamlessly integrate diverse prize pools, rewards, and item distribution logic directly into their games. By managing the source code in the FLIX registry and simply passing the FLIX ID to the Blsqui SDK, developers can create rich Blockchain eSports experiences—complete with customized captions and icons on authorization screen—without consuming their own server resources.

https://www.youtube.com/watch?v=dzjDuH_fbTY

TEM Technologies Co. LLC / Blsqui Wallet Division

URL: https://blsqui.net/contact

答えは至極シンプルです。熱狂的なeスポーツを、今すぐこの手で実現したいからです。これ以上に理由はありません。

eスポーツ業界において、ポイント to ポイント（Point-to-Point） はキラーワードだと言えます。

この構造を組み込むだけで、法的なハードルを下げながら、グローバルかつリアルタイムな決済、または報酬配布を行えるインフラストラクチャーを備えたゲーム大会が成立します。

「ポイント to ポイント」のスマートコントラクト実装は、実は非常にシンプルです。 私は過去に、大手企業向けに金（Gold）価格に連動するステーブルコインの仕組みを実装から納品まで請け負ったことがあります。外部のAPIから金価格を取得し、オラクルを経由してリアルタイムにスマートコントラクトへ反映させる設計でした。

「ポイント to ポイント」は実はとても簡単です。

• 1対1の固定レートのため、金価格のような変動オラクルによる調整がありません。

• 日本円との直接交換を回避し、法定通貨への直接換金を挟まず、ポイント同士の等価交換に特化することで短期間でのリリースを実現できます。 仕様さえ決まれば1日でも実装可能であり、これによってeスポーツの実現速度は飛躍的に加速することでしょう。

2. 日本国内におけるポイント×ステーブルコインのトレンド

現在、日本のポイント経済圏とステーブルコインの融合は、歴史的な転換期を迎えています。

2026年6月、JPYC社はHashPortおよび三井住友トラストクラブと提携し、クレジットカード（Diners Club）の特典ポイントを直接JPYCへ交換できる日本初のサービスを発表しました。

この動きが意味することは明白です。

ポイントをステーブルコイン化し、エコシステム内で循環させるという思想において、私たちBlsquiの目線は、すでにメガキャリアや大手金融機関と完全に同じ高さにあるということです。(注: 株式会社HashPortは au Financial 、Coincheckと合弁会社を設立(名称: au Coincheck Digital Assets)しており、au Pontaポイントをすでにステーブルコインとしてリリースしています)

共通のゴール

彼ら大手事業者がポータルサイトや巨大アライアンスを通じた日本市場の変革を目指す一方で、私たちBlsquiもブロックチェーンゲーム／eスポーツという現場から日本を進化させたいという、アプローチの出発点こそ異なりますが到達すべき共通のゴールを持っています。

3. Blsquiの強み

私たちBlsquiチームは、暫定企業価値5億円規模の精鋭スタートアップです。だからこそ大手には真似できない決定的なアドバンテージを有しています。

① エンジニア主導

Blsquiの代表自身がプロダクトのコードを書き、アーキテクチャを設計する技術者集団ですので、ユーザーやゲーム事業者が目にするUI/UX、SDKの挙動を、現場のニーズに合わせて即日かつ自由にアップデートできる機動力があります。

② 次世代ブロックチェーン「Flow」とGoogle Cloud基盤

先行する競合他社が1世代前のブロックチェーンのインフラを活用しているのに対し、Blsquiは創業時よりGoogle Cloudがバックアップする「Flowブロックチェーン」を採用しています。

• GCPインフラのおかげで超低遅延かつ高スループットであり、5G時代の高速ネットワークに最適化できます。

• PayPalやCircle（USDC）などのグローバルスタンダード の巨人がエコシステムに参画する信頼性の高いブロックチェーンです。

4. Blsqui SDKの主な機能

独自のステーブルコインやポイントトークンをゲーム内通貨として利用可能です。

ゲーム開発者は、Blsqui SDKを使用することで、カスタマイズされたPoint-to-Point ステーブルコインや独自ブランドのエコシステム・トークン、仮想通貨をゲーム内決済に統合できます。ステーブルコインなどのスマートコントラクトはワンクリックで安全にデプロイできるブロックチェーンインフラも備えています。

弊社の最先端インフラを使用したサービスを利用するメリット

1. すべての開発者とユーザーが、決済手数料無料で決済画面の機能を利用できます。

2. Unreal EngineやUnity、Godotなどの高性能ゲームエンジンに対応した、ガス代不要（Gasless）のステーブルコイン決済機能を提供しています。

3. **MPC-CMP（マルチパーティ計算）**による閾値署名技術を備えており、トランザクション速度を損なうことなく、多層的な鍵管理セキュリティを実現できます。

4. ブロックチェーンロジックの複雑さを「FLIX ID」として抽象化し、設定不要なネイティブウォレット層を同時に提供しているため、Blsqui SDKは、従来なら数週間を要した決済機能の導入作業を、わずか1〜2時間のセットアップ期間へと短縮できます。

弊社の決済インフラはエンタープライズグレードのネットワークを使用しており、最先端のインフラ環境となっています

1. DNSから弊社サーバーのIPアドレス追跡を隠蔽するIP Maskingを実施しています。

2. トランザクション履歴の追跡にCDN Functions を利用し、低遅延を実現、また、ブロックチェーンAPI情報の完全抽象化を実現しています。

3. AI活用のAnti-DDoS機能により分散型大規模DoS攻撃に対応しています。

4. Threat Filteringにより、APIに対するあらゆる怪しい攻撃を遮断しています。

ブロックチェーンAPI情報の完全抽象化を実現

Blsqui SDK が外部から取得する情報はブロックチェーンAPIによる影響がゲーム内に及ばない設計になっています。APIのバージョンアップ等でレスポンス形式が変わったとしてもゲーム内SDKがアップデートを強いられることは、決してありません。 世界300都市で最新のCDN Functionによる抽象化ロジックが同時にデプロイされ、ゲーム内SDKは抽象化データのみが提供されます (下図)。また、JSONの解析に必要となるメモリ消費もこれにより最低限に抑えることができます。

{
  "status": "SEALED",
  "txId": "fb1272c57c...",
  "nonce": "fb1272c57c...",
  "errorMessage": null,
  "payer": "fb1272c57c...",
  "amount": "10.00",
  "currency": "USDC",
  "timestamp": 1722052603
}

【本件に関するお問い合わせ・アライアンスのご相談】

TEM Technologies Co. LLC / Blsqui Wallet Division

URL: https://blsqui.net/contact

The current clunky state of AI payment setups versus the seamless UX reviving with the Blsqui architecture.

Why your AI Assistant is Giving You Terrifying Code for Payment Logic

If you have ever asked an AI assistant to generate payment logic for your application, you’ve probably stared at the output in absolute horror.

AI is incredibly superior at optimizing game loops, generating assets, and structuring databases. But the moment you type the word "payment," the AI returns a monstrous wall of terrifying code. You are suddenly looking at dense server configurations, complex webhooks, third-party payment gateway middlewares, state management handlers, and data tracking endpoints just to move a single dollar.

Why does this happen? Because AI only knows the traditional tech stack. It assumes you need to build a heavy, centralized billing fortress.

People use AI every single day because it makes creation frictionless. Yet, the moment monetization enters the equation, the friction returns tenfold. Developers are struggling to cope with payment logic not because they lack skill, but because the traditional architecture is fundamentally broken for modern independent applications.

There has to be a cleaner way to handle settlement without writing code that looks like a cybersecurity nightmare.

japanese-version

AIアシスタントが提示する決済ロジックのコードが「恐ろしく複雑」になってしまう理由

アプリケーションの決済ロジックをAIに生成させたことがある人なら、その出力結果を見て思わずゾッとした経験があるはずです。

AIは、ゲームループの最適化やアセット生成、データベースの構造化においては圧倒的に優秀です。しかし、あなたが「決済」という単語を入力した瞬間、AIは恐ろしく難解で長大なコードの壁を返し始めます。たった1ドルを移動させるためだけに、高密度なサーバー設定、複雑なウェブフック、サードパーティの決済ゲートウェイ、状態管理ハンドラー、データトラッキングのエンドポイントが画面を埋め尽くすのです。

なぜこれが起きるのでしょうか？それは、AIが「従来のレガシーなテックスタック」しか知らないからです。AIは、あなたが巨大で中央集権的な課金要塞をゼロから構築しなければならないと前提しているのです。

人々は開発をスムーズにするために毎日AIを使っています。しかし、マネタイズが絡んだ瞬間に、その摩擦（フリクション）は10倍になって戻ってきます。開発者が決済ロジックに苦労しているのは、技術が足りないからではありません。従来のアーキテクチャ自体が、現代のインディー開発やAIアプリケーションにとって根本的に壊れているからです。

サイバーセキュリティの悪夢のようなコードを書くことなく、よりクリーンに決済を処理する方法が他にあるはずです。

We can solve problems that AI cannot.

Across X, YouTube, and Discord, we are watching a profound cultural shift: parents and children are sitting down together, co-prompting AI agents, and spinning up fully playable 3D games in a single afternoon.

What Normal People and Families Are Actually Trying

Based on data across developer communities, families and "normal" people are building Casual Simulations, Sandbox Upgraders, and Casual Tycoons.

• They are prompting things like: "Make a game where a character cuts down a tree, carries wood to a shop, gets 10 coins, and upgrades their axe."

• The core mechanic is a simple sequence: Perform Task ➔ Gain Resource ➔ Purchase Upgrade.

Technical Bottleneck

These creators want their games to make money so they can show their kids real validation (or, for solo indie creators, pay their bills).

But right now, Google, Claude, and ChatGPT agents fail them at the checkout gate. If you ask an AI agent: "Add a secure checkout system" the AI spits out hundreds of lines of complex Node.js/Go server logic, database configuration schemas, and security headers.

The normal creator looks at that infrastructure mountain and completely gives up.

At Blsqui, our engineering philosophy is built around a single phrase: Democratizing Revenue for Independent Game Creators.

The Blsqui esports wallet enables creators to implement payment verification and blockchain security layers without requiring backend expertise—all through a no-code solution.

Payment implementation, which previously took weeks, has been streamlined to the execution of just a single line of script in Unity or Godot. Once the necessary conditions are met, a sleek wallet interface appears—no Chrome extension required.

Game creators no longer need to write code to handle in-game payments.

Blsqui ensures that everyone can rightfully earn 100% of their revenue, and the entire setup process takes less than a minute.

As shown here, simply running npm create blsqui launches a game screen featuring a sample game and an integrated Blsqui wallet. You simply need to set the wallet address to the one generated via Blsqui. Once you swap in your own game design and run the npm run build command, your wallet setup is complete. Additionally, since the system accepts cryptocurrency exchange addresses, you can immediately convert your earnings into cash.

1. Native Cross-Platform Execution: Whether the game is exported to Windows, iOS, or Android via Unity or Godot, a single script natively calls the device's default web browser.

2. Income from Tomorrow: The creator inputs their wallet address and asset strings. When a player buys the "Golden Axe" in-game, the transaction is cryptographically processed on the ledger, verified by our cloud, and cleared safely.

japanese-version

プロンプトから「収益」へ：AIゲーム開発における最大のボトルネック「決済インフラ」を解消する

私たちは、AIには解決できないことを解決できます。

今、XやYouTube、Discordを見渡すと、テクノロジーの歴史における大きな転換点を目にすることができます。それは、親と子どもが机を並べ、AIエージェントにプロンプトを打ち込みながら、わずか数時間で実際に遊べるゲームを作り上げている光景です。

一般の人々や家族が実際に試みていること

開発者コミュニティのデータを分析すると、家族や「一般の」人々は、カジュアル・シミュレーション、サンドボックス型アップグレード・ゲーム、カジュアルなタイクーン（経営）ゲームを制作しようとしています。

• 彼らは次のようなプロンプトを入力しています。「キャラクターが木を切り倒し、木材を店に運んで10コインを獲得し、斧をアップグレードするゲームを作って」

• その核となるメカニズムは、「タスク実行 ➔ リソース獲得 ➔ アップグレード購入」というシンプルなものです。

技術面でのボトルネック

こうしたクリエイターは、子供たちに「実際に成果が出た」ことを見せるため（あるいは、個人開発者なら生活費を稼ぐため）に、ゲームで収益を上げたいと考えています。

しかし現状では、Google、Claude、ChatGPTといったAIエージェントが、決済（チェックアウト）の実装段階でつまずいてしまいます。AIエージェントに安全な決済システムを追加してと頼むと、AIは数百行にも及ぶ複雑なNode.jsやGoのサーバーロジック、データベース設定スキーマ、セキュリティヘッダーなどを出力してくるのです。

一般のクリエイターは、その膨大なインフラ構築の山を目の当たりにして、完全にやる気を失ってしまいます。

Blsquiが掲げるミッションはただ一つです。 「独立したゲームクリエイターの収益を、完全に民主化する（Democratizing Revenue for Independent Game Creators）」

Blsqui eスポーツウォレットはクリエイターにバックエンドの知識を強いず、決済の検証とブロックチェーンのセキュリティ層を、ノーコードで提供することことができます。

これまで数週間かかっていた決済の実装は、UnityやGodotにおける「わずか1行のスクリプト実行」へと簡潔化されました。そしてその条件が満たされた時、Chromeエクステンションを必要としない、美しいウォレット画面を表示します。

もうゲームクリエイターはゲームの決済にコードを書く必要はなくなりました。

Blsqui は誰もが正当に１００％の収益を得られることができ、その手順は１分もあれば終わります。

ここにあるように

npm create blsqui

を実行するだけでサンプルゲームとBlsquiウォレットが実装されたゲーム画面が立ち上がります。あなたはそのウォレットアドレスにBlsquiで作成したアドレスをセットするだけです。ゲームデザインをあなたの作ったものに切り替えて、

npm run build

のコマンドを実行すればもうウォレットの準備は万全です。また、ウオレットアドレスは暗号通貨取引所のアドレスでも機能しますので、即座に売上を換金することができます。

1. ネイティブなクロスプラットフォーム対応: ゲームがWindows、Mac、iOS、Androidのどれに書き出されても、ゲームエンジンから標準ブラウザを安全に呼び出し、シームレスな決済画面を展開します。

2. 明日から始まるゲームビジネス: クリエイターは自分のウォレットアドレスとアイテム名を登録するだけ。プレイヤーがゲーム内で「金の斧」を購入すると、分散型台帳で即座に処理され、検証された売上が翌日からクリエイターの手元に入ります。