Перейти к содержанию

Self-Custody Use Case (XLM)

Данный гайд иллюстрирует создание секретов, синхронизацию адресов, получение баланса и отправку транзакции из клиентского приложения-кошелька в рамках сценария Self-Custody с использованием Spatium Signer Service.

Инициализация

Для взаимодействия со Spatium Signer Client необходимо предоставить следующие данные:

  • auth - сессия авторизации (AuthorizationSession)
  • storage - (StorageDirver) отвечающий за хранение клиентского секрета
import { MemoryStorageDriver, Crypto } from '@spatium/sdk';
import { AuthorizationSession, ServiceStorage, SignerClient } from '@spatium/signer-client';

export const createSignerClient = (auth: AuthorizationSession) => {
    const storage = new ServiceStorage('https://cloud.spatium.net/storage/v1', auth);

    const cache = new MemoryStorageDriver()
    const crypto = new Crypto(cache, storage)

    return new SignerClient('https://cloud.spatium.net/signer/v1', auth, crypto, 10 * 1000);  
};

import SpatiumSDKSwift
import SignerClientSwift

func createSignerClient() -> SignerClient {
    let auth = AuthorizationSession(
        url: "https://cloud.spatium.net/authorization/v1",
        tokenId: UUID().uuidString,
        permissions: ["read", "secret"]
    )

    let clientCache = MemoryStorageDriver()
    let clientStorage = MemoryStorageDriver()

    let clientCrypto = SpatiumCrypto(cache: clientCache, storage: clientStorage)

    let clientProtocol = SignerClient(
        url: "https://cloud.spatium.net/signer/v1",
        auth: auth,
        crypto: clientCrypto,
        timeout: 10 * 1000
    )

    return clientProtocol
}

Важно! В примере на TypeScript в качестве хранилища используется ServiceStorage, который размещает оба секрета на стороне Spatium. Использование данного формата подразумевает, что кошелек является кастодиальным. Не рекомендуется к использованию в продакшене.

Генерация секрета

Для пользования распределенным кошельком необходимо создать постоянную пару из клиентского и серверного секретов и обеспечить их надежное хранение. На стороне Spatium Signer Service управление секретом происходит автоматически, а на стороне клиента разработчик должен имплементировать стабильный StorageDirver самостоятельно. В обоих случаях секрет привязывается к идентификатору секрета (secretId) и после создания доступен по нему. У одного пользователя может быть любое количество секретов, однако так как нужно обеспечить их сохранность и возможность восстановления, рекомендуется использовать один секрет на пользователя.

Для резервного копирования секретов на случай утраты содержимого StorageDirver рекомендуется использовать функционал экспорта и импорта.

export const ensureSecret = async (signerClient: SignerClient, secretId: string) => {
  if (await signerClient.crypto.checkSecret(secretId)) {
    return;
  }

  try {
    // Ожидаем установки соединения 
    await signerClient.connect(10 * 1000);

    await signerClient.generateDistributedSecret(secretId);
  } finally {
    await signerClient.disconnect();
  }
};

func ensureSecret(signerClient: SignerClient, secretId: String) async throws {
    if (await signerClient.crypto.checkSecret(secretId: secretId)) {
        return;
    }

    // Ожидаем установки соединения
    try await signerClient.connect(timeout: 10 * 1000);
    defer {
        signerClient.disconnect()
    }
    try await signerClient.generateDistributedSecret(secretId: secretId);
};

Важно! На данном этапе разработки SDK рекомендуется использовать подобный подход при обращении к сервису, т.е. с подключением непосредственно перед взаимодействием и отключением после. Это позволит избежать распространенных сетевых ошибок пока они не будут полностью устранены.

Синхронизация адресов валют

Адрес валюты необходим для получения ассетов и запроса информации о балансе, поэтому рекомендуется сразу синхронизировать его при создании кошелька.

Для уменьшения времени синхронизации и улучшения пользовательского опыта рекомендуется использовать один публичный ключ (одни параметры синхронизации) для всех валют одной и той же криптосистемы. Для этого следует сначала синхронизировать один публичный ключ соответствующей криптосистемы, а затем сгенерировать с его помощью адреса в нужных валютах.

