Fireblocks Embedded Wallet (EW)

https://ncw-developers.fireblocks.com/docs
Admin
The Fireblocks Embedded Wallet (EW) is a solution for securely managing digital assets, granting end...
Tokens:15,460
Snippets:83
Trust Score:9.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Webhook Notification for Device Setup Request

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

Example JSON structure of a webhook notification (`NCW_ADD_DEVICE_SETUP_REQUESTED`) that can be yielded after calling `requestJoinExistingWallet`. It provides details like `walletId`, `deviceId`, and `requestId`.

```JSON
{
	 type: "NCW_ADD_DEVICE_SETUP_REQUESTED",
	 tenantId: string,
	 timestamp: number,
	 data: {
	     walletId: string,
	     deviceId: string,
	     requestId: string
	 }
}
```

--------------------------------

### Retrieve Wallet Key Setup State via API

Source: https://ncw-developers.fireblocks.com/docs/multiple-algorithms

This API endpoint provides an overview of a wallet's key setup status by aggregating the status of all associated devices. A wallet is considered 'COMPLETE' if at least one of its devices has reached a 'COMPLETE' status, indicating readiness for operations.

```APIDOC
Endpoint: GET /reference/getwalletsetupstate
Response:
  Includes the current status of all devices associated with the wallet.
  A wallet is considered COMPLETE as long as at least one of its devices also has the COMPLETE status.
```

--------------------------------

### Retrieve Device Key Setup State via API

Source: https://ncw-developers.fireblocks.com/docs/multiple-algorithms

This API endpoint allows checking the current key generation status for a specific device. It provides details on the setup status (COMPLETE/INCOMPLETE) for each algorithm, the algorithm name itself, and whether the keys have been backed up. This is crucial for monitoring the multi-step MPC key generation process.

```APIDOC
Endpoint: GET /reference/getdevicesetupstate
Response Parameters:
  SetupStatus: string ("COMPLETE" | "INCOMPLETE") - Status per key that started creation on the device.
  Algorithm name: string ("MPC_ECDSA_SECP256K1" | "MPC_EDDSA_ED25519") - The algorithm associated with the key.
  backedUp: boolean - Indicates if the keys were backed up by any of the wallet's devices.
```

--------------------------------

### Install Fireblocks Embedded Wallet SDKs

Source: https://ncw-developers.fireblocks.com/docs/setup-4

Instructions for installing the Fireblocks Embedded Wallet (EW) SDK and EW Core SDK using popular JavaScript package managers, npm and yarn. These SDKs are essential for integrating Fireblocks embedded wallet functionalities into web applications.

```Shell
npm i @fireblocks/ncw-js-sdk
npm i @fireblocks/embedded-wallet-sdk
```

```Shell
yarn add @fireblocks/ncw-js-sdk
yarn add @fireblocks/embedded-wallet-sdk
```

--------------------------------

### Set up a basic Falcon API application for webhooks

Source: https://ncw-developers.fireblocks.com/docs/webhook-configuration

This Python code demonstrates how to initialize a Falcon API application, configure middleware for request body parsing and authentication, and add a route for handling webhook requests. It also includes a basic `wsgiref` server setup for local testing.

```python
app = falcon.API(
    middleware=[
        RequestBodyMiddleware(),
        AuthMiddleware()
    ]
)

app.add_route('/webhook', DummyRequest())

if __name__ == '__main__':
    from wsgiref import simple_server  # NOQA
    httpd = simple_server.make_server('127.0.0.1', 8000, app)
    httpd.serve_forever()
```

--------------------------------

### Import Fireblocks iOS SDK Libraries

Source: https://ncw-developers.fireblocks.com/docs/setup-4

This snippet demonstrates how to import the `EmbeddedWalletSDK` and `FireblocksSDK` into your iOS project's Swift files. These imports are essential to access the functionalities provided by the installed Fireblocks SDK packages.

```Swift
import EmbeddedWalletSDK
import FireblocksSDK
```

--------------------------------

### Initialize Fireblocks Embedded Wallet Core SDK

Source: https://ncw-developers.fireblocks.com/docs/initializing-the-sdk

This snippet demonstrates the initialization of the `EmbeddedWallet` Core SDK. It requires a `deviceId` generated previously, along with handlers for `messagesHandler` and `keyStorage`. An optional `eventsHandler` can also be provided. The example shows how to pass these configuration options to the `initializeCore` method to set up the core functionalities.

```JavaScript
const coreOptions: ICoreOptions = {
  deviceId,
  eventsHandler,
  secureStorageProvider,
  storageProvider,
};

const ewCore =
      getFireblocksNCWInstance(coreOptions.deviceId) ?? (await ew.initializeCore(coreOptions));
```

```Kotlin
val coreOptions = CoreOptions.Builder()
  .setEventHandler(object : FireblocksEventHandler {
    override fun onEvent(event: Event) {
				//handle events or just log them if needed
      }
  }).build()
embeddedWallet.initializeCore(deviceId, keyStorage, coreOptions)
```

```Swift
func initializeCore() throws -> Fireblocks {
  guard !deviceId.isEmpty else {
    throw CustomError.deviceId
  }

  //Initialize the EW SDK
  let ewInstance = try getInstance()

  do {
    return try Fireblocks.getInstance(deviceId: deviceId)
  } catch {
    //keyStorageDelegate is a host app implementation
    self.keyStorageDelegate = KeyStorageProvider(deviceId: deviceId)
    return try ewInstance.initializeCore(deviceId: deviceId, keyStorage: keyStorageDelegate!)
  }
}
```

--------------------------------

### Requesting to Join an Existing Wallet

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

Code examples demonstrating how to call the `requestJoinExistingWallet` function on the requesting device. The function takes a handler to process events such as `requestId` and `onProvisionerFound` during the wallet joining procedure.

```JavaScript
await ewCore.requestJoinExistingWallet({
  onRequestId(requestId) {
    // your code here
    set((state) => ({ ...state, addDeviceRequestId: requestId }));
  },
  onProvisionerFound() { // -> optional
    // your code here
  },
});
```

```Kotlin
val joinWalletHandler: FireblocksJoinWalletHandler = object : FireblocksJoinWalletHandler {
    override fun onRequestId(requestId: String) {
        // use this requestId to approve the request from the source device, e.g. using a QR code or a push notification
        // the requestId will be used in approveJoinWalletRequest method
    }

    override fun onProvisionerFound() {
        // use this indication the provisioner device was found and the join process continues, e.g. show a spinner/progress bar
    }
}

Fireblocks.getInstance(deviceId).requestJoinExistingWallet(joinWalletHandler) { result ->
    Timber.i("joinExistingWallet result: $result")
}
```

