REST API

Get account configuration

GEThttps://api.funkybit.fun/v1/account-config

Response

Body

newSymbolsarray of object-252064986 (object)

rolestring

Example: "User"

authorizedAddressesarray of object1226950960 (object)

testnetChallengeStatusstring

Example: "Unenrolled"

testnetChallengeDepositSymbolstring

Example: "USDC:31337"

testnetChallengeDepositLimitsarray of object-397882078 (object)

nickNamestring

Example: "Nick Name"

avatarUrlstring

Example: "https://icons/avatar.svg"

inviteCodestring

Example: "WYZFRORSQDI"

pointsBalancestring

Example: "0"

Request

const response = await fetch('https://api.funkybit.fun/v1/account-config', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "newSymbols": [
    {
      "name": "FUNK",
      "description": "funkybit Token",
      "contractAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "decimals": 18,
      "faucetSupported": true,
      "iconUrl": "https://icons/funk.svg",
      "withdrawalFee": "0"
    }
  ],
  "role": "User",
  "authorizedAddresses": [
    {
      "address": "0x0000000000000000000000000000000000000000",
      "networkType": "Evm"
    }
  ],
  "testnetChallengeStatus": "Unenrolled",
  "testnetChallengeDepositSymbol": "USDC:31337",
  "testnetChallengeDepositLimits": [
    {
      "symbol": "USDC:31337",
      "limit": "10000"
    }
  ],
  "nickName": "Nick Name",
  "avatarUrl": "https://icons/avatar.svg",
  "inviteCode": "WYZFRORSQDI",
  "pointsBalance": "0"
}

Mark symbol as added

POSThttps://api.funkybit.fun/v1/account-config/{symbolName}

Path parameters

symbolName*string

Symbol Name

Response

Request

const response = await fetch('https://api.funkybit.fun/v1/account-config/{symbolName}', {
    method: 'POST',
    headers: {},
});
const data = await response.json();

Get balances

GEThttps://api.funkybit.fun/v1/balances

Response

Body

balancesarray of object-176461050 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/balances', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "balances": [
    {
      "symbol": "USDC",
      "total": "0",
      "available": "0",
      "lastUpdated": "2024-10-22T10:04:09.634218514Z"
    }
  ]
}

Manage orders in batch

POSThttps://api.funkybit.fun/v1/batch/orders

Body

marketIdstring

Example: "BTC/ETH"

createOrdersarray of object-1058503512 (object)

cancelOrdersarray of object-2123361748 (object)

Response

Body

createdOrdersarray of object-1960910463 (object)

canceledOrdersarray of object796892056 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/batch/orders', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "marketId": "BTC/ETH",
      "createOrders": [
        {
          "type": "limit",
          "nonce": "123",
          "marketId": "BTC/ETH",
          "side": "Buy",
          "amount": {
            "type": "fixed",
            "value": "100"
          },
          "price": "100",
          "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
          "verifyingChainId": 0
        }
      ],
      "cancelOrders": [
        {
          "orderId": "123",
          "marketId": "BTC/ETH",
          "side": "Buy",
          "amount": "100",
          "nonce": "123",
          "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
          "verifyingChainId": 0
        }
      ]
    }),
});
const data = await response.json();

Response

{
  "createdOrders": [
    {
      "orderId": "order_01jasty60tffmaw3d4tx8sbsb2",
      "requestStatus": "Accepted",
      "order": {
        "type": "market",
        "nonce": "123",
        "marketId": "BTC/ETH",
        "side": "Buy",
        "amount": {
          "type": "fixed",
          "value": "100"
        },
        "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "verifyingChainId": 0
      }
    }
  ],
  "canceledOrders": [
    {
      "orderId": "order_01jasty60we9x8wcf140jbfvdn",
      "requestStatus": "Accepted"
    }
  ]
}

Get configuration

GEThttps://api.funkybit.fun/v1/config

Response

Body

chainsarray of object453395182 (object)

marketsarray of object865678341 (object)