Каждая новая процедура синхронизации привязывается к уникальному идентификатору и ее результаты записываются в предоставленный StorageDirver, что дает возможность (имея сохраненный syncSessionId) синхронизировать ключ один раз и затем пользоваться результатами постоянно. Однако утрата данных синхронизации не несет долгосрочных последствий, так как ничего не мешает провести синхронизацию еще раз и получить при этом тот же самый публичный ключ и, соответственно, адреса.

Для процедуры синхронизации необходимы следующие данные:

  • secretId - идентификатор секрета, служащего энтропией данного кошелька. На момент синхронизации секреты должны быть уже сгенерированы;
  • syncSessionId - идентификатор сессии синхронизации. В случае совпадения предыдущая сессия с таким идентификатором будет перезаписана;
  • curve - эллиптическая кривая. Для xlm это ed25519;
  • derivationCoin - параметр HD деривации ключа, непосредственно влияет на результат генерации адреса. Уникальные значения приводят к генерации уникальных ключей. Рекомендуется использовать фиксированное значение для конкретной криптосистемы, а варьировать значение ключа следующим параметром;
  • derivationAccount - параметр HD деривации ключа, непосредственно влияет на результат генерации адреса. Уникальные значения приводят к генерации уникальных ключей.
import { syncDistributedEddsaKey, getEddsaPublicKey } from '@spatium/sdk';

export const ensureEddsaPublicKey = async (signerClient: SignerClient, secretId: string, syncSessionId: string, derivationCoin: number, derivationAccount: number): Promise<string> => {
  const publicKey = await getEddsaPublicKey(signerClient, secretId, syncSessionId).catch(() => null);
  if (publicKey) {
    return publicKey;
  }

  try {
    // Ожидаем установки соединения 
    await signerClient.connect(10 * 1000);

    const distributedEddsaKey = await syncDistributedEddsaKey(signerClient, secretId, syncSessionId, 'secp256k1', derivationCoin, derivationAccount);
    return distributedEddsaKey
  } finally {
    await signerClient.disconnect();
  }
};

func ensureEddsaPublicKey(signerClient: SignerClient, secretId: String, syncSessionId: String, derivationCoin: UInt32, derivationAccount: UInt32) async throws -> String {

    let publicKey = try await getEddsaPublicKey(driver: signerClient, secretId: secretId, syncSessionId: syncSessionId) 

    if !publicKey.isEmpty {
        return publicKey
    }

    // Ожидаем установки соединения 
    try await signerClient.connect(timeout: 10 * 1000)

    let distributedEddsaKey = try await syncDistributedEddsaKey(
        driver: signerClient,
        secretId: secretId,
        syncSessionId: syncSessionId,
        curve: .ed25519,
        derivationCoin: derivationCoin,
        derivationAccount: derivationAccount
    )

    return distributedEddsaKey
}

Для получения из публичного ключа адреса в конкретном блокчейне рекомендуется использовать Blockchain Connector Service.

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetAddressRequest = {
  network?: 'livenet' | 'testnet';
  publicKey: string;
  prefix?: boolean;
};
type XlmGetAddressResponse = {
  requestId: string;
  data: { address: string };
}

