Authentication

curl -H 'x-api-key:'key' \
     -H 'x-api-timestamp:17200001' \
     -H 'x-api-signature:signature_to_be_calculated' \
      https://{GATEWAY_URL}/swap/api/test?param1=test1&param2=test2 -d'{"data":"test"}'
 
===> Content is
{"apiPath":"/swap/api/test","body":{\"data\":\"test\"},"param1":"test1", "param2":"test2", "x-api-key":"key", "x-api-timestamp":"17200001"}

package example
 
import (
    context "context"
 
    bgw "github.com/bitgetwallet/tob-api-sdk"
    "github.com/bitgetwallet/tob-api-sdk/client"
    "github.com/bitgetwallet/tob-api-sdk/option"
)
 
func do() {
    client := client.NewClient(
        option.HTTPClient(bgw.NewSigningHTTPClient(apiKey, apiSecret, nil)),
    )
    resp, err := client.InstructionMode.InstructionQuote(
        context.Background(),
        &bgw.InstructionQuoteRequest{
            FromContract: "fromContract",
            FromAmount: "fromAmount",
            FromChain: "fromChain",
            ToContract: "toContract",
            ToChain: "toChain",
        },
    )
}

import { BitgetWalletApiClient } from "@bitget-wallet/api";
import { createSigningFetch } from "@bitget-wallet/api/auth";
 
const client = new BitgetWalletApiClient({
    // Auto-sign every request (see Authentication below).
    fetch: createSigningFetch({
        apiKey: xxx,
        apiSecret: xxx,
    }),
});
 
const quote = await client.instructionMode.instructionQuote({
    fromChain: "bnb",
    fromContract: "0x...",
    fromAmount: "1000000000000000000",
    toChain: "bnb",
    toContract: "0x...",
});
 
console.log(quote);

func signature(path, apiKey string, apiSecret, timestamp string, query map[string]string, body string) string {
    contentMap := make(map[string]string)
    contentMap["x-api-key"] = apiKey
    contentMap["x-api-timestamp"] = timestamp
    contentMap["apiPath"] = path
    for key, value := range query {
       contentMap[key] = value
    }
    contentMap["body"] = body
    content, _ := json.Marshal(contentMap)
    mac := hmac.New(sha256.New, []byte(apiSecret))
    mac.Write(content)
    return base64.StdEncoding.EncodeToString(mac.Sum(nil))
}

package org.example;
 
import com.google.gson.Gson;
 
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;
 
public class Main {
    private static String  Signature(String path, String apiKey, String apiSecret, String timestamp, HashMap<String, String> query, String body) throws Exception {
        TreeMap<String, String> mapping = new TreeMap<>();
 
        // Assemble content
        mapping.put("x-api-key", apiKey);
        mapping.put("x-api-timestamp", timestamp);
        mapping.put("apiPath", path);
        mapping.put("body", body);
 
        Set<Map.Entry<String, String>> entries = query.entrySet();
        for (Map.Entry<String, String> mapEntry : entries) {
            mapping.put(mapEntry.getKey(), mapEntry.getValue());
        }
 
        // Serialize
        Gson gson = new Gson();
        String content = gson.toJson(mapping);
 
        // HMAC signature
        Mac sha256_HMAC = Mac.getInstance("HmacSha256");
        SecretKeySpec secretKey = new SecretKeySpec(apiSecret.getBytes(), "HmacSha256");
        sha256_HMAC.init(secretKey);
        byte[] mac = sha256_HMAC.doFinal(content.getBytes());
 
        // Base64 encode
        Base64.Encoder base = Base64.getEncoder();
 
        return base.encodeToString(mac);
    }
    public static void main(String[] args) throws Exception {
        HashMap<String, String> query = new HashMap<>();
        query.put("key1", "val1");
        query.put("key2", "val2");
 
        System.out.println(Signature("/test", "123456", "7890", "1733366175000",query, "{\"body\":\"test\"}"));
    }
}

function getSignature(apiPath, body, apiKey, apiSecret, timeStamp, queryParams = {}) {
  // build contentTpl with all keys (base fields + queryParams keys)
  const contentTpl = {
    "apiPath": "",
    "body": "",
    "x-api-key": "",
    "x-api-timestamp": "",
  };
  // add queryParams keys to template
  if (queryParams && typeof queryParams === "object") {
    for (const key of Object.keys(queryParams)) {
      contentTpl[key] = "";
    }
  }
 
  // build content with actual values
  const content = {
    "apiPath": apiPath,
    "body": body,
    "x-api-key": apiKey,
    "x-api-timestamp": timeStamp,
  };
  if (queryParams && typeof queryParams === "object") {
    for (const [key, value] of Object.entries(queryParams)) {
      content[key] = String(value);
    }
  }
 
  // sort only by contentTpl keys
  const sortedKeys = Object.keys(contentTpl).sort();
  const sortedContent = Object.fromEntries(sortedKeys.map(key => [key, content[key]]));
 
  const payload = JSON.stringify(sortedContent);
 
  return crypto
    .createHmac("sha256", apiSecret)
    .update(payload)
    .digest("base64");
}