@fystack/sdk 0.1.0

package/src/api.ts

@@ -0,0 +1,332 @@
+import fetch from 'cross-fetch'
+import { APIConfig, Environment, createAPI } from './config'
+import { computeHMAC, computeHMACForWebhook } from './utils'
+import {
+  APICredentials,
+  WebhookEvent,
+  SignRequestParams,
+  SignResponse,
+  SignatureStatusResponse,
+  TransactionStatusResponse,
+  CreateWalletResponse,
+  WalletCreationStatusResponse,
+  WalletType,
+  WalletAsset,
+  AddressType,
+  DepositAddressResponse
+} from './types'
+import {
+  CreateCheckoutPayload,
+  CreateCheckoutPaymentPayload,
+  CreateCheckoutPaymentResponse,
+  CreateCheckoutResponse,
+  GetCheckoutPaymentResponse,
+  GetCheckoutResponse
+} from './payment'
+
+interface APIResponse {
+  data: any
+  success: boolean
+  message?: string
+}
+
+export interface HMACParams {
+  method: string
+  path: string
+  timestamp: string
+  body?: string
+}
+
+export interface WalletDetail {
+  APIKey: string
+  WalletID: string
+  Name: string
+  AddressType: string
+  Address: string
+}
+
+export interface CreateWalletPayload {
+  name: string
+  walletType: WalletType
+}
+
+export interface PaymentServiceParams {
+  apiKey: string
+  environment: Environment
+}
+
+export enum WalletAddressType {
+  Evm = 'evm',
+  Sol = 'sol'
+}
+
+async function composeAPIHeaders(
+  credentials: APICredentials,
+  httpMethod: string,
+  apiEndpoint: string,
+  body: Record<string, any> = {}
+): Promise<Record<string, string>> {
+  if (credentials.apiSecret == '') {
+    // If APISecret is not provided, fallback to cookie mode with no headers
+    return {}
+  }
+
+  const currentTimestampInSeconds = Math.floor(Date.now() / 1000)
+  const url = new URL(apiEndpoint)
+  const path = url.pathname // Extract the path
+  const params: HMACParams = {
+    method: httpMethod,
+    path,
+    timestamp: String(currentTimestampInSeconds),
+    body: Object.keys(body).length ? JSON.stringify(body) : ''
+  }
+
+  const digest = await computeHMAC(credentials.apiSecret, params as Record<string, any>)
+
+  const headers = {
+    'ACCESS-API-KEY': credentials.apiKey,
+    'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
+    'ACCESS-SIGN': btoa(digest) // convert to base64
+  }
+
+  return headers
+}
+
+export class APIService {
+  private credentials!: APICredentials
+  public Webhook: WebhookService
+  private API: APIConfig
+
+  constructor(credentials: APICredentials, environment: Environment) {
+    this.credentials = credentials
+    this.Webhook = new WebhookService(credentials)
+    this.API = createAPI(environment)
+  }
+
+  async getWalletDetail(
+    addressType: WalletAddressType = WalletAddressType.Evm,
+    walletId?: string
+  ): Promise<WalletDetail> {
+    const endpoint = this.API.endpoints.getWalletDetail(walletId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    console.info('headers', headers)
+    const resp = await get(endpoint + `?address_type=${addressType}`, headers)
+    return transformWalletDetail(resp.data)
+  }
+
+  async requestSign(walletId: string, params: SignRequestParams): Promise<SignResponse> {
+    const endpoint = this.API.endpoints.requestSign(walletId)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, params)
+    const response = await post(endpoint, params, headers)
+    return response.data
+  }
+
+  async getSignStatus(walletId: string, transactionId: string): Promise<SignatureStatusResponse> {
+    const endpoint = this.API.endpoints.getSignStatus(walletId, transactionId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
+
+  async signTransaction(walletId: string, body: Record<string, any>): Promise<SignResponse> {
+    const startTime = Date.now()
+    const endpoint = this.API.endpoints.signTransaction(walletId)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, body)
+    const response = await post(endpoint, body, headers)
+    const elapsedTime = Date.now() - startTime
+
+    console.log(`[WalletSDK] Sign transaction completed in ${elapsedTime}ms`)
+    console.log('[WalletSDK] Sign transaction response:', response)
+
+    return response.data
+  }
+
+  async getTransactionStatus(
+    walletId: string,
+    transactionId: string
+  ): Promise<TransactionStatusResponse> {
+    const endpoint = this.API.endpoints.getTransactionStatus(walletId, transactionId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
+
+  async createWallet(payload: CreateWalletPayload): Promise<CreateWalletResponse> {
+    const endpoint = this.API.endpoints.createWallet()
+    const transformedPayload = transformCreateWalletPayload(payload)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, transformedPayload)
+    const resp = await post(endpoint, transformedPayload, headers)
+    return resp.data
+  }
+
+  async createCheckout(payload: CreateCheckoutPayload): Promise<CreateCheckoutResponse> {
+    const endpoint = this.API.endpoints.createCheckout()
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, payload)
+    const response = await post(endpoint, payload, headers)
+    return response.data
+  }
+
+  async getWalletCreationStatus(walletId: string): Promise<WalletCreationStatusResponse> {
+    const endpoint = this.API.endpoints.getWalletCreationStatus(walletId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
+
+  async getWalletAssets(walletId: string): Promise<WalletAsset[]> {
+    const endpoint = this.API.endpoints.getWalletAssets(walletId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
+
+  /**
+   * Gets deposit address for a wallet by address type
+   * @param walletId The wallet ID
+   * @param addressType The type of address (evm, sol)
+   * @returns Deposit address response
+   */
+  async getDepositAddress(
+    walletId: string,
+    addressType: AddressType
+  ): Promise<DepositAddressResponse> {
+    const endpoint = this.API.endpoints.getDepositAddress(walletId, addressType)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
+}
+
+export class PaymentService {
+  private apiKey!: string
+  private API: Record<string, any>
+
+  constructor(params: PaymentServiceParams) {
+    this.apiKey = params.apiKey
+    this.API = createAPI(params.environment)
+  }
+
+  async createCheckout(payload: CreateCheckoutPayload): Promise<CreateCheckoutResponse> {
+    const endpoint = this.API.endpoints.createCheckout()
+    const headers = {
+      'ACCESS-API-KEY': this.apiKey
+    }
+    const response = await post(endpoint, payload, headers)
+    return response.data
+  }
+
+  async getCheckout(checkoutId: string): Promise<GetCheckoutResponse> {
+    const endpoint = this.API.endpoints.getCheckout(checkoutId)
+    const response = await get(endpoint)
+    return response.data
+  }
+
+  async createCheckoutPayment(
+    checkoutId: string,
+    payload: CreateCheckoutPaymentPayload
+  ): Promise<CreateCheckoutPaymentResponse> {
+    const endpoint = this.API.endpoints.createCheckoutPayment(checkoutId)
+    const response = await post(endpoint, payload)
+    return response.data
+  }
+
+  async getCheckoutPayment(checkoutId: string): Promise<GetCheckoutPaymentResponse> {
+    const endpoint = this.API.endpoints.getCheckoutPayment(checkoutId)
+    const response = await get(endpoint)
+    return response.data
+  }
+}
+
+export class WebhookService {
+  private credentials!: APICredentials
+
+  constructor(credentials: APICredentials) {
+    this.credentials = credentials
+  }
+
+  // Implement verify webhook here
+  async verifyEvent(event: WebhookEvent, signature: string): Promise<boolean> {
+    // Recompute HMAC
+    const computedHMAC = await computeHMACForWebhook(this.credentials.apiSecret, event)
+    const isValid = signature === computedHMAC
+    return isValid
+  }
+}
+
+// Simplified GET request function
+export async function get(
+  endpoint: string,
+  headers: Record<string, string> = {}
+): Promise<APIResponse> {
+  const request: RequestInit = {
+    method: 'GET',
+    headers: {
+      ...headers
+    }
+  }
+
+  // Only include credentials if we're in cookie mode (no API key in headers)
+  if (!headers['ACCESS-API-KEY']) {
+    request.credentials = 'include'
+  }
+
+  const response = await fetch(`${endpoint}`, request)
+  const data = await response.json()
+  if (!response.ok || !data.success) {
+    console.error('Status Code', response.status)
+    throw new Error(data.message || 'Failed to fetch data')
+  }
+
+  return data
+}
+
+// Simplified POST request function
+export async function post(
+  endpoint: string,
+  body: any,
+  headers: Record<string, string> = {}
+): Promise<APIResponse> {
+  const request: RequestInit = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...headers
+    },
+    body: JSON.stringify(body)
+  }
+
+  // Only include credentials if we're in cookie mode (no API key in headers)
+  if (!headers['ACCESS-API-KEY']) {
+    request.credentials = 'include'
+  }
+
+  const response = await fetch(`${endpoint}`, request)
+  const data = await response.json()
+  if (!response.ok || !data.success) {
+    console.error('Status Code', response.status)
+    throw new Error(data.message || 'Failed to fetch data')
+  }
+
+  return data
+}
+
+export function transformWalletDetail(data: Record<string, string>): WalletDetail {
+  return {
+    APIKey: data?.ap_key,
+    WalletID: data?.wallet_id,
+    Name: data?.name,
+    AddressType: data?.address_type,
+    Address: data?.address
+  }
+}
+
+export function transformCreateWalletPayload(data: CreateWalletPayload) {
+  return {
+    name: data.name,
+    wallet_type: data.walletType
+  }
+}
+
+;(BigInt.prototype as any).toJSON = function () {
+  return this.toString()
+}

package/src/config.ts

@@ -0,0 +1,75 @@
+enum Environment {
+  Local = 'local',
+  Sandbox = 'sandbox',
+  Production = 'production'
+}
+
+// Define the API routes structure
+export interface APIEndpoints {
+  signTransaction: (walletId: string) => string
+  requestSign: (walletId: string) => string
+  getSignStatus: (walletId: string, transactionId: string) => string
+  getTransactionStatus: (walletId: string, transactionId: string) => string
+  getWalletDetail: (walletId?: string) => string
+  createWallet: () => string
+  createCheckout: () => string
+  getCheckout: (checkoutId: string) => string
+  createCheckoutPayment: (checkoutId: string) => string
+  getCheckoutPayment: (checkoutId: string) => string
+  getWalletCreationStatus: (walletId: string) => string
+  getWalletAssets: (walletId: string) => string
+  getDepositAddress: (walletId: string, addressType: string) => string
+}
+
+const getBaseURL = (env: Environment): string => {
+  switch (env) {
+    case Environment.Local:
+      return 'http://localhost:8150'
+    case Environment.Sandbox:
+      return 'https://apex.void.exchange'
+    case Environment.Production:
+      return 'https://api.fystack.io'
+  }
+}
+
+export interface APIConfig {
+  baseURL: string
+  endpoints: APIEndpoints
+}
+
+const createAPI = (env: Environment): APIConfig => {
+  const baseURL = `${getBaseURL(env)}/api/v1`
+
+  const withBaseURL = (path: string) => `${baseURL}${path}`
+
+  return {
+    baseURL,
+    endpoints: {
+      signTransaction: (walletId: string) => withBaseURL(`/web3/transaction/${walletId}/signRaw`),
+      getWalletDetail: (walletId?: string) =>
+        walletId
+          ? withBaseURL(`/web3/wallet-detail/${walletId}`)
+          : withBaseURL('/web3/wallet-detail'),
+      createWallet: () => withBaseURL('/wallets'),
+      createCheckout: () => withBaseURL('/checkouts'),
+      getCheckout: (checkoutId: string) => withBaseURL(`/checkouts/${checkoutId}`),
+      createCheckoutPayment: (checkoutId: string) =>
+        withBaseURL(`/checkouts/${checkoutId}/payment`),
+      getCheckoutPayment: (checkoutId: string) => withBaseURL(`/checkouts/payment/${checkoutId}`),
+
+      // New endpoints for signing and transaction status
+      requestSign: (walletId: string) => withBaseURL(`/web3/${walletId}/sign`),
+      getSignStatus: (walletId: string, transactionId: string) =>
+        withBaseURL(`/web3/${walletId}/sign/${transactionId}`),
+      getTransactionStatus: (walletId: string, transactionId: string) =>
+        withBaseURL(`/web3/transaction/${walletId}/${transactionId}`),
+      getWalletCreationStatus: (walletId: string) =>
+        withBaseURL(`/wallets/creation-status/${walletId}`),
+      getWalletAssets: (walletId: string) => withBaseURL(`/wallets/${walletId}/assets`),
+      getDepositAddress: (walletId: string, addressType: string) =>
+        withBaseURL(`/wallets/${walletId}/deposit-address?address_type=${addressType}`)
+    }
+  }
+}
+
+export { Environment, createAPI }

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './sdk'
+export * from './signer'
+export * from './solanaSigner'
+export * from './api'
+export * from './types'
+export * from './config'
+export * from './utils/statusPoller'

package/src/payment.ts

@@ -0,0 +1,268 @@
+export interface Network {
+  id: string
+  created_at: string
+  updated_at: string
+  name: string
+  description: string
+  is_evm: boolean
+  chain_id: number
+  native_currency: string
+  is_testnet: boolean
+  internal_code: string
+  explorer_tx: string
+  explorer_address: string
+  explorer_token: string
+  confirmation_blocks: number
+  block_interval_in_seconds: number
+  disabled: boolean
+  logo_url: string
+}
+
+export interface Asset {
+  id: string
+  created_at: string
+  updated_at: string
+  name: string
+  symbol: string
+  decimals: number
+  logo_url: string
+  is_native: boolean
+  address_type: 'evm'
+  is_whitelisted: boolean
+  address?: string
+  network_id: string
+  network?: Network
+}
+export interface CreateCheckoutPayload {
+  price: string
+  currency: string
+  supported_assets: string[]
+  underpaid_cover_percent?: number
+  description?: string
+  success_url?: string
+  cancel_url?: string
+  product_id?: string
+  customer_id?: string
+  order_id?: string
+  enable_localization?: boolean
+  destination_wallet_id: string
+  from_address?: string
+  expiry_duration_seconds: number
+}
+
+/**
+ * Represents the payload required to create a checkout payment.
+ */
+export interface CreateCheckoutPaymentPayload {
+  /**
+   * Customer's email address.
+   *
+   * - This field is **optional**.
+   * - If provided, it must be a valid email format.
+   */
+  customer_email?: string
+
+  /**
+   * Unique identifier of the asset used for payment.
+   *
+   * - This field is **required**.
+   * - Must be a **UUIDv4**.
+   */
+  pay_asset_id: string
+}
+
+export interface CreateCheckoutResponse {
+  id: string
+  created_at: string
+  updated_at: string
+  currency: string
+  product_id: string
+  order_id: string
+  workspace_id: string
+  underpaid_cover_percent: number
+  description: string
+  price: string
+  supported_assets: Array<{
+    id: string
+    created_at: string
+    updated_at: string
+    is_native: boolean
+    is_whitelisted: boolean
+  }>
+  customer_id: string
+  expiry_duration_seconds: number
+  enable_localization: boolean
+  success_url: string
+  cancel_url: string
+  status: string
+  outcome: any
+  from_address: string
+}
+
+export enum PaymentStatus {
+  Pending = 'Pending',
+  Confirming = 'Confirming',
+  Success = 'Success'
+}
+
+export interface SupportedAsset {
+  id: string
+  created_at: string
+  updated_at: string
+  name: string
+  symbol: string
+  decimals: number
+  logo_url: string
+  is_native: boolean
+  address_type: 'evm'
+  is_whitelisted: boolean
+  address?: string
+  network_id: string
+  network: {
+    id: string
+    created_at: string
+    updated_at: string
+    name: string
+    description: string
+    is_evm: boolean
+    chain_id: number
+    native_currency: string
+    is_testnet: boolean
+    internal_code: string
+    explorer_tx: string
+    explorer_address: string
+    explorer_token: string
+    confirmation_blocks: number
+    block_interval_in_seconds: number
+    disabled: boolean
+    logo_url: string
+  }
+}
+
+export interface GetCheckoutResponse {
+  id: string
+  created_at: string
+  updated_at: string
+  currency: string
+  product_id: string
+  order_id: string
+  workspace_id: string
+  underpaid_cover_percent: number
+  description: string
+  price: string
+  supported_assets: SupportedAsset[]
+  customer_id: string
+  expiry_duration_seconds: number
+  enable_localization: boolean
+  success_url: string
+  cancel_url: string
+  status: PaymentStatus
+  outcome?: string | null
+  from_address: string
+}
+
+/**
+ * Represents the response structure for a checkout payment.
+ */
+export interface CreateCheckoutPaymentResponse {
+  /**
+   * Unique identifier of the payment.
+   */
+  id: string
+
+  /**
+   * Timestamp when the payment was created (ISO 8601 format).
+   */
+  created_at: string
+
+  /**
+   * Timestamp when the payment was last updated (ISO 8601 format).
+   */
+  updated_at: string
+
+  /**
+   * Unique identifier of the associated checkout.
+   */
+  checkout_id: string
+
+  /**
+   * Details of the associated checkout (if available).
+   * Can be `null` if no data is linked.
+   */
+  checkout: any | null // Replace `any` with the actual Checkout type if available
+
+  /**
+   * Customer's email address (if provided).
+   * Can be `null` if not available.
+   */
+  customer_email: string | null
+
+  /**
+   * Unique identifier of the asset used for payment.
+   */
+  pay_asset_id: string
+
+  /**
+   * Unique identifier of the blockchain network used for the transaction.
+   */
+  network_id: string
+
+  /**
+   * Details of the associated blockchain network (if available).
+   * Can be `null` if no data is linked.
+   */
+  network: any | null // Replace `any` with the actual Network type if available
+
+  /**
+   * Timestamp when the payment expires (ISO 8601 format).
+   */
+  expired_at: string
+
+  /**
+   * Blockchain address of the payer (if available).
+   * Can be `null` if not yet provided.
+   */
+  payer_address: string | null
+
+  /**
+   * Hash of the blockchain transaction (if completed).
+   * Can be `null` if the transaction has not been broadcasted yet.
+   */
+  tx_hash: string | null
+
+  /**
+   * The amount of cryptocurrency required for the payment,
+   * converted to the selected payment asset.
+   */
+  converted_crypto_price: string
+
+  /**
+   * The blockchain address where the customer should send the payment.
+   */
+  deposit_address: string
+
+  /**
+   * QR code (as a string) representing the deposit address for easy payment.
+   * Could be an empty string if not generated.
+   */
+  deposit_qr: string
+}
+
+export interface GetCheckoutPaymentResponse {
+  id: string
+  created_at: string
+  updated_at: string
+  checkout_id: string
+  checkout: GetCheckoutResponse
+  customer_email?: string | null
+  pay_asset_id: string
+  pay_asset: Asset
+  network_id: string
+  network: Network
+  expired_at: string
+  payer_address?: string | null
+  tx_hash?: string | null
+  converted_crypto_price: string
+  deposit_address: string
+  deposit_qr: string
+}