feeRatesobject772049226 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/config', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "chains": [
    {
      "id": 1337,
      "name": "Bitlayer",
      "contracts": [
        {
          "name": "Exchange",
          "address": "0x0000000000000000000000000000000000000000"
        }
      ],
      "symbols": [
        {
          "name": "ETH",
          "description": "Ethereum",
          "decimals": 18,
          "faucetSupported": false,
          "iconUrl": "https://icons/eth.svg",
          "withdrawalFee": "1"
        }
      ],
      "jsonRpcUrl": "https://demo-anvil.funkybit.fun",
      "blockExplorerNetName": "funkybit Demo BitLayer",
      "blockExplorerUrl": "https://demo-otterscan.funkybit.fun",
      "networkType": "Evm"
    }
  ],
  "markets": [
    {
      "id": "USDC/DAI",
      "baseSymbol": "USDC",
      "baseDecimals": 18,
      "quoteSymbol": "DAI",
      "quoteDecimals": 6,
      "tickSize": "0.01",
      "lastPrice": "0.995",
      "minFee": "1"
    }
  ],
  "feeRates": {
    "maker": "1.0",
    "taker": "2.0"
  }
}

List deposits

GEThttps://api.funkybit.fun/v1/deposits

Response

Body

depositsarray of object584865457 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/deposits', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "deposits": [
    {
      "id": "id",
      "symbol": "USDC",
      "amount": "200000",
      "status": "Pending",
      "createdAt": "2024-10-22T10:04:09.636870049Z",
      "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
    }
  ]
}

Deposit

POSThttps://api.funkybit.fun/v1/deposits

Body

symbolstring

Example: "USDC"

amountstring

Example: "1000"

txHashstring

Example: "0x0000000000000000000000000000000000000000000000000000000000000000"

Response

Created

Body

depositobject584865457 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/deposits', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "symbol": "USDC",
      "amount": "1000",
      "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
    }),
});
const data = await response.json();

Response

{
  "deposit": {
    "id": "id",
    "symbol": "USDC",
    "amount": "200000",
    "status": "Pending",
    "createdAt": "2024-10-22T10:04:09.636870049Z",
    "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
  }
}

Get deposit

GEThttps://api.funkybit.fun/v1/deposits/{depositId}

Path parameters

depositId*string

Deposit Id

Response

Body

depositobject584865457 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/deposits/{depositId}', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "deposit": {
    "id": "id",
    "symbol": "USDC",
    "amount": "200000",
    "status": "Pending",
    "createdAt": "2024-10-22T10:04:09.636870049Z",
    "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
  }
}

Faucet

POSThttps://api.funkybit.fun/v1/faucet

Body

symbolstring

Example: "USDC"

addressstring

Example: "0x0000000000000000000000000000000000000000"

Response

Body

chainIdinteger

Example: 0

txHashstring

Example: "0x0000000000000000000000000000000000000000000000000000000000000000"

symbolstring

Example: "USDC"

amountstring

Example: "100000000000000000"

Request

const response = await fetch('https://api.funkybit.fun/v1/faucet', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "symbol": "USDC",
      "address": "0x0000000000000000000000000000000000000000"
    }),
});
const data = await response.json();

Response

{
  "chainId": 0,
  "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "symbol": "USDC",
  "amount": "100000000000000000"
}

Get last price for market

GEThttps://api.funkybit.fun/v1/last-price/{marketId}

Path parameters

marketId*string

Market Id

Response

Body

lastPricestring

Example: "0.995"

Request

const response = await fetch('https://api.funkybit.fun/v1/last-price/{marketId}', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "lastPrice": "0.995"
}

Get limits

GEThttps://api.funkybit.fun/v1/limits

Response

Body

limitsarray of object1547743688 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/limits', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "limits": [
    {
      "marketId": "BTC/ETH",
      "base": "1000000000000000000",
      "quote": "2000000000000000000"
    }
  ]
}

Get order book

GEThttps://api.funkybit.fun/v1/order-book/{marketId}

Path parameters

marketId*string

Market Id

Response

Body

marketIdstring

Example: "BTC/ETH"

bidsarray of object2067507266 (object)

asksarray of object2067508072 (object)

lastobject-2112455922 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/order-book/{marketId}', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "marketId": "BTC/ETH",
  "bids": [
    {
      "price": "16.75",
      "size": "1"
    }
  ],
  "asks": [
    {
      "price": "16.80",
      "size": "1"
    }
  ],
  "last": {
    "price": "16.75",
    "direction": "Up"
  }
}

List orders

GEThttps://api.funkybit.fun/v1/orders

Query parameters

