Class FilsnapAdapter

constructor

• new FilsnapAdapter(options: FilsnapAdapterOptions): FilsnapAdapter

  Parameters

  • options: FilsnapAdapterOptions

  Returns FilsnapAdapter

config

Readonlyprovider

Readonlysnap

calculateGasForMessage

• calculateGasForMessage(
      params: {
          maxFee?: string;
          message: {
              gasFeeCap?: string;
              gasLimit?: number;
              gasPremium?: string;
              method?: number;
              nonce?: number;
              params?: string;
              to: string;
              value: string;
              version?: 0;
          };
      },
  ): Promise<
      | JsonifyObject<{ error: SnapError; result: null }>
      | JsonifyObject<{ error: null; result: MessageGasEstimate }>,
  >

  Estimate the gas for a message

  maxFee is optional and defaults to 100000000000000000 attoFIL (0.1 FIL)

  Parameters

  • params: {
        maxFee?: string;
        message: {
            gasFeeCap?: string;
            gasLimit?: number;
            gasPremium?: string;
            method?: number;
            nonce?: number;
            params?: string;
            to: string;
            value: string;
            version?: 0;
        };
    }

    fil_getGasForMessage RPC method params

  Returns Promise<
      | JsonifyObject<{ error: SnapError; result: null }>
      | JsonifyObject<{ error: null; result: MessageGasEstimate }>,
  >

changeChain

• changeChain(chain: string | number): Promise<ConfigureResponse>

  Change the chain

  Parameters

  • chain: string | number

    Chain to switch to. Can be a chain id (0x13a) or id (314) or network name (mainnet)

  Returns Promise<ConfigureResponse>

  Deprecated

  use changeNetwork instead and use getNetworkFromChainId from 'iso-filecoin/utils'

changeNetwork

• changeNetwork(
      network: Network,
  ): Promise<SnapResponse<{ account: {}; network: Network }>>

  Change the current network and derive a new account for that network

  Parameters

  • network: Network

    Network to switch to (mainnet, testnet, etc)

  Returns Promise<SnapResponse<{ account: {}; network: Network }>>

  Response containing the new network and derived account

  Example

  import { FilsnapAdapter, getProvider } from 'filsnap-adapter'
  
  const adapter = await FilsnapAdapter.connect({
    provider: getProvider(),
    snapId: 'npm:filsnap',
    config: { network: 'testnet' },
  })
  const response = await adapter.changeNetwork('mainnet')
  console.log(response.result.network) // 'mainnet'
  console.log(response.result.account.address) // 'f1...'
  Copy

configure

• configure(
      params?: Partial<
          {
              derivationPath: string;
              network: Network;
              rpc: { token: string; url: string };
              unit?: { decimals: number; symbol: "FIL" | "tFIL" };
          },
      >,
  ): Promise<ConfigureResponse>

  Configure the snap

  Parameters

  • params: Partial<
        {
            derivationPath: string;
            network: Network;
            rpc: { token: string; url: string };
            unit?: { decimals: number; symbol: "FIL" | "tFIL" };
        },
    > = {}

    FilSnapMethods.fil_configure params

  Returns Promise<ConfigureResponse>

deriveAccount

• deriveAccount(index: number): Promise<SnapResponse<{}>>

  Derive new account using provided index

  Parameters

  • index: number

  Returns Promise<SnapResponse<{}>>

disconnect

• disconnect(): Promise<void>

  Disconnect provider

  Returns Promise<void>

  Example

  import { FilsnapAdapter } from 'filsnap-adapter'
  
  const adapter = await FilsnapAdapter.connect({
    provider: window.ethereum,
    snapId: 'npm:filsnap',
  })
  await adapter.disconnect()
  Copy

exportPrivateKey

• exportPrivateKey(): Promise<ExportPrivateKeyResponse>

  Export the account private key from the snap

  Returns Promise<ExportPrivateKeyResponse>

  See

  FilSnapMethods.fil_exportPrivateKey

getAccount

• getAccount(): Promise<SnapResponse<{}>>

  Get current account data

  Returns Promise<SnapResponse<{}>>

getAccountInfo