export const xlmGetAddress = async (
  auth: AuthorizationSession,
  { network, publicKey, prefix }: XlmGetAddressRequest,
): Promise<XlmGetAddressResponse['data']> => {
  const token = await auth.getPermissionToken();

  const response = await axios.post(
    `https://cloud.spatium.net/blockchain-connector-xlm/v1/api/get-address/xlm`,
    {
      publicKey,
      network,
      prefix,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return response.data;
};

struct XlmGetAddressRequest: Codable {
    enum Network: String, Codable {
        case livenet
        case testnet
    }

    let network: Network?
    let publicKey: String
    let prefix: Bool?
}

struct XlmGetAddressResponse: Decodable {
    let requestId: String
    let data: DataResponse
}

struct DataResponse: Decodable {
    let address: String
}

func xlmGetAddress(auth: AuthorizationSession, addressRequest: XlmGetAddressRequest) async throws -> String? {
    guard let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/get-address") else { throw CustomError.urlError }

    let token = try await auth.getPermissionToken()

    let headers: [String: String] = [
        "request-id": UUID().uuidString,
        "authorization": "Bearer \(token)"
    ]

    var request = URLRequest(url: url)
    request.httpMethod = "POST"

    headers.forEach { (key, value) in
        request.addValue(value, forHTTPHeaderField: key)
    }
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")

    guard let body = try? JSONEncoder().encode(addressRequest) else {
        throw CustomError.configurationError
    }

    request.httpBody = body

    let (data,_) = try await URLSession.shared.data(for: request)
    guard let address = try? JSONDecoder().decode(XlmGetAddressResponse.self, from: data) else {
        throw CustomError.codingError
    }

    return address.data.address
}

Важно! Для того чтобы при утрате данных в StorageDirver можно было однозначно восстановить все адреса со всеми средствами пользователя, нужно обеспечить бэкап клиентского секрета и внешнее хранение параметров генерации адресов, а именно:

  • secretId - данные генерации, также нужно хранить вместе с бэкапом секрета
  • curve - данные генерации
  • derivationCoin - данные генерации
  • derivationAccount - данные генерации

Получение информации об адресе

Имея синхронизированный адрес (или любой другой) можно обратиться к Address Info Service для получения развернутой информации об адресе, включая баланс в различных ассетах и историю транзакций.

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetAddressRequest = {
  network?: 'livenet' | 'testnet';
  address: string;
};
type XlmGetAddressResponse = {
  requestId: string;
  data: AddressInfo;
};

export const xlmGetAddressInfo = async (
  auth: AuthorizationSession,
  { network, address }: XlmGetAddressRequest,
): Promise<XlmGetAddressResponse['data']> => {
  const token = await auth.getPermissionToken();

  const result = await axios.get(
    `https://cloud.spatium.net/address-info-xlm/v1/api/xlm`,
    {
      params: { network, address },
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return result.data;
};

struct AddressInfo: Codable {
    let address: String
    let chain: String
    let balances: [Balance]
    // let transactions: [Transaction]
}

struct Balance: Codable {
    let asset: Asset
    let balance: BalanceAmount
}

struct Asset: Codable {
    let chain: String
    let kind: String
}

struct BalanceAmount: Codable {
    let amount: String
    let decimals: Int
}

//    struct Transaction {
//      // properties
//    }

struct XlmGetAddressInfoRequest {
    enum Network: String, Codable {
        case livenet
        case testnet
    }
    let network: Network?
    let address: String
}

struct XlmGetAddressInfoResponse: Codable {
    let requestId: String
    let data: AddressInfo
}

func btcLikeGetAddressInfo(auth: AuthorizationSession,
                           addressInfoRequest: XlmGetAddressInfoRequest) async throws -> AddressInfo {
    let token = try await auth.getPermissionToken()
    var url = URLComponents(string: "https://cloud.spatium.net/address-info-xlm/v1/api/xlm")!
    let params = [
        "address": addressInfoRequest.address,
        "network": addressInfoRequest.network?.rawValue
    ]

    url.queryItems = params.map { (key, value) in
        URLQueryItem(name: key, value: value)
    }

    var request = URLRequest(url: url.url!)
    request.httpMethod = "GET"
    request.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")
    request.addValue("Bearer \(token)", forHTTPHeaderField: "authorization")

    let (data, _) = try await URLSession.shared.data(for: request)

    let result = try JSONDecoder().decode(XlmGetAddressInfoResponse.self, from: data)

    return result.data
}

Подпись транзакции

Подпись транзакции включает в себя несколько этапов:

  • Оценка комиссии транзакции;
  • Формирование хэша транзакции;
  • Подпись хэша транзакции;
  • Формирование подписанной транзакции;
  • Отправка транзакции в блокчейн.

Из всех этих этапов только подпись хэша транзакции выполняется при помощи SDK, остальное предоставляется через API Blockchain Connector Service.

Информация о комиссии

Для указания максимального размера комиссии при формировании транзакции полезно ориентироваться на статистику текущих комиссий сети

Примечание

Существуют различные стратегии формирования максимальной комиссии, однако стоит учитывать, что транзакция с невысокой максимальной комиссией не будет обработана при нагрузке на сеть, поэтому мы ориентируем пользователей на значение статистической максимальной комиссии с добавлением небольшого запаса - текущей минимальной комиссии за операцию (feeCharged.max + lastLedgerBaseFee), при этом оставляя возможность указать любое значение комиссии вручную. Больше информации о получении комисии сети можно найти тут

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetFeeStatResponse = {
  xlm: {
    lastLedgerBaseFee: string;
    feeCharged: {
      min: string,
      max: string,
    }
  }
};

export const xlmGetFeeInfo = async (
  network: 'livenet' | 'testnet',
): Promise<XlmGetFeeInfoResponse> => {
  const result = xlmGetFeeInfoResponseSchema.parse(await axios.get(
    `https://cloud.spatium.net/fee-info-xlm/v1/static/fee-info-${network}.json`,
    {
    },
  ).then((result) => result.data));

  return result;
};

enum Network: String, Codable {
    case livenet
    case testnet
}

struct XlmFeeInfo: Codable {
  let lastLedgerBaseFee: String
  let feeCharged: FeeCharged

struct FeeCharged: Codable {
    let min: String
    let max: String
  }
}

struct XlmGetFeeInfoResponse: Codable {
  let xlm: XlmFeeInfo
}

func xlmGetFeeInfo(network: Network) async throws -> XlmGetFeeInfoResponse {
    let url = URL(string: "https://cloud.spatium.net/fee-info-xlm/v1/static/fee-info-\(network.rawValue).json")!

    let (data, response) = try await URLSession.shared.data(from: url)

    guard (response as? HTTPURLResponse)?.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    let result = try JSONDecoder().decode(XlmGetFeeInfoResponse.self, from: data)

    return result
}

Формирование хэша для подписи

Имея все предварительные данные, можно формировать хэш для подписи.

В XLM получение хэша отличачется в зависимости от типа транзакции:

  • Отправка валюты
  • Добавление трастлайна
  • Принятие claimableBalance

Формирование хэша для подписи транзакции отправки валюты

Важно

В соответствии с логикой работы сети Stellar нельзя отправить валюту на несуществующий в сети аккаунт (необходимо сначала создать этот аккаунт). Данный эндпоинт автоматически определяет наличие аккаунта в сети и и при необходимости создает его, предупреждения об отсутствии аккаунта в сети не будет! Подробнее про формирование хэша для подписи транзакции отправки валюты можно узнать тут.

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetHashTransferRequest = {
  network?: 'livenet' | 'testnet';
  publicKey: string;
  to: string,
  amount: string,
  asset?: StellarAsset;
  fee: string;
  memo?: string;
 };

type XlmGetHashTransferResponse = {
  requestId: string;
  data: {
    unsignedMessage: string;
    hash: string;
  }
};

export const xlmGetHashTransfer = async (
  auth: AuthorizationSession,
  { network, publicKey, to, amount, asset, fee, memo }: XlmGetHashTransferRequest,
): Promise<XlmGetHashTransferResponse['data']> => {
  const token = await auth.getPermissionToken();

  const response = await axios.post(
    'https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/transfer',
    {
      network,
      publicKey,
      to,
      amount,
      asset,
      fee,
      memo,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return response.data;
};

struct StellarAsset: Encodable {
    let kind = "stellar-asset"
    let chain = "xlm"
    let code: String
    let issuer: String
}

struct XlmGetHashTransferRequest: Encodable {
    let network: Network?
    let publicKey: String
    let to: String
    let amount: String
    let asset: StellarAsset?
    let fee: String
    let memo: String?
}

struct XlmGetHashTransferResponse: Decodable {
    let unsignedMessage: String
    let hash: String
}

func xlmGetHashTransfer(
  request: XlmGetHashTransferRequest
) async throws -> XlmGetHashTransferResponse {

  guard let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/transfer") else {
    throw CustomError.urlError
  }

  let auth = try AuthManager.shared.getAuthPermission()

  let token = try await auth.getPermissionToken()

  let headers = [
    "request-id": UUID().uuidString,
    "authorization": "Bearer \(token)"
  ]

  let parameters = request

  var urlRequest = URLRequest(url: url)
  urlRequest.httpMethod = "POST"
  headers.forEach { key, value in
    urlRequest.addValue(value, forHTTPHeaderField: key)
  }
  urlRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")

  guard let body = try? JSONEncoder().encode(parameters) else {
    throw CustomError.configurationError
  }

  urlRequest.httpBody = body

  let (data, _) = try await URLSession.shared.data(for: urlRequest)

  guard let response = try? JSONDecoder().decode(XlmGetHashTransferResponse.self, from: data) else {
    throw CustomError.codingError
  }

  return response
}

Формирование хэша для подписи транзакции добавления трастлайна

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetHashAddTrustlineRequest = {
  network?: 'livenet' | 'testnet';
  publicKey: string;
  to: string,
  amount?: string,
  asset: StellarAsset;
  fee: string;
  memo?: string;
 };

type XlmGetHashAddTrustlineResponse = {
  requestId: string;
  data: {
    unsignedMessage: string;
    hash: string;
  }
};

export const xlmGetHashAddTrustline = async (
  auth: AuthorizationSession,
  { network, publicKey, to, amount, asset, fee, memo }: XlmGetHashAddTrustlineRequest,
): Promise<XlmGetHashAddTrustlineResponse['data']> => {
  const token = await auth.getPermissionToken();

  const response = await axios.post(
    'https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/add-trustline',
    {
      network,
      publicKey,
      to,
      amount,
      asset,
      fee,
      memo,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return response.data;
};

struct XlmGetHashAddTrustlineRequest: Encodable {
    let network: String?
    let publicKey: String
    let to: String
    let amount: String?
    let asset: StellarAsset
    let fee: String
    let memo: String?
}

struct XlmGetHashAddTrustlineResponse: Decodable {
    let requestId: String
    let data: XlmGetHashAddTrustlineResponseData
}

struct XlmGetHashAddTrustlineResponseData: Decodable {
    let unsignedMessage: String
    let hash: String
}

func xlmGetHashAddTrustline(auth: AuthorizationSession, request: XlmGetHashAddTrustlineRequest) async throws -> XlmGetHashAddTrustlineResponse {

    let token = try await auth.getPermissionToken()

    let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/add-trustline")!

    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "POST"
    urlRequest.setValue(UUID().uuidString, forHTTPHeaderField: "request-id")
    urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "authorization")

    let encoder = JSONEncoder()
    let body = try encoder.encode(request)
    urlRequest.httpBody = body

    let (data, _) = try await URLSession.shared.data(for: urlRequest)

    guard let response = try? JSONDecoder().decode(XlmGetHashAddTrustlineResponse.self, from: data) else {
        throw CustomError.codingError
    }
    return response
}

Формирование хэша для подписи транзакции принятия claimableBalance

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmGetHashClaimRequest = {
  network?: 'livenet' | 'testnet';
  publicKey: string;
  claimableBalanceId: string,
  fee: string;
  memo?: string;
 };

type XlmGetHashClaimResponse = {
  requestId: string;
  data: {
    unsignedMessage: string;
    hash: string;
  }
};

export const xlmGetHashClaim = async (
  auth: AuthorizationSession,
  { network, publicKey, claimableBalanceId, fee, memo }: XlmGetHashClaimRequest,
): Promise<XlmGetHashClaimResponse['data']> => {
  const token = await auth.getPermissionToken();

  const response = await axios.post(
    'https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/claim',
    {
      network,
      publicKey,
      claimableBalanceId,
      fee,
      memo,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return response.data;
};

struct XlmGetHashClaimRequest: Encodable {
  let network: String?
  let publicKey: String
  let claimableBalanceId: String
  let fee: String
  let memo: String?
}

struct XlmGetHashClaimResponse: Decodable {
  let requestId: String
  let data: XlmGetHashClaimResponseData
}

struct XlmGetHashClaimResponseData: Decodable {
  let unsignedMessage: String
  let hash: String
}

func xlmGetHashClaim(auth: AuthorizationSession, request: XlmGetHashClaimRequest) async throws -> XlmGetHashClaimResponse {

  let token = try await auth.getPermissionToken()

  let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/get-hash/xlm/claim")!

  var urlRequest = URLRequest(url: url)
  urlRequest.httpMethod = "POST"
  urlRequest.setValue(UUID().uuidString, forHTTPHeaderField: "request-id")
  urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "authorization")

  let encoder = JSONEncoder()
  let body = try encoder.encode(request)
  urlRequest.httpBody = body

  let (data, _) = try await URLSession.shared.data(for: urlRequest)

  let response = try JSONDecoder().decode(XlmGetHashClaimResponse.self, from: data)
  return response
}

Получение токена подписи

import { randomBytes, uuid } from '@spatium/sdk';

export const getSigningToken = async (message: string): Promise<string> => {

  const { data: { permissionToken: { permissionToken: signingToken } } } = await axios.post('https://cloud.spatium.netauthorization/v1/api/permission/issue-by-key', {ы
    tokenId: uuid(randomBytes),
    permissions: ['sign'],
    payload: message,
    merchantKey: 'your-merchant-key',
  }).then(({ data }) => data);

  return signingToken;
};

//    struct PermissionRefreshToken : Codable {
//        let permissionRefreshToken : String?
//        let issuer : String?
//        let expiresAt : Int?
//    }

struct PermissionToken : Codable {
    let permissionToken : String
    let issuer : String?
    let expiresAt : Int?
}

struct TokenModel : Codable {
    //        let permissionRefreshToken : PermissionRefreshToken?
    let permissionToken : PermissionToken
}

struct IssueKeyResponse : Codable {
    let requestId : String
    let data : TokenModel
}

func getSigningToken(message: String) async throws -> String {
    let tokenId = UUID().uuidString

    let url = URL(string: "https://cloud.spatium.net/authorization/v1/api/permission/issue-by-key")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"

    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")

    let body: [String: Any] = [
        "tokenId": tokenId,
        "permissions": ["sign"],
        "payload": message,
        "merchantKey": Constants.merchantKey //"your-merchant-key"
    ]

    request.httpBody = try JSONSerialization.data(withJSONObject: body, options: [])

    let (data, _) = try await URLSession.shared.data(for: request)

    guard let tokenModel = try? JSONDecoder().decode(IssueKeyResponse.self, from: data) else {
        throw CustomError.codingError
    }

    return tokenModel.data.permissionToken.permissionToken
}

SMPC подпись хэша

import { signEddsaMessage } from '@spatium/sdk';
import { randomBytes, uuid } from '@spatium/sdk';

export const signEddsa = async (signerClient: SignerClient, secretId: string, syncSessionId: string, message: string, signingToken: string): Promise<EddsaSignature> => {
  const signSessionId = uuid(randomBytes);

  try {
    // Ожидаем установки соедения 
    await signerClient.connect(10 * 1000);

    return await signerClient.signEddsaMessage(secretId, syncSessionId, signSessionId, message, signingToken);
  } finally {
    await signerClient.disconnect();
  }
};

func signEddsa(signerClient: SignerClient,
               secretId: String,
               syncSessionId: String,
               message: String,
               signingToken: String) async throws -> EddsaSignature {

    let signSessionId = UUID().uuidString

    // Wait for the actual connection to be established
    try await signerClient.connect(timeout: 10 * 1000)

    defer {
        signerClient.disconnect()
    }

    do {
        let signature = try await signerClient.signEddsaMessage(secretId: secretId,
                                                                syncSessionId: syncSessionId,
                                                                signSessionId: signSessionId,
                                                                message: message,
                                                                signatureToken: signingToken)
        return signature
    } catch {
        throw error
    }
}

Формирование подписанной транзакции

Подпись нужно прикрепить к транзакции, тем самым получив данные, готовые к отправке в блокчейн.

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmAttachSignatureRequest = {
  network?: 'livenet' | 'testnet';
  publicKey: string;
  unsignedMessage: string;
  signature: EddsaSignature,
};

type XlmAttachSignatureResponse = {
  requestId: string;
  data: { txdata: string };
};

export const xlmAttachSignature = async (
  auth: AuthorizationSession,
  { network, publicKey, unsignedMessage, signature }: XlmAttachSignatureRequest,
): Promise<XlmAttachSignatureResponse['data']> => {

  const response = await axios.post(
    `https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/attach-signature/xlm`,
    {
      network,
      publicKey,
      unsignedMessage,
      signature,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    },
  ).then((result) => result.data);

  return response.data;
};

struct XlmAttachSignatureRequest: Encodable {
    enum Network: String, Codable {
        case livenet
        case testnet
    }

    let network: Network?
    let publicKey: String
    let unsignedMessage: String
    let signature: EddsaSignature
}

struct XlmAttachSignatureResponse: Decodable {
    let requestId: String
    let data: TxData
}

struct TxData: Decodable {
    let txdata: String
}

func xlmAttachSignature(auth: AuthorizationSession,
                            request: XlmAttachSignatureRequest) async throws -> TxData {

    let token = try await auth.getPermissionToken()

    let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/attach-signature/xlm")!

    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "POST"
    urlRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")
    urlRequest.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    urlRequest.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")

    let body = try JSONEncoder().encode(request)
    urlRequest.httpBody = body

    let (data, _) = try await URLSession.shared.data(for: urlRequest)

    let response = try JSONDecoder().decode(XlmAttachSignatureResponse.self, from: data)

    return response.data
}

Отправка транзакции в сеть

За отправку транзакции в блокчейн также отвечает Blockchain Connector Service

import axios from 'axios';
import { randomBytes, uuid } from '@spatium/sdk';

type XlmSendTXRequest = {
  txdata: string;
};
type XlmSendTXResponse = {
  requestId: string;
  data: { txid: string };
};

export const xlmSendTX = async (
  auth: AuthorizationSession,
  { txdata }: XlmSendTXRequest,
): Promise<XlmSendTXResponse['data']> => {
  const token = await auth.getPermissionToken();

  const response = await axios.post(
    `https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/send/xlm`,
    {
      txdata,
    },
    {
      headers: {
        'request-id': uuid(randomBytes),
        'authorization': `Bearer ${token}`,
      },
    }
  ).then((result) => result.data);

  return response.data;
};

struct XlmSendTXRequest: Encodable {
    let txdata: String
}

struct XlmSendTXResponse: Decodable {
    let requestId: String
    let data: TXID
}

struct TXID: Decodable {
    let txid: String
}

func xlmSendTX(auth: AuthorizationSession,
                   request: XlmSendTXRequest) async throws -> TXID {

    let token = try await auth.getPermissionToken()

    let url = URL(string: "https://cloud.spatium.net/blockchain-connector-xlm/v1/api/transaction/send/xlm")!

    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "POST"
    urlRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")
    urlRequest.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    urlRequest.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")

    let body = try JSONEncoder().encode(request)
    urlRequest.httpBody = body

    let (data, _) = try await URLSession.shared.data(for: urlRequest)
    print("ethLikeSendTX response: \(String(data:data, encoding: .utf8)!)")

    let response = try JSONDecoder().decode(XlmSendTXResponse.self, from: data)

    return response.data
}

Полная процедура

import { AuthorizationSession, SignerClient } from '@spatium/signer-client';
import { randomBytes, uuid } from '@spatium/sdk';

const auth = new AuthorizationSession('https://cloud.spatium.net/authorization/v1', uuid(randomBytes), ['read', 'secret']);

// получение security токенов
const { data: { securityToken } } = await axios.post('https://cloud.spatium.net/authorization/v1/api/security-factor/credentials', {
    username: 'username', password: 'password',
  }, {
    headers: {
      'request-id': uuid(randomBytes),
    },
  }).then(({ data }) => data);

await auth.establish([securityToken]);

const xlmSignTransaction = async (auth: AuthorizationSession, signerClient: SignerClient, secretId: string, syncSessionId: string, publicKey: string, to: string, amount: string) => {

  const { address } = await xlmGetAddress(auth, { publicKey })

  const feeInfo = await xlmGetFeeInfo(network);
  const fee = (Number(feeInfo.xlm.feeCharged.max) + Number(feeInfo.xlm.lastLedgerBaseFee)).toString();

  // получение хэша транзакции отправки валюты
  const { hash, unsignedMessage } = await xlmGetHashTransfer(auth, { publicKey, to, amount, fee });

    // получение хэша транзакции добавления трастлайна
  // const { hash, unsignedMessage } = await xlmGetHashAddTrustline(auth, { publicKey, asset, fee });

  // получение хэша транзакции получения claimableBalance
  // const { hash, unsignedMessage } = await xlmGetHashClaim(auth, { publicKey, claimableBalanceId, fee });

  const signingToken = await getSigningToken(hash)

  const signature = await signEddsa(signer, secretId, syncSessionId, hash, signingToken);

  const { txdata } = await xlmAttachSignature(auth, { publicKey, unsignedMessage, signature });

  const { txid } = await xlmSendTX(auth, { txdata });

  return txid;
}

let auth = AuthorizationSession(url: "https://cloud.spatium.net/authorization/v1", tokenId: UUID().uuidString, permissions: ["read", "secret"])

// get security tokens
let url = URL(string: "https://cloud.spatium.net/authorization/v1/api/security-factor/credentials")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")
guard let body = try? JSONEncoder().encode(["username": "username", "password": "password"])  else {
    throw CustomError.configurationError
}
request.httpBody = body

let (data, _) = try await URLSession.shared.data(for: request)
let response = try JSONDecoder().decode(SecurityTokenResponse.self, from: data)

try await auth.establish([response.data.securityToken])
//    struct PermissionRefreshToken : Codable {
//        let permissionRefreshToken : String?
//        let issuer : String?
//        let expiresAt : Int?
//    }

struct PermissionToken : Codable {
    let permissionToken : String
    let issuer : String?
    let expiresAt : Int?
}

struct TokenModel : Codable {
    // let permissionRefreshToken : PermissionRefreshToken?
    let permissionToken : PermissionToken
}

struct IssueKeyResponse : Codable {
    let requestId : String
    let data : TokenModel
}

func getSigningToken(message: String) async throws -> String {
    let tokenId = UUID().uuidString

    let url = URL(string: "https://cloud.spatium.net/authorization/v1/api/permission/issue-by-key")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"

    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue(UUID().uuidString, forHTTPHeaderField: "request-id")

    let body: [String: Any] = [
        "tokenId": tokenId,
        "permissions": ["sign"],
        "payload": message,
        "merchantKey": Constants.merchantKey //"your-merchant-key"
    ]

    request.httpBody = try JSONSerialization.data(withJSONObject: body, options: [])

    let (data, _) = try await URLSession.shared.data(for: request)

    guard let tokenModel = try? JSONDecoder().decode(IssueKeyResponse.self, from: data) else {
        throw CustomError.codingError
    }

    return tokenModel.data.permissionToken.permissionToken
}

func signXlmTransaction(auth: AuthorizationSession, signerClient: SignerClient, syncSessionId: String, publicKey: String, to: String, amount: String) async throws -> String {
    // let address = try await xlmGetAddress(auth: auth, addressRequest: XlmGetAddressRequest(network: .testnet, publicKey: publicKey, prefix: false))

    let feeInfo = try await xlmGetFeeInfo(network: .testnet)
    let fee = (feeInfo.xlm.feeCharged.max + feeInfo.xlm.lastLedgerBaseFee).description

    let hashResult = try await xlmGetHashTransfer(request:
                                                    XlmGetHashTransferRequest(
                                                        network: .testnet,
                                                        publicKey: publicKey,
                                                        to: to,
                                                        amount: amount,
                                                        asset: nil,
                                                        fee: fee,
                                                        memo: nil
                                                    )
    )

    let hash = hashResult.hash
    let unsignedMessage = hashResult.unsignedMessage

    let signingToken = try await getSigningToken(message: hash)

    guard let secretId = AuthManager.shared.secretID else {
        throw CustomError.configurationError
    }

    let signature = try await signEddsa(signerClient: signerClient, secretId: secretId, syncSessionId: syncSessionId, message: hash, signingToken: signingToken)

    let attachResult = try await xlmAttachSignature(auth: auth, request: XlmAttachSignatureRequest(network: .testnet, publicKey: publicKey, unsignedMessage: unsignedMessage, signature: signature))
    let txdata = attachResult.txdata

    let sendResult = try await xlmSendTX(auth: auth, request: XlmSendTXRequest(txdata: txdata))
    return sendResult.txid
}