Response

Body

ordersarray of object1082775760 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/orders', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "orders": [
    {
      "type": "market",
      "id": "order_01jasty60xe409rsqbjptn4ap8",
      "status": "Partial",
      "marketId": "BTC/ETH",
      "side": "Buy",
      "amount": "100",
      "executions": [
        {
          "tradeId": "trade_01jasty60zeyha4f33xg563v84",
          "timestamp": "2024-10-22T10:04:09.632396137Z",
          "amount": "50",
          "price": "500",
          "role": "Maker",
          "feeAmount": "0",
          "feeSymbol": "ETH",
          "marketId": "BTC/ETH"
        }
      ],
      "timing": {
        "createdAt": "2024-10-22T10:04:09.632914378Z",
        "sequencerTimeNs": "0"
      }
    }
  ]
}

Cancel open orders

DELETEhttps://api.funkybit.fun/v1/orders

Response

Request

const response = await fetch('https://api.funkybit.fun/v1/orders', {
    method: 'DELETE',
    headers: {},
});
const data = await response.json();

Create order

POSThttps://api.funkybit.fun/v1/orders

Body

one of

Response

Created

Body

one of

Request

const response = await fetch('https://api.funkybit.fun/v1/orders', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({}),
});
const data = await response.json();

Response

{
  "orderId": "order_01jasty60tffmaw3d4tx8sbsb2",
  "requestStatus": "Accepted",
  "order": {
    "type": "market",
    "nonce": "123",
    "marketId": "BTC/ETH",
    "side": "Buy",
    "amount": {
      "type": "fixed",
      "value": "100"
    },
    "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "verifyingChainId": 0
  }
}

The signature for creating an order can be either from an EVM or a Bitcoin wallet, regardless of the assets being traded. However, before an order containing a Bitcoin asset can be placed, a Bitcoin wallet must have been authorized; conversely, before an order containing an EVM asset can be placed, an EVM wallet must have been authorized. See the Authorize wallet API call below.

When signing an order with a fixed amount with an EVM wallet, create the signature by signing this EIP-712 message:

const message = {
  sender: address,
  baseChainId: baseChainId,
  baseToken: baseTokenAddress,
  quoteChainId: quoteChainId,
  quoteToken: quoteTokenAddress,
  amount: amount,
  price: price,
  nonce: Date.now()
}
const eip712 = {
  domain: {
    name: 'funkybit',
    chainId: chainId
  },
  types: {
    EIP712Domain: [
      { name: 'name', type: 'string' },
      { name: 'chainId', type: 'uint32' }
    ],
    'Order': [
      { name: 'sender', type: 'address' },
      { name: 'baseChainId', type: 'uint256' },
      { name: 'baseToken', type: 'address' },
      { name: 'quoteChainId', type: 'uint256' },
      { name: 'quoteToken', type: 'address' },
      { name: 'amount', type: 'int256' },
      { name: 'price', type: 'uint256' },
      { name: 'nonce', type: 'int256' }
    ]
  },
  message: message,
  primaryType: 'Order'
}

When signing an order with a percentage amount with an EVM wallet, create the signature by signing this EIP-712 message:

const message = {
  sender: address,
  baseChainId: baseChainId,
  baseToken: baseTokenAddress,
  quoteChainId: quoteChainId,
  quoteToken: quoteTokenAddress,
  percentage: percentage,
  price: price,
  nonce: Date.now()
}
const eip712 = {
  domain: {
    name: 'funkybit',
    chainId: chainId
  },
  types: {
    EIP712Domain: [
      { name: 'name', type: 'string' },
      { name: 'chainId', type: 'uint32' }
    ],
    'Order': [
      { name: 'sender', type: 'address' },
      { name: 'baseChainId', type: 'uint256' },
      { name: 'baseToken', type: 'address' },
      { name: 'quoteChainId', type: 'uint256' },
      { name: 'quoteToken', type: 'address' },
      { name: 'percentage', type: 'int256' },
      { name: 'price', type: 'uint256' },
      { name: 'nonce', type: 'int256' }
    ]
  },
  message: message,
  primaryType: 'Order'
}

When signing an order with a Bitcoin wallet, create the signature by signing a message constructed as follows:

const amountDescription = isPercentage ? `${amount}% of your` : amount
const swapDescription = isBuy ? `Swap ${amountDescription} ${quoteSymbol} for ${baseSymbol}` : `Swap ${amountDescription} ${baseSymbol} for ${quoteSymbol}`
const priceDescription = isLimit ? `Price: ${price}` : `Price: Market`
const message = `[funkybit] Please sign this message to authorize a swap. This action will not cost any gas fees.\n${swapDescription}\n${priceDescription}\nAddress: ${address}, Nonce: ${nonce}`

The bitcoin signature should be created following the same rules as for authentication.

Cancel order

DELETEhttps://api.funkybit.fun/v1/orders/{orderId}

Path parameters

orderId*string

Order Id

Body

orderIdstring

Example: "123"

marketIdstring

Example: "BTC/ETH"

sidestring

Example: "Buy"

amountstring

Example: "100"

noncestring

Example: "123"

signaturestring

Example:

"0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

verifyingChainIdinteger

Example: 0

Response

Request

const response = await fetch('https://api.funkybit.fun/v1/orders/{orderId}', {
    method: 'DELETE',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "orderId": "123",
      "marketId": "BTC/ETH",
      "side": "Buy",
      "amount": "100",
      "nonce": "123",
      "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
      "verifyingChainId": 0
    }),
});
const data = await response.json();

The signature for cancelling an order can be either from an EVM or a Bitcoin wallet, regardless of the assets being traded.

When signing an order cancellation with an EVM wallet, create the signature by signing this EIP-712 message:

const message = {
  sender: address,
  marketId: marketId,
  amount: amount,
  nonce: Date.now()
}
const eip712 = {
  domain: {
    name: 'funkybit',
    chainId: chainId
  },
  types: {
    EIP712Domain: [
      { name: 'name', type: 'string' },
      { name: 'chainId', type: 'uint32' }
    ],
    'CancelOrder': [
      { name: 'sender', type: 'address' },
      { name: 'marketId', type: 'string' },
      { name: 'amount', type: 'int256' },
      { name: 'nonce', type: 'int256' }
    ]
  },
  message: message,
  primaryType: 'CancelOrder'
}

When signing an order cancellation with a Bitcoin wallet, create the signature by signing a message constructed as follows:

const swapDescription = isBuy ? `Swap ${amount} ${quoteSymbol} for ${baseSymbol}` : `Swap ${amount} ${baseSymbol} for ${quoteSymbol}`
const message = `[funkybit] Please sign this message to authorize order cancellation. This action will not cost any gas fees.\n${swapDescription}\nAddress: ${address}, Nonce: ${nonce}`

The bitcoin signature should be created following the same rules as for authentication.

List trades

GEThttps://api.funkybit.fun/v1/trades

Query parameters

Response

Body

tradesarray of object-427886960 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/trades', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "trades": [
    {
      "id": "trade_1234",
      "timestamp": "2024-10-22T10:04:09.733660968Z",
      "orderId": "1234",
      "marketId": "BTC/ETH",
      "executionRole": "Taker",
      "counterOrderId": "4321",
      "side": "Buy",
      "amount": "12345",
      "price": "17.61",
      "feeAmount": "500",
      "feeSymbol": "ETH",
      "settlementStatus": "Pending"
    }
  ]
}

List withdrawals

GEThttps://api.funkybit.fun/v1/withdrawals

Response

Body

withdrawalsarray of object-717561876 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/withdrawals', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "withdrawals": [
    {
      "id": "id",
      "symbol": "USDC",
      "amount": "200000",
      "status": "Pending",
      "createdAt": "2024-10-22T10:04:09.635688840Z",
      "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "fee": "20"
    }
  ]
}

Withdraw

POSThttps://api.funkybit.fun/v1/withdrawals

Body

symbolstring

Example: "USDC"

amountstring

Example: "1000"

nonceinteger

Example: 1

signaturestring

Example:

"0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

Response

Created

Body

withdrawalobject-717561876 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/withdrawals', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "symbol": "USDC",
      "amount": "1000",
      "nonce": 1,
      "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
    }),
});
const data = await response.json();

Response

{
  "withdrawal": {
    "id": "id",
    "symbol": "USDC",
    "amount": "200000",
    "status": "Pending",
    "createdAt": "2024-10-22T10:04:09.635688840Z",
    "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "fee": "20"
  }
}