```Swift
  //Initialize and create the Core SDK instance
  let instance = try getCore()
//joinWalletHandler: FireblocksJoinWalletHandler
let result = try await instance.requestJoinExistingWallet(joinWalletHandler: joinWalletHandler)
```

--------------------------------

### Validate Fireblocks Webhook Signature

Source: https://ncw-developers.fireblocks.com/docs/webhook-configuration

These code examples demonstrate how to set up a server to receive Fireblocks webhook notifications and validate their signatures. The validation process involves verifying the `Fireblocks-Signature` header against the raw request body using the provided public key. Examples are provided for JavaScript (Node.js with Express) and Python (Falcon framework). Note: These examples are for reference and not production-ready.

```JavaScript
const crypto = require("crypto");
const express = require("express");
const bodyParser = require('body-parser')

const port = 3000;

const publicKey = `-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw+fZuC+0vDYTf8fYnCN6
71iHg98lPHBmafmqZqb+TUexn9sH6qNIBZ5SgYFxFK6dYXIuJ5uoORzihREvZVZP
8DphdeKOMUrMr6b+Cchb2qS8qz8WS7xtyLU9GnBn6M5mWfjkjQr1jbilH15Zvcpz
ECC8aPUAy2EbHpnr10if2IHkIAWLYD+0khpCjpWtsfuX+LxqzlqQVW9xc6z7tshK
eCSEa6Oh8+ia7Zlu0b+2xmy2Arb6xGl+s+Rnof4lsq2tZS6f03huc+XVTmd6H2We
WxFMfGyDCX2akEg2aAvx7231/6S0vBFGiX0C+3GbXlieHDplLGoODHUt5hxbPJnK
IwIDAQAB
-----END PUBLIC KEY-----`.replace(/\\n/g, "\n");

const app = express();

app.use(bodyParser.json());

app.post("/webhook", (req, res) => {
    const message = JSON.stringify(req.body);
    const signature = req.headers["fireblocks-signature"];

    const verifier = crypto.createVerify('RSA-SHA512');
    verifier.write(message);
    verifier.end();

    const isVerified = verifier.verify(publicKey, signature, "base64");
    console.log("Verified:", isVerified);

    res.send("ok");
});

app.listen(port, () => {
    console.log(`Webhook running at http://localhost:${port}`);
});

```

```Python
import falcon
import json
import rsa
import base64

FIREBLOCKS_PUBLIC_KEY = """
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw+fZuC+0vDYTf8fYnCN6
71iHg98lPHBmafmqZqb+TUexn9sH6qNIBZ5SgYFxFK6dYXIuJ5uoORzihREvZVZP
8DphdeKOMUrMr6b+Cchb2qS8qz8WS7xtyLU9GnBn6M5mWfjkjQr1jbilH15Zvcpz
ECC8aPUAy2EbHpnr10if2IHkIAWLYD+0khpCjpWtsfuX+LxqzlqQVW9xc6z7tshK
eCSEa6Oh8+ia7Zlu0b+2xmy2Arb6xGl+s+Rnof4lsq2tZS6f03huc+XVTmd6H2We
WxFMfGyDCX2akEg2aAvx7231/6S0vBFGiX0C+3GbXlieHDplLGoODHUt5hxbPJnK
IwIDAQAB
-----END PUBLIC KEY-----
"""

signature_pub_key = rsa.PublicKey.load_pkcs1_openssl_pem(FIREBLOCKS_PUBLIC_KEY)

class RequestBodyMiddleware(object):
    def process_request(self, req, resp):
        req.body = req.bounded_stream.read()

class AuthMiddleware(object):
    def process_request(self, req, resp):
        signature = req.get_header('Fireblocks-Signature')

        if signature is None:
            raise falcon.HTTPUnauthorized('Signature required')

        if not self._signature_is_valid(req.body, signature):
            raise falcon.HTTPUnauthorized('Invalid signature')

    def _signature_is_valid(self,  body, signature):
        try:
            hashing_alg = rsa.verify(body, base64.b64decode(signature), signature_pub_key)
            return hashing_alg == "SHA-512"
        except rsa.pkcs1.VerificationError:
            return False

class DummyRequest(object):
    def on_post(self, req, resp):
        obj = json.loads(req.body.decode("utf-8"))
        print(obj)
        resp.status = falcon.HTTP_201

```

--------------------------------

### EW SDK: Get User Key Status

Source: https://ncw-developers.fireblocks.com/docs/handling-returning-end-users

Describes the `getKeysStatus` function within the EW SDK, its return value, and the meaning of different key statuses. It also explains the implications of an empty `keyDescriptor`.

```APIDOC
EW SDK Function:
  getKeysStatus(): keyDescriptor
    Description: Retrieves the status of all ECDSA and EdDSA keys associated with the user.
    Returns:
      keyDescriptor: An object containing the status of user keys.
        Possible Status Values:
          READY: User completed onboarding, MPC key shares generated, device ready for MPC actions.
          INITIATED, REQUESTED_SETUP, SETUP, SETUP_COMPLETE: User has not completed MPC key share generation; `generateMPCKeys` function should be called.
        Empty keyDescriptor:
          Meaning: User's mobile device lacks a key share and was never in the process of creating one for the specified `deviceId`.
          Action: Current device may need to go into recovery mode or join an existing wallet.
```

--------------------------------

### Configure Fireblocks NCW SDK Reporting Options

Source: https://ncw-developers.fireblocks.com/docs/ncw-sdk-telemetry-collection

These snippets demonstrate how to initialize the Fireblocks NCW SDK across different platforms (Web, iOS, Android) and configure the `reporting` option to control telemetry data sharing. They also show platform-specific setup for logging and event handling.

```JavaScript
// First you need to initialize the NCW SDK with an implementation of the looger
const logger: IndexedDBLogger = await IndexedDBLoggerFactory({ deviceId, logger: ConsoleLoggerFactory() });

const fireblocksNCW = await FireblocksNCWFactory({
          env: ENV_CONFIG.NCW_SDK_ENV,
          logLevel: "INFO",
          deviceId,
          messagesHandler,
          eventsHandler,
          secureStorageProvider,
          logger,
		      reporting = { enabled: true },
        });

