This reference documents all the methods available in the SDK, and explains in detail how these methods work. SDKs are open source, and you can use them according to the licence.

• Sign in/up with Wallet provider
• Configure app
• Query cadence script with arguments
• Send transaction with non-custodial mode (Blocto)
• Send transaction with custodial wallet
• Support all access api endpoint such as GetAccount and GetLastestBlock
• Sign user message
• Verify user signature
• Account Proof
• Verify account proof
• Support custom authz func

This is a Swift Package, and can be installed via Xcode with the URL of this repository:

.package(name: "FCL", url: "https://github.com/outblock/fcl-swift.git", from: "0.1.1")

Values only need to be set once. We recommend doing this once and as early in the life cycle as possible. To set a configuration value, the put method on the config instance needs to be called, the put method returns the config instance so they can be chained.

let accountProof = FCL.Metadata.AccountProofConfig(appIdentifier: "xxxx", nonce: "xxxx")
let walletConnect = FCL.Metadata.WalletConnectConfig(urlScheme: "xxxx", projectID: "xxxx")
let metadata = FCL.Metadata(appName: "xxx",
                            appDescription: "xxx",
                            appIcon: URL(string: "xxxx")!,
                            location: URL(string: "xxx")!,
                            accountProof: accountProof,
                            walletConnectConfig: walletConnect)

fcl.config(metadata: metadata,
           env: env,
           provider: provider)

Configuration keys that start with 0x will be used to find-and-replace their values in Cadence scripts and transactions input to FCL. Typically this is used to represent account addresses. Account addresses for the same contract will be different depending on the Flow network you're interacting with (eg. Testnet, Mainnet). This allows you to write your script or transaction once and not have to update code when you point your application at a different Flow network.

fcl.config
    .put(key: "0xFungibleToken", value: "0xf233dcee88fe0abe")
    .put(key: "0xFUSD", value: "0x3c5959b568896393")


fcl.query {
    cadence {
        """
        import FungibleToken from 0xFungibleToken
        import FUSD from 0xFUSD

        access(all) fun main(account: Address): UFix64 {
          let receiverRef = getAccount(account).capabilities.get<&FUSD.Vault>(/public/fusdBalance)
            .borrow()

          return receiverRef!.balance
        }
        """
    }

    arguments {
        [.address(Flow.Address(hex: address))]
    }
}

These methods allows dapps to interact with FCL compatible wallets in order to authenticate the user and authorize transactions on their behalf.

Calling this method will authenticate the current user via any wallet that supports FCL. Once called, FCL will initiate communication with the configured authn endpoint which lets the user select a wallet to authenticate with. Once the wallet provider has authenticated the user, FCL will set the values on the current user object for future use and authorization.

let accountProof = FCL.Metadata.AccountProofConfig(appIdentifier: "xxxx", nonce: "xxxx")
let walletConnect = FCL.Metadata.WalletConnectConfig(urlScheme: "xxxx", projectID: "xxxx")
let metadata = FCL.Metadata(appName: "xxx",
                            appDescription: "xxx",
                            appIcon: URL(string: "xxxx")!,
                            location: URL(string: "xxx")!,
                            accountProof: accountProof,
                            walletConnectConfig: walletConnect)
let provider: FCL.Provider = .flowWallet
fcl.config(metadata: metadata,
           env: env,
           provider: provider)

fcl.authenticate()

A convenience method that produces the needed authorization details for the current user to submit transactions to Flow. It defines a signing function that connects to a user's wallet provider to produce signatures to submit transactions.

Note: The default values for proposer, payer, and authorizations are already fcl.authz so there is no need to include these parameters, it is shown only for example purposes. See more on signing roles.

try await fcl.mutate(cadence: 
                    """
                       transaction(test: String, testInt: Int) {
                           prepare(signer: &Account) {
                                log(signer.address)
                                log(test)
                                log(testInt)
                           }
                       }
                    """,
                    args: [.string("Test2"), .int(1)])

📣 These methods can be used in browsers and NodeJS.

These methods allows dapps to interact directly with the Flow blockchain via a set of functions that currently use the Access Node API.

If you want to run arbitrary Cadence scripts on the blockchain, these methods offer a convenient way to do so without having to build, send, and decode interactions.

Allows you to submit scripts to query the blockchain.

Pass in the following as a single object with the following keys.All keys are optional unless otherwise stated.

fcl.query {
    cadence {
        """
        access(all) fun main(a: Int, b: Int, addr: Address): Int {
            log(addr)
            return a + b
        }
        """
    }

    arguments {
        [.int(7), .int(6), .address(Flow.Address(hex: "0x01"))]
    }
}

Allows you to submit transactions to the blockchain to potentially mutate the state.

⚠️When being used in the browser, fcl.mutate uses the built-in fcl.authz function to produce the authorization (signatures) for the current user. When calling this method from Node.js, you will need to supply your own custom authorization function.

Pass in the following as a single object with the following keys. All keys are optional unless otherwise stated.

try await fcl.mutate(cadence: 
                    """
                       transaction(test: String, testInt: Int) {
                           prepare(signer: &Account) {
                                log(signer.address)
                                log(test)
                                log(testInt)
                           }
                       }
                    """,
                    args: [.string("Test2"), .int(1)])

A builder function that returns the interaction to get the latest block.

📣 Use with fcl.atBlockId() and fcl.atBlockHeight() when building the interaction to get information for older blocks.

⚠️Consider using the pre-built interaction fcl.latestBlock(isSealed) if you do not need to pair with any other builders.

fcl.getLastestBlock()