• getAccountInfo(): Promise<
      | JsonifyObject<{ error: SnapError; result: null }>
      | JsonifyObject<{ error: null; result: AccountInfo }>,
  >

  Request account info with balance from the snap

  Returns Promise<
      | JsonifyObject<{ error: SnapError; result: null }>
      | JsonifyObject<{ error: null; result: AccountInfo }>,
  >

  Deprecated

  use getAccount instead

  See

  FilSnapMethods.fil_getAccountInfo

getAddress

• getAddress(): Promise<GetAddressResponse>

  Request account address from the snap

  Returns Promise<GetAddressResponse>

  Deprecated

  use getAccount instead

  See

  FilSnapMethods.fil_getAddress

getBalance

• getBalance(): Promise<GetBalanceResponse>

  Request account balance from the snap

  Returns Promise<GetBalanceResponse>

  See

  FilSnapMethods.fil_getBalance

getPublicKey

• getPublicKey(): Promise<GetPublicResponse>

  Request account public key from the snap

  Returns Promise<GetPublicResponse>

  Hex encoded public key

  Deprecated

  use getAccount instead

  See

  FilSnapMethods.fil_getPublicKey

  Example

  const rsp = await adapter.getPublicKey()
  if (rsp.error) {
     throw new Error(rsp.error.message, {cause: rsp.error.data})
  }
  const publicKey = hex.decode(rsp.result)
  Copy

rpc

• rpc(): RPC

  Get the RPC instance configured by Filsnap

  Returns RPC

  RPC instance

sendMessage

• sendMessage(
      params: {
          message: {
              from: string;
              gasFeeCap: string;
              gasLimit: number;
              gasPremium: string;
              method: number;
              nonce: number;
              params: string;
              to: string;
              value: string;
              version: 0;
          };
          signature: { data: string; type: "SECP256K1" };
      },
  ): Promise<SendMessageResponse>

  Send a signed message

  Parameters

  • params: {
        message: {
            from: string;
            gasFeeCap: string;
            gasLimit: number;
            gasPremium: string;
            method: number;
            nonce: number;
            params: string;
            to: string;
            value: string;
            version: 0;
        };
        signature: { data: string; type: "SECP256K1" };
    }

    FilSnapMethods.fil_sendMessage params

  Returns Promise<SendMessageResponse>

sign

• sign(data: Uint8Array): Promise<SnapResponse<Signature>>

  Sign arbitrary bytes

  Parameters

  • data: Uint8Array

    Data to sign

  Returns Promise<SnapResponse<Signature>>

signMessage

• signMessage(
      params: {
          gasFeeCap?: string;
          gasLimit?: number;
          gasPremium?: string;
          method?: number;
          nonce?: number;
          params?: string;
          to: string;
          value: string;
          version?: 0;
      },
  ): Promise<SignMessageResponse>

  Sign a Filecoin message

  Parameters

  • params: {
        gasFeeCap?: string;
        gasLimit?: number;
        gasPremium?: string;
        method?: number;
        nonce?: number;
        params?: string;
        to: string;
        value: string;
        version?: 0;
    }

    FilSnapMethods.fil_signMessage params

  Returns Promise<SignMessageResponse>

signMessageRaw

• signMessageRaw(params: { message: string }): Promise<SignMessageRawResponse>

  Sign a raw message

  Parameters

  • params: { message: string }

    FilSnapMethods.fil_signMessageRaw params

  Returns Promise<SignMessageRawResponse>

Staticconnect

• connect(options: ConnectOptions): Promise<FilsnapAdapter>

  Installs and connects to Filsnap

  Parameters

  • options: ConnectOptions

    Connect options

  Returns Promise<FilsnapAdapter>

  Throws

  Error if Metamask is not installed

Staticreconnect

• reconnect(
      options: Omit<ConnectOptions, "config">,
  ): Promise<undefined | { account: AccountInfo; adapter: FilsnapAdapter }>

  Reconnects to an existing Filsnap installation

  Parameters

  • options: Omit<ConnectOptions, "config">

    Connect options without config

  Returns Promise<undefined | { account: AccountInfo; adapter: FilsnapAdapter }>

  Adapter instance and account info if snap is installed, undefined otherwise

  Example

  import { FilsnapAdapter } from 'filsnap-adapter'
  
  const connection = await FilsnapAdapter.reconnect({
    provider: window.ethereum,
    snapId: 'npm:filsnap'
  })
  
  if (connection) {
    const { adapter, account } = connection
    console.log('Reconnected to account:', account.address)
  }
  Copy