// Number of logs collected
const numberOfLogs = await logger.count();

// Collect 10 logs
const logs = await logger.collect(10);

// Clears the oldest 10 logs
await logger.clear(10);

```

```Swift
var fireblocksOptions = FireblocksOptions(
  env: EnvironmentConstants.env,
  eventHandlerDelegate: self,
  logLevel: .info,
  logToConsole: true,
  reporting: ReportingOptions(enabled: true)
)

```

```Kotlin
val fireblocksOptions = FireblocksOptions.Builder()
  .setLogLevel(getNCWLogLevel())
  .setLogToConsole(true)
  .setReportingOptions(ReportingOptions(enabled = false))
  .setEventHandler(object : FireblocksEventHandler {
                   override fun onEvent(event: Event) {
  // handle events
}
})
  .setEnv(environment)
    .build()

```

--------------------------------

### Examples of Shared Telemetry Data Payloads

Source: https://ncw-developers.fireblocks.com/docs/ncw-sdk-telemetry-collection

These snippets provide examples of the non-PII metadata collected from iOS and Android devices when telemetry reporting is enabled. The data includes device-specific information, environment details, and status flags, demonstrating the types of information shared.

```Key-Value
completedMPC:true
device:iPhone14,3
deviceId:b0550946-3d70-4e6b-949d-247549bd775f
environment:dev9
hasCMPKey:true
iosVersion:16.4
onboardedRecovery:false
timezone:GMT+3
uptime:timeval(tv_sec: 1716876653, tv_usec: 488161)

```

```Key-Value
VersionIncremental=S.17acc52_1-1,
completedMPC=false,
Uptime= 18h29m3.942s,
keyStatus=ERROR,
Device=OnePlus/OP516FL1/NE2213/NE2213,
SdkVersion=2.5.0_1,
keyId=0743117c-f737-4f38-b5bc-2c5a0cb17209,
AndroidVersion=34,
deviceId=3ac62b9b-5bb6-4756-96ef-85015ee5f345,
hasCMPKey=Yes,
environment=dev9,
TimeZone=GMT+03:00,
onboardedRecovery=null,
OSVersion=5.10.198-android12-9-o-g4b6fa3fb4a9f,
VersionRelease=14,
algorithm=MPC_EDDSA_ED25519

```

--------------------------------

### Initialize and Manage Logs with Fireblocks NCW SDK (JavaScript/TypeScript)

Source: https://ncw-developers.fireblocks.com/docs/ncw-sdk-logs-retrieval

This snippet demonstrates how to initialize the Fireblocks NCW SDK, configure logging using `IndexedDBLogger`, and perform log management operations like counting, collecting, and clearing logs. It highlights the setup for secure storage and event handling required for the SDK.

```JavaScript
// First you need to initialize the NCW SDK with an implementation of the looger
const logger: IndexedDBLogger = await IndexedDBLoggerFactory({ deviceId, logger: ConsoleLoggerFactory() });

const fireblocksNCW = await FireblocksNCWFactory({
          env: ENV_CONFIG.NCW_SDK_ENV,
          logLevel: "INFO",
          deviceId,
          messagesHandler,
          eventsHandler,
          secureStorageProvider,
          logger,
        });

// Number of logs collected
const numberOfLogs = await logger.count();

// Collect 10 logs
const logs = await logger.collect(10);

// Clears the oldest 10 logs
await logger.clear(10);