When withdrawing an EVM asset, create the signature by signing this EIP-712 message (the chainId must be the correct one for the token being withdrawn):

const message = {
  sender: address,
  token: tokenAddress,
  amount: amount,
  nonce: Date.now()
}
const eip712 = {
  domain: {
    name: 'funkybit',
    chainId: chainId
  },
  types: {
    EIP712Domain: [
      { name: 'name', type: 'string' },
      { name: 'chainId', type: 'uint32' }
    ],
    'Withdraw': [
      { name: 'sender', type: 'address' },
      { name: 'token', type: 'address' },
      { name: 'amount', type: 'uint256' },
      { name: 'nonce', type: 'uint64' }
    ]
  },
  message: message,
  primaryType: 'Withdraw'
}

When withdrawing a Bitcoin asset, create the signature by signing this message:

const message = `[funkybit] Please sign this message to authorize withdrawal of ${amountInSats} ${symbol} from the exchange to your wallet.\nAddress: ${address}, Timestamp: ${new Date().toISOString()}`

The bitcoin signature should be created following the same rules as for authentication.

Get withdrawal

GEThttps://api.funkybit.fun/v1/withdrawals/{withdrawalId}

Path parameters

withdrawalId*string

Withdrawal Id

Response

Body

withdrawalobject-717561876 (object)

Request

const response = await fetch('https://api.funkybit.fun/v1/withdrawals/{withdrawalId}', {
    method: 'GET',
    headers: {},
});
const data = await response.json();

Response

{
  "withdrawal": {
    "id": "id",
    "symbol": "USDC",
    "amount": "200000",
    "status": "Pending",
    "createdAt": "2024-10-22T10:04:09.635688840Z",
    "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "fee": "20"
  }
}

Authorize wallet

POSThttps://api.funkybit.fun/v1/wallets/authorize

Body

authorizedAddressstring

Example: "0x0000000000000000000000000000000000000000"

chainIdinteger

Example: 0

addressstring

Example: "bcrt1qdca3sam9mldju3ssryrrcmjvd8pgnw30ccaggx"

timestampstring

Example: "2024-08-21T14:14:13.095Z"

signaturestring

Example: ""

Response

Request

const response = await fetch('https://api.funkybit.fun/v1/wallets/authorize', {
    method: 'POST',
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "authorizedAddress": "0x0000000000000000000000000000000000000000",
      "chainId": 0,
      "address": "bcrt1qdca3sam9mldju3ssryrrcmjvd8pgnw30ccaggx",
      "timestamp": "2024-08-21T14:14:13.095Z",
      "signature": ""
    }),
});
const data = await response.json();

This is used to authorize a Bitcoin wallet for an existing EVM account, or to authorize an EVM wallet for an existing Bitcoin account. A given account can have at most 1 Bitcoin wallet and 1 EVM wallet. The wallet being added must not have already been added as either a primary or an additional wallet.

To authorize a Bitcoin wallet for an existing EVM wallet, sign this EIP-712 message (any valid chain id can be used):

const message = {
  message: `[funkybit] Please sign this message to authorize Bitcoin wallet ${authorizedAddress}. This action will not cost any gas fees.`,
  address: address.toLowercase(),
  authorizedAddress: authorizedAddress,
  chainId: chainId,
  timestamp: new Date().toISOString(),
}
const eip712 = {
  domain: {
    name: 'funkybit',
    chainId: chainId
  },
  types: {
    EIP712Domain: [
      { name: 'name', type: 'string' },
      { name: 'chainId', type: 'uint32' }
    ],
    'Authorize': [
      { name: 'message', type: 'string' },
      { name: 'address', type: 'string' },
      { name: 'authorizedAddress', type: 'string' },
      { name: 'chainId', type: 'uint32' },
      { name: 'timestamp', type: 'string' }
    ]
  },
  message: message,
  primaryType: 'Authorize'
}

To authorize an EVM wallet for an existing Bitcoin wallet, sign this message:

const message = `[funkybit] Please sign this message to authorize EVM wallet ${authorizedAddress.toLowerCase()}. This action will not cost any gas fees.\nAddress: ${address}, Timestamp: ${new Date().toISOString()}`

The bitcoin signature should be created following the same rules as for authentication.

PreviousWebsocket API

Last updated 5 days ago