```

--------------------------------

### Configure Fireblocks Maven Repository for Android

Source: https://ncw-developers.fireblocks.com/docs/setup-4

This snippet adds the Fireblocks Android SDK Maven repository to your project's `settings.gradle` file, enabling dependency resolution. It includes credentials for authentication required to access the repository.

```Gradle
repositories {
       maven {
            url "https://maven.fireblocks.io/android-sdk/maven"
            name = "android-sdk"
            credentials(HttpHeaderCredentials) {
                name = "Deploy-Token"
                value = "-fU8ijmuPohHaqDBgpaT"
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
```

--------------------------------

### Add Fireblocks Android SDK Dependencies

Source: https://ncw-developers.fireblocks.com/docs/setup-4

This snippet adds the necessary Fireblocks SDK dependencies (BOM, EW, NCW) to your application's `build.gradle` file. It's crucial to use the most updated BOM version for proper dependency management and compatibility.

```Gradle
implementation "com.fireblocks.sdk:bom:1.0.0"
implementation "com.fireblocks.sdk:ew"
implementation "com.fireblocks.sdk:ncw"
```

--------------------------------

### Approving a New Device to Join Wallet

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

Code examples demonstrating how to call the `approveJoinWalletRequest` function on the approving device. This function takes the `requestId` to finalize the process of adding a new device to the wallet.

```JavaScript
const result = await ewCore.approveJoinWalletRequest(requestId);
console.log("approveJoinWallet result:", result);
```

```Kotlin
Fireblocks.getInstance(deviceId).approveJoinWalletRequest(requestId) { result ->
    Timber.i("approveJoinWallet result: $result")
}
```

```Swift
//Initialize and create the Core SDK instance
let instance = try getCore()
return try await instance.approveJoinWalletRequest(requestId: requestId)
```

--------------------------------

### Web Key Storage Provider Interfaces for Fireblocks SDK

Source: https://ncw-developers.fireblocks.com/docs/key-handler

Defines the TypeScript interfaces IStorageProvider and ISecureStorageProvider that must be implemented by custom key storage solutions for the Fireblocks Web SDK. These interfaces specify methods for getting, setting, and managing access to secure key material, supporting the SDK's lock/unlock mechanism.

```TypeScript
export interface IStorageProvider {
  get(key: string): Promise<string | null>;
  set(key: string, data: string): Promise<void>;
}

export interface ISecureStorageProvider extends IStorageProvider {
  getAccess(): Promise<void>;
}
```

--------------------------------

### Fireblocks SDK Common Error Codes

Source: https://ncw-developers.fireblocks.com/docs/android-sdk-errors

This section outlines common error codes encountered when interacting with the Fireblocks SDK, covering issues related to key management, device setup, and wallet operations. Each entry includes the error code, a brief title, and a detailed explanation.

```APIDOC
Error Codes:
  701: Missing key IDs in server for backup
    Description: The client failed to fetch the key's metadata from the backend.
  702: We have a discrepancy between valid key IDs between server and client
    Description: A discrepancy exists between the `keyId` parameters stored on the client and the backend.
  703: Failed to backup keys, missing keys
    Description: The client failed to fetch the key's metadata from the backend.
  704: Failed to backup key
    Description: The key backup process with the backend failed.
  705: Invalid passphrase error
    Description: The used passphrase is invalid.
  800: Invalid add device setup data
    Description: The request to add a device failed due to invalid data.
  900: Failed to join wallet
    Description: The request to join an existing wallet failed.
  901: Timeout during join wallet
    Description: The request to join an existing wallet timed out.
  902: Join wallet was stopped
    Description: The request to join an existing wallet was stopped.
  1000: Failed to approve join wallet
    Description: The request to approve a new device joining an existing wallet failed.
  1001: Timeout during approve join wallet
    Description: The request to approve a new device joining an existing wallet timed out.
  1002: No keys to provision
    Description: Indicates that `com.fireblocks.sdk.Fireblocks.approveJoinWalletRequest` was called with an empty set of algorithms.
  1003: Approve join wallet was stopped
    Description: The request to approve a new device joining an existing wallet was stopped.
```

--------------------------------

### Multi-Device Request ID Webhook

Source: https://ncw-developers.fireblocks.com/docs/webhooks

This webhook is triggered when a multi-device setup request is initiated. The 'data' field contains specific details about the wallet, device, and the unique request ID. The structure of 'data.fieldName' describes a payload with values under a key 'data'.

```APIDOC
type: string - NCW_ADD_DEVICE_SETUP_REQUESTED
tenantId: string - The Fireblocks workspace's unique ID
timestamp: number - Timestamp in milliseconds
data.walletId: string - The wallet's unique ID
data.deviceId: string - The device's unique ID
data.requestId: string - The join wallet request's unique ID; is delegated to the approving device
```

--------------------------------

### Re-generate MPC EdDSA Keys with Fireblocks SDK

Source: https://ncw-developers.fireblocks.com/docs/multiple-algorithms

This snippet demonstrates how to re-generate an EdDSA key set using the Fireblocks SDK's `generateMPCKeys` method. It covers implementations for Web (JavaScript), Android (Kotlin), and iOS (Swift), assuming the wallet is operational and the EdDSA keys were lost. The example specifically targets the `MPC_CMP_EDDSA_ED25519` algorithm.

```JavaScript
import { IKeyDescriptor } from "@fireblocks/ncw-js-sdk";

// Generate MPC Keys
const algorithms = new Set(["MPC_CMP_EDDSA_ED25519"]);
const keyDescriptor: Set<IKeyDescriptor> = await ewCore.generateMPCKeys(algorithms);
```

```Kotlin
val algorithms = setOf(Algorithm.MPC_EDDSA_ED25519)
fireblocksSdk.generateMPCKeys(algorithms = algorithms){ result ->
    Timber.i("generateMPCKeys result: $result")
}
```

```Swift
func generateKeys(algorithms: Set<Algorithm>) async throws -> Set<KeyDescriptor> {
  //Initialize and create the Core SDK instance
  let instance = try getCore()
  return try await instance.generateMPCKeys(algorithms: algorithms)
}
```

--------------------------------

### Supported Identity Providers and JWKS URIs for Fireblocks OAuth

Source: https://ncw-developers.fireblocks.com/docs/setting-up-oauth-sso

This section lists the OAuth-compatible Identity Providers (IDPs) supported by Fireblocks Embedded Wallets, along with their respective JSON Web Key Set (JWKS) URIs. These URIs are crucial for Fireblocks to retrieve public keys for token validation during the OAuth setup.

```APIDOC
Identity Providers and JWKS URIs:
- Google: https://www.googleapis.com/oauth2/v3/certs
- Firebase: https://www.googleapis.com/service_accounts/v1/jwk/[[email protected]](/cdn-cgi/l/email-protection)
- Microsoft Azure AD: https://login.microsoftonline.com/common/discovery/v2.0/keys
- AWS Cognito: https://cognito-idp.{REGION}.amazonaws.com/{USER_POOL_ID}/.well-known/jwks.json
- Salesforce: https://login.salesforce.com/id/keys
```

--------------------------------

### Android/Kotlin: Custom FireblocksMessageHandler Implementation

Source: https://ncw-developers.fireblocks.com/docs/outgoingincoming-message-handling

This Kotlin example provides a custom implementation of FireblocksMessageHandler for Android. It shows how to override handleOutgoingMessage to send the payload to the Fireblocks backend via a REST API call within a coroutine. The implementation includes handling successful responses with responseCallback and errors with errorCallback.

```Kotlin
val fireblocksMessageHandler = FireblocksMessageHandlerImpl()

// An implementation example for the FireblocksMessageHandler.
// Override the handleOutgoingMessage method and call pass the payload to Fireblocks BE using your BE implementation.
// Make sure you to invoke the responseCallback with the response body or the errorCallback in case of an error
class FireblocksMessageHandlerImpl(
private val context: Context,
private val deviceId: String)
: FireblocksMessageHandler, CoroutineScope {
    private val job = Job()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.IO + job

    override fun handleOutgoingMessage(
payload:String,
responseCallback: (responseBody: String?) -> Unit,
      errorCallback: (errorMessage: String?) -> Unit) {
        runBlocking {
            withContext(Dispatchers.IO) {
                // do rest API call
                Timber.i("calling invoke rest API")
                runCatching {
                    val response = Api.with(StorageManager.get(context, deviceId)).invoke(deviceId, MessageBody(payload)).execute()
                    Timber.i("got response from invoke rest API, code:${response.code()}, isSuccessful:${response.isSuccessful}")
                    responseCallback(response.body())
                }.onFailure {
                    Timber.e(it, "Failed to call invoke Api")
                    errorCallback("Failed to call invoke Api")
                }
            }
        }
    }
}
```

--------------------------------

### Initialize Fireblocks EmbeddedWallet SDK Instance

Source: https://ncw-developers.fireblocks.com/docs/initializing-the-sdk

This snippet demonstrates how to create a new `EmbeddedWallet` SDK instance. It highlights required parameters like `authClientId` for your OAuth client ID and `authTokenRetriever` for fetching the end user’s IDP token. An optional `reporting` configuration can be enabled for error diagnostics. After initialization, `ew.assignWallet()` is called to create or assign a wallet for the user.

```JavaScript
const ew = new EmbeddedWallet({
  env: ENV_CONFIG.NCW_SDK_ENV,
  logLevel: 'INFO',
  logger,
  authClientId: ENV_CONFIG.AUTH_CLIENT_ID,
  authTokenRetriever: {
    getAuthToken: () => this._rootStore.userStore.getAccessToken(),
  },
  reporting: {
    enabled: true,
  },
});

const wallet = await ew.assignWallet();
```

```Kotlin
val embeddedWallet = EmbeddedWallet(
                context,
                authClientId = authClientId,
                authTokenRetriever = object : AuthTokenRetriever {
                    override suspend fun getAuthToken(): Result<String> {
                        val idToken = runBlocking {
                            SignInUtil.getInstance().getIdTokenBlocking(context)
                        }
                        return idToken?.let {
                            Result.success(it)
                        } ?: Result.failure(Exception("Failed to get auth token"))
                    }
                },
                options = EmbeddedWalletOptions.Builder().build()
)
```

```Swift
//EnvironmentConstants.ewEnv - default environment is .production
let options = EmbeddedWalletOptions(env: EnvironmentConstants.ewEnv, logLevel: .info, logToConsole: true, logNetwork: true, eventHandlerDelegate: nil, reporting: .init(enabled: true))

func initialize() throws -> EmbeddedWallet {
  guard instance == nil else {
    return instance!
  }

  return try EmbeddedWallet(authClientId: authClientId, authTokenRetriever: self, options: options)
}
```

--------------------------------

### API: requestJoinExistingWallet Function

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

Describes the `requestJoinExistingWallet` function in the EW SDK, used by a requesting device to initiate joining an existing wallet. It receives a handler that emits events like `requestId` and `onProvisionerFound` to track the process.

```APIDOC
requestJoinExistingWallet:
  description: A function in the requesting device that receives a handler that emits events according to the progression of the process.
  emits:
    - requestId: The UUID used to approve the request.
    - onProvisionerFound: Optional indication that the provisioner device was found.
```

--------------------------------

### Key Storage Provider Method Overview and Usage

Source: https://ncw-developers.fireblocks.com/docs/key-handler

Provides a detailed description of the common methods required by key storage providers across Fireblocks SDK platforms (Web, Android, iOS), outlining their purpose and platform-specific applicability for managing MPC key shares.

```APIDOC
store/set:
  Description: Called to store the MPC key share on the end-user device.
load/get:
  Description: Called to get the MPC key share from the end-user device.
remove:
  Description: Called to remove the MPC key share from the user device.
  Applicability: Android and iOS only.
contains:
  Description: Called to check if the set of MPC key shares is stored on the device.
  Applicability: Android and iOS only.
getAccess:
  Description: Called to lock or unlock the secure key storage upon every NCW SDK execution.
  Applicability: Web only.
```

--------------------------------

### Fireblocks NCW SDK Core Methods and Constants

Source: https://ncw-developers.fireblocks.com/docs/javascript-sdk

API methods for managing SDK instances (creation, retrieval, disposal) and core functionalities like MPC key generation, along with related constants.

```APIDOC
Methods:
  getFireblocksNCWInstance(deviceId)
  FireblocksNCWFactory(options)
  dispose()
  generateMPCKeys()

Constants:
  MPC_EDDSA_ED25519
```

--------------------------------

### Fireblocks Device Provisioning and Joining States

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

These are the possible states that an approving device or a requesting device can transition through during the multi-device provisioning and joining process in Fireblocks. Understanding these states is crucial for monitoring the progress and handling various outcomes, including successful completion, stopping, or timeouts.

```APIDOC
Approving Device States:
  - PROVISION_INITIATED
  - PROVISION_ADD_DEVICE_SETUP_REQUESTED
  - PROVISION_KEYS_SETUP_STARTED
  - PROVISION_SETUP_STARTED
  - PROVISION_SETUP_COMPLETED
  - STOPPED
  - TIMEOUT

Requesting Device States:
  - JOIN_INITIATED
  - ADD_DEVICE_SETUP_REQUESTED
  - PROVISIONER_FOUND
  - STOPPED
  - TIMEOUT
```

--------------------------------

### Create External Wallet using assignWallet()

Source: https://ncw-developers.fireblocks.com/docs/high-level-architecture

This snippet demonstrates how to create an External Wallet (EW) by calling the `assignWallet()` method via the client SDK. This method directly interacts with Fireblocks to create the wallet if it does not exist. After creation, the wallet ID can be stored for further operations.

```SDK
ew.assignWallet()
```

--------------------------------

### Fireblocks API for Solana Token Account Management

Source: https://ncw-developers.fireblocks.com/docs/asset-management

This API documentation outlines the process for managing Solana token accounts within Fireblocks. It details the use of the `add asset` endpoint to create a dedicated token account and the `retrieve asset` endpoint to query its activation state. Understanding these states is crucial for tracking the token account's readiness.

```APIDOC
Endpoint: add asset (POST)
  Description: Initiates the creation of a dedicated Solana token account.
  Action: Creates a transaction for user signing.

Endpoint: retrieve asset (GET)
  Description: Queries the activation state of an asset.
  Parameters:
    assetId: The ID of the asset to retrieve.
  Returns:
    state: Current activation status of the asset.
      Possible Values:
        PENDING_ACTIVATION: A transaction is awaiting user signature.
        ACTIVATION_FAILED: User failed to sign the transaction; asset needs re-adding.
        READY: The asset is successfully activated and ready for use.
```

--------------------------------

### Create Fireblocks Transaction with EW SDK

Source: https://ncw-developers.fireblocks.com/docs/create-transaction

This snippet demonstrates how to initiate a new transaction using the Fireblocks Embedded Wallet (EW) SDK. It shows the construction of transaction arguments, including source, destination, asset ID, and amount, and then calls the `createTransaction` method to generate a unique transaction ID.

```TypeScript
const txArgs: TransactionArguments = {
  source: {
    type: PeerType.END_USER_WALLET,
    walletId: '<my_user_wallet_id>,
    id: '0',
  },
  destination: {
    PeerType.ONE_TIME_ADDRESS,
    oneTimeAddress: {
      address: '<some_ETH_address>'
    }
  },
  assetId: 'ETH',
  amount: '<amount>',
  note: "My First EW Transaction"
};

const txId = await ew.createTransaction(txArgs);
```

```Kotlin
// createOneTimeAddressTransaction
suspend fun createOneTimeAddressTransaction(assetId: String, destAddress: String, amount: String, feeLevel: FeeLevel): Result<CreateTransactionResponse> {
  val transactionRequest = TransactionRequest(
    assetId = assetId,
    source = SourceTransferPeerPath(id = accountId.toString()),
    destination = DestinationTransferPeerPath(type = TransferPeerPathType.ONE_TIME_ADDRESS, oneTimeAddress = OneTimeAddress(address = destAddress)),
    amount = amount,
    feeLevel = feeLevel)
  return embeddedWallet.createTransaction(transactionRequest)
}
```

```Swift
//createOneTimeAddressTransaction

//initialize EmbeddedWallet instance
let instance = try initialize()
let request = TransactionRequest(
  assetId: assetId,
  source: SourceTransferPeerPath(id: String(accountId)),
  destination: DestinationTransferPeerPath(type: .oneTimeAddress, oneTimeAddress: OneTimeAddress(address: destAddress)),
    amount: amount,
      feeLevel: feeLevel
      )
return try await instance.createTransaction(transactionRequest: request)
```

--------------------------------

### Required OAuth Configuration Fields in Fireblocks Console

Source: https://ncw-developers.fireblocks.com/docs/setting-up-oauth-sso

This section details the essential configuration fields that must be provided when setting up OAuth in the Fireblocks Console for Embedded Wallets. Each field's purpose and typical values are described to ensure proper integration and token validation.

```APIDOC
OAuth Configuration Fields:
- API User:
  Description: Select an API user with the "EW Signer" role.
- JWKS URI:
  Description: The JWKS (JSON Web Key Set) endpoint from which Fireblocks retrieves your IDP’s public keys for token validation.
  Reference: Supported Identity Providers (IDPs)
- Issuer:
  Description: The expected `iss` claim in the token (must match your IDP’s value).
- Audience:
  Description: The expected `aud` claim in the token (typically your OAuth client ID).
- Custom wallet ID field name (optional):
  Description: Specify the name of a custom claim in your IDP token (e.g., a Firebase custom claim) that contains the wallet ID for the user. If presented in the token, Fireblocks will use this claim to override the default, deterministic wallet ID calculation for this user.
```

--------------------------------

### Recover MPC Key Shares with Fireblocks SDK

Source: https://ncw-developers.fireblocks.com/docs/backup-recovery-1

This snippet illustrates the process of recovering backed-up MPC key shares using the Fireblocks SDK. It utilizes a `passphraseResolver` callback to dynamically fetch the correct passphrase based on a given `passphraseId`, enabling the SDK to decrypt the key share locally. The recovery requires initializing the SDK with the same `deviceId` used during backup.

```JavaScript
await ewCore.recoverKeys(passphraseResolver);
```

```Kotlin
// recover the backed up keys. We will use the given backupEncryptionKey to decrypt the keys
Fireblocks.getInstance(deviceId).recoverKeys(passphraseResolver = passphraseResolver) {
	Timber.d("Recover keys result: $it")
  callback.invoke(it)
}
```

```Swift
//Initialize and create the Core SDK instance
let instance = try getCore()
let keySet = try await instance.recoverKeys(passphraseResolver: passphraseResolver)
```

--------------------------------

### API Error: 1002 Incomplete Backup

Source: https://ncw-developers.fireblocks.com/docs/api-errors

Details the 1002 error code, indicating that a device key was not backed up.

```APIDOC
Error Code: 1002 Incomplete Backup
Errors:
- Name: Incomplete Backup
  Message: The device key was not backed up. Learn more about backups here: /docs/backup-recovery-1 and multiple algorithms here: /docs/multiple-algorithms
```

--------------------------------

### API: approveJoinWalletRequest Function

Source: https://ncw-developers.fireblocks.com/docs/multiple-devices

Describes the `approveJoinWalletRequest` function in the EW SDK, used by an approving device to confirm or reject a new device's request to join a wallet. It requires the `requestId` obtained from the requesting device.

```APIDOC
approveJoinWalletRequest:
  description: A function in the approving device that receives a `requestId` and will allow the processing of the approval to start.
  parameters:
    - requestId: The ID of the join request to approve or reject.
```

--------------------------------

### Retrieve Supported Assets via Fireblocks API

Source: https://ncw-developers.fireblocks.com/docs/frequently-asked-questions

This snippet describes how to obtain a comprehensive list of all assets supported by Fireblocks, including their unique identifiers. These identifiers are crucial for correctly creating new assets within non-custodial wallets (NCW) or vault accounts using the Fireblocks API.

```APIDOC
API Endpoint: Get Supported Assets
Purpose: Retrieve a list of all assets supported by Fireblocks, including their unique identifiers.
Usage: Essential for creating new assets in non-custodial wallets (NCW) or vault accounts via the Fireblocks API.
Reference: https://developers.fireblocks.com/reference/get_supported-assets
```

--------------------------------

### Fireblocks API Considerations for Key Removal

Source: https://ncw-developers.fireblocks.com/docs/multiple-algorithms

This section outlines important considerations and limitations for the Fireblocks API concerning the removal of signing algorithms. It clarifies that the API only supports removal, not addition, and specifies conditions under which an algorithm cannot be removed, such as existing assets, public key retrieval, or wallet takeover.

```APIDOC
API for Key Removal:
  - Purpose: Only removes a signing algorithm.
    - Does NOT support adding algorithms.
  - Restrictions on Removal:
    1. Cannot remove if assets already exist under that algorithm.
    2. Cannot remove if the public key was retrieved using `getPublicKey`.
    3. Cannot remove if a takeover has been performed for the wallet.
```

--------------------------------

### Fireblocks SDK v10.0 backup/recovery Function Parameter Changes

Source: https://ncw-developers.fireblocks.com/docs/javascript-sdk

Describes breaking changes in Fireblocks SDK version 10.0 related to the `backupKeys` and `recoverKeys` functions, which now receive different parameters due to a safer backup and recovery mechanism.

```APIDOC
// API Changes in Fireblocks SDK v10.0:
// Backup and Recovery Functions:
//   Functions: backupKeys, recoverKeys
//   Change: Parameters received by these functions have changed.
//   Note: New parameter details are not specified in this document.
```

--------------------------------

### API Error: 1001 Incomplete Device

Source: https://ncw-developers.fireblocks.com/docs/api-errors

Details the 1001 error code, indicating that a device key status is INCOMPLETE.

```APIDOC
Error Code: 1001 Incomplete Device
Errors:
- Name: Incomplete Device
  Message: The device key status is in status INCOMPLETE. Learn more here: /docs/multiple-algorithms
```

--------------------------------

### Assign or Create Embedded Wallet

Source: https://ncw-developers.fireblocks.com/docs/mpc-key-generation

Initializes or retrieves an embedded wallet instance. This is a prerequisite step for subsequent operations like account creation or key generation within the Fireblocks Embedded Wallet SDK.

```Kotlin
embeddedWallet.assignWallet()
```

```Swift
embeddedWallet.assignWallet()
```

--------------------------------

### Android Fireblocks Key Storage Interface

Source: https://ncw-developers.fireblocks.com/docs/key-handler

Defines the Kotlin interface FireblocksKeyStorage for implementing custom key storage on Android. It includes methods for storing, loading, removing, and checking the presence of raw key data, facilitating secure MPC key share management.

```Kotlin
interface FireblocksKeyStorage {

    /**
     * Store raw keys data
     * @param keys map of keyId and raw [ByteArray] of data.
     * @param callback result is a map of store keys operation result
     */
    fun store(keys: Map<String, ByteArray>, callback: (result: Map<String, Boolean>) -> Unit)

    /**
     * Load raw keys data
     * @param keyIds a set of key ids to load
     * @param callback result is a map of key id and raw key data as [ByteArray]
     */
    fun load(keyIds: Set<String>, callback: (result: Map<String, ByteArray>) -> Unit)

    fun remove(keyIds: Set<String>, callback: (result: Map<String, Boolean>) -> Unit)

    fun contains(keyIds: Set<String>, callback: (result: Map<String, Boolean>) -> Unit)
}
```

--------------------------------

### FireblocksError Class and Error Constants

Source: https://ncw-developers.fireblocks.com/docs/javascript-sdk

Documentation for the FireblocksError class, providing structured error information via its properties, and a list of specific error constants with their numeric values.

```APIDOC
FireblocksError:
  properties:
    message
    key

Constants:
  INSTANCE_ALREADY_INITIALIZED = 109
  WRONG_RECOVERY_PASSPHRASE = 603
```

--------------------------------

### API Error: 1003 Unsupported Algorithms

Source: https://ncw-developers.fireblocks.com/docs/api-errors

Details the 1003 error code, indicating that a specified algorithm is not supported by the workspace.

```APIDOC
Error Code: 1003 Unsupported Algorithms
Errors:
- Name: Unsupported Algorithms
  Message: The Algorithm is not supported by the workspace. Learn more here: /docs/multiple-algorithms
```

--------------------------------

### Backup MPC Key Shares with Fireblocks SDK

Source: https://ncw-developers.fireblocks.com/docs/backup-recovery-1

This snippet demonstrates how to back up MPC key shares using the Fireblocks SDK across Web, Android, and iOS platforms. It requires a `passphrase` for encryption and a unique `passphraseId` for identification. The backup process involves calling the SDK's `backupKeys` function after securely storing the passphrase and its ID.

```JavaScript
await ewCore.backupKeys(passphrase, passphraseId);
```

```Kotlin
// create a symmetric key for the encryption of the backup
var backupEncryptionKey = fireblocksSdk.generateRandomPassPhrase();

// store the backupEncryptionKey somewhere (user’s iCloud/Google, d/l, convert to seed phrase or other)

// backup the keys (including encryption)
fireblocks.backupKeys(passphrase, passphraseId) {
  Timber.d("Backup keys result: $it")
  callback.invoke(it)
}
```

```Swift
func backupKeys() async throws -> Set<KeyBackup> {
    //Initialize and create the Core SDK instance
  let instance = try getCore()
  return try await instance.backupKeys(passphrase: <passphrase>, passphraseId: <passphraseId>)
}
```

--------------------------------

### Add Asset to Fireblocks Account

Source: https://ncw-developers.fireblocks.com/docs/asset-management

This snippet demonstrates how to add a new asset to a Fireblocks account using either JavaScript or a Curl command. The `accountId` parameter, typically an index, is often derived from `ew.createAccount()` and is set to `0` in demo environments for simplicity. This action activates a wallet for a specific asset within a vault account.

```JavaScript
const address = await ew.addAsset(accountId, assetId);
```

```Curl
curl --request POST \
     --url https://sandbox-api.fireblocks.io/v1/ncw/wallets/walletId/accounts/accountId/assets/assetId \
     --header 'accept: application/json'
```

--------------------------------

### Configure Android ABI Filters for 64-bit Devices

Source: https://ncw-developers.fireblocks.com/docs/minimum-requirements

This snippet demonstrates how to configure the `abiFilters` within the `ndk` block of an Android `build.gradle` file. It ensures that the application targets 64-bit architectures (`arm64-v8a`, `x86_64`), which is a minimum requirement for the SDK. Developers must also ensure their app's `build.gradle` file imposes this limitation for distribution.

```Gradle
ndk {
  abiFilters 'arm64-v8a', 'x86_64'
}
```

--------------------------------

### API Error: 1000 Incomplete Wallet

Source: https://ncw-developers.fireblocks.com/docs/api-errors

Details the 1000 error code, indicating that none of the devices in a wallet have a COMPLETE status.

```APIDOC
Error Code: 1000 Incomplete Wallet
Errors:
- Name: Incomplete Wallet
  Message: None of the devices in the Wallet have a COMPLETE status. Learn more here: /docs/multiple-algorithms
```

--------------------------------

### Retrieve Supported Assets API Endpoint

Source: https://ncw-developers.fireblocks.com/docs/supported-networks

Reference to the Fireblocks API endpoint for querying the full list of supported assets, including those not explicitly listed in the table on this page. This endpoint allows programmatic access to the complete asset catalog.

```APIDOC
Endpoint: GET /wallets/supported_assets
Documentation: https://developers.fireblocks.com/reference/wallets-getsupportedassets
```

--------------------------------

### Fireblocks SDK v11.0.0 Interface and Function Renames

Source: https://ncw-developers.fireblocks.com/docs/javascript-sdk

Details breaking changes in Fireblocks SDK version 11.0.0, including renaming of initialization functions, interface types, logger instantiation, and direct access to version and device ID generation functions.

```APIDOC
// API Changes in Fireblocks SDK v11.0.0:
// Initialization:
//   Old: FireblocksNCW.initialize(options)
//   New: FireblocksNCWFactory(options)
// Type Declaration:
//   Old: type FireblocksNCW
//   New: interface IFireblocksNCW
// Logger Initialization:
//   Old: new ConsoleLogger()
//   New: ConsoleLoggerFactory()
// Version Access:
//   Old: FireblocksNCW.version()
//   New: version()
// Device ID Generation:
//   Old: FireblocksNCW.generateDeviceId()
//   New: generateDeviceId()
```

--------------------------------

### API Role Permissions for EW Admin and EW Signer

Source: https://ncw-developers.fireblocks.com/docs/api-communication

This table outlines the specific operations that can be performed by the EW Admin and EW Signer API users, detailing which actions each role is permitted to execute, including creating accounts, managing transactions, and accessing asset information.

```APIDOC
API Roles:
  EW Admin:
    Permissions:
      - Create new EW Everywhere: true
      - Create new account under a specific EW Everywhere: true
      - Enable/Disable EW Everywhere: true
      - Get deposit address information: true
      - Create transaction from EW Everywhere: false
      - Get transaction fee information: true
      - Cancel transaction: false
      - Decline transfer: false
      - Enable/disable a signing device: false
      - Invoke RPC (relayed from the EW Everywhere SDK): false
      - Add asset to an account under an EW Everywhere: false
      - Get public key: true
      - Delete algorithm: true
  EW Signer:
    Permissions:
      - Create new EW Everywhere: false
      - Create new account under a specific EW Everywhere: true
      - Enable/Disable EW Everywhere: false
      - Get deposit address information: true
      - Create transaction from EW Everywhere: true
      - Get transaction fee information: true
      - Cancel transaction: true
      - Decline transfer: true
      - Enable/disable a signing device: true
      - Invoke RPC (relayed from the EW Everywhere SDK): true
      - Add asset to an account under an EW Everywhere: true
      - Get public key: false
      - Delete algorithm: false
```

--------------------------------

### Create New Account in Embedded Wallet

Source: https://ncw-developers.fireblocks.com/docs/mpc-key-generation

Creates a new account associated with the assigned embedded wallet. This operation is typically performed once to set up the wallet's account structure.

```JavaScript
// Create account under wallet
const newAccount = await ew.createAccount();
```

```Kotlin
embeddedWallet.createAccount()
```

```Swift
embeddedWallet.createAccount()
```

--------------------------------

### iOS Key Storage Delegate Protocol for Fireblocks SDK

Source: https://ncw-developers.fireblocks.com/docs/key-handler

Defines the Swift protocol KeyStorageDelegate for implementing custom key storage on iOS. This protocol specifies methods for storing, loading, removing, and verifying the presence of raw key data, essential for managing MPC key shares securely.

```Swift
public protocol KeyStorageDelegate: AnyObject {

     /// Store raw keys data
     /// - Parameters:
     ///   - keys: map of keyId and Data
     ///   - callback: result is a map of store keys and operation result
    func store(keys: [String: Data], callback: @escaping ([String: Bool]) -> ())

     /// Load raw keys data
     /// - Parameters:
     ///   - keyIds: a set of key ids to load
     ///   - callback: result is a map of key id and raw key data as Data
    func load(keyIds: Set<String>, callback: @escaping ([String: Data]) -> ())

     /// Remove raw data from your storage
     /// - Parameter keyId: key id to remove
    func remove(keyId: String)

     /// Check if Set of key ids is stored on your storage
     /// - Parameters:
     ///   - keyIds: a set of key ids to verify
     ///   - callback: result is a map of keys and operation result
    func contains(keyIds: Set<String>, callback: @escaping ([String : Bool]) -> ())
}
```

--------------------------------

### Sign Fireblocks Transaction with EW Core SDK

Source: https://ncw-developers.fireblocks.com/docs/create-transaction

This snippet illustrates how to sign a transaction that is in the 'PENDING_SIGNATURE' status using the Fireblocks Embedded Wallet (EW) Core SDK. It shows the invocation of the `signTransaction` method, passing the transaction ID to initiate the asynchronous MPC signing process.

```TypeScript
// Transaction is in PENDING_SIGNATURE status, can be signed now:
await ewCore.signTransaction(txId);
```

```Kotlin
Fireblocks.getInstance(deviceId).signTransaction(txId)
```

```Swift
//Initialize and create the Core SDK instance
let instance = try getCore()
let result = try await instance.signTransaction(txId: transactionId)
```

--------------------------------

### Define Events Handler Interface for Fireblocks EW SDK

Source: https://ncw-developers.fireblocks.com/docs/event-handler

The events handler object must be provided when initializing the Fireblocks Embedded Wallet (EW) SDK. It requires implementing a specific method to receive notifications about significant occurrences like key generation, backup, and transaction signing. This interface allows applications to react to SDK events by refreshing UI, logging, or dispatching notifications.

```TypeScript
export interface IEventsHandler {
  handleEvent(event: TEvent): void;
}
```

```Kotlin
interface FireblocksEventHandler {

    /**
     * Listens to various Fireblocks events see [Event]. Each event has relevant information.
     * In addition, in case of an error we will add the [FireblocksError] with the relevant error code
     */
    fun onEvent(event: Event)
}
```

```Swift
public protocol EventHandlerDelegate: AnyObject {
    /// Listens to various Fireblocks events [FireblocksEvent]. Each event has relevant information.
    /// In addition, in case of an error we will add the FireblocksError with the relevant error code
    /// - Parameter event: FireblocksEvent
     func onEvent(event: FireblocksEvent)
}
```

--------------------------------

### Retrieve Latest Backup Device ID for Recovery

Source: https://ncw-developers.fireblocks.com/docs/backup-recovery-1

This snippet demonstrates how to obtain the `deviceId` associated with the latest backup for a specific wallet. This `deviceId` is crucial for initializing the NCW SDK during the recovery procedure, as key shares are tied to the device that created the backup. Both Web SDK and direct API (Curl) methods are provided.

```JavaScript
await ew.getLatestBackup();
```

```Curl
curl --request GET \
     --url https://sandbox-api.fireblocks.io/v1/ncw/wallets/walletId/backup/latest \
     --header 'accept: application/json'
```

--------------------------------

### API Error: 404 Not Found

Source: https://ncw-developers.fireblocks.com/docs/api-errors

Details common reasons for a 404 Not Found error when interacting with Fireblocks APIs, indicating that a requested resource was not found.

```APIDOC
Error Code: 404 Not Found
Errors:
- Name: Wallet not found
  Message: The provided wallet ID was not found.
- Name: Device not found
  Message: The provided device ID was not found.
- Name: Tenant not found
  Message: The provided tenant ID was not found.
```
Tokens:
Raw