@silentswap/sdk 0.0.1

package/README.md

@@ -0,0 +1,6 @@
+# SilentSwap SDK
+
+```bash
+npm i @silentswap/sdk
+```
+

package/dist/caip19.d.ts

@@ -0,0 +1,29 @@
+import type { Caip19, IntStr } from './types/core.js';
+import type { Hex } from 'viem';
+export declare enum Caip19Namespace {
+    BIP122 = "bip122",
+    EIP155 = "eip155",
+    COSMOS = "cosmos",
+    SOLANA = "solana",
+    SUI = "sui",
+    STELLAR = "stellar"
+}
+export interface Caip19Parts<N extends Caip19Namespace> {
+    chainNamespace: N;
+    chainId: N extends Caip19Namespace.EIP155 ? number | bigint | IntStr : N extends Caip19Namespace.SUI ? 'mainnet' | 'testnet' | 'devnet' : string;
+    assetNamespace: N extends Caip19Namespace.EIP155 ? 'erc20' : N extends Caip19Namespace.SOLANA ? 'token' : N extends Caip19Namespace.COSMOS ? 'ics20' : N extends Caip19Namespace.SUI ? 'slip44' : string;
+    assetReference: N extends Caip19Namespace.EIP155 ? Hex : N extends Caip19Namespace.SUI ? string : bigint | IntStr;
+}
+/**
+ * Helper function makes a CAIP-19 string from parts
+ * @param parts CAIP-19 parts
+ * @returns CAIP-19 string
+ */
+export declare function caip19FromParts<N extends Caip19Namespace>(parts: Caip19Parts<N>): Caip19;
+/**
+ * Helper function makes a CAIP-19 string for an EVM fungible token
+ * @param chainId EVM chain ID
+ * @param tokenAddress EVM token address
+ * @returns CAIP-19 string
+ */
+export declare function caip19FungibleEvmToken(chainId: number, tokenAddress: Hex): Caip19;

package/dist/caip19.js

@@ -0,0 +1,31 @@
+export var Caip19Namespace;
+(function (Caip19Namespace) {
+    Caip19Namespace["BIP122"] = "bip122";
+    Caip19Namespace["EIP155"] = "eip155";
+    Caip19Namespace["COSMOS"] = "cosmos";
+    Caip19Namespace["SOLANA"] = "solana";
+    Caip19Namespace["SUI"] = "sui";
+    Caip19Namespace["STELLAR"] = "stellar";
+})(Caip19Namespace || (Caip19Namespace = {}));
+/**
+ * Helper function makes a CAIP-19 string from parts
+ * @param parts CAIP-19 parts
+ * @returns CAIP-19 string
+ */
+export function caip19FromParts(parts) {
+    return `${parts.chainNamespace}:${parts.chainId}/${parts.assetNamespace}:${parts.assetReference}`;
+}
+/**
+ * Helper function makes a CAIP-19 string for an EVM fungible token
+ * @param chainId EVM chain ID
+ * @param tokenAddress EVM token address
+ * @returns CAIP-19 string
+ */
+export function caip19FungibleEvmToken(chainId, tokenAddress) {
+    return caip19FromParts({
+        chainNamespace: Caip19Namespace.EIP155,
+        chainId,
+        assetNamespace: 'erc20',
+        assetReference: tokenAddress,
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,69 @@
+import { ENVIRONMENT } from './constants.js';
+import type { AuthRequest, AuthResponse, NonceResponse, OrderRequest, OrderResponse, QuoteRequest, QuoteResponse } from './types/api.js';
+import type { ResponseWrapper } from './types/sdk.js';
+import type { Hex } from 'viem';
+export type SilentSwapClientConfig = {
+    /**
+     * API key for authentication
+     */
+    apiKey: string;
+    /**
+     * Chain environment
+     */
+    environment: ENVIRONMENT;
+    /**
+     * Base URL to override the default
+     */
+    baseUrl?: string;
+};
+/**
+ * SilentSwap client
+ */
+declare class SilentSwapClient {
+    #private;
+    protected config: SilentSwapClientConfig;
+    constructor(config: SilentSwapClientConfig);
+    /**
+     * Returns the gateway address for the current environment
+     */
+    get gatewayAddress(): Hex;
+    /**
+     * Returns the proxy public key for the current environment
+     */
+    get proxyPublicKey(): Hex;
+    /**
+     * Fetches a signed nonce from the backend for the given signer address
+     * @param addr - signer address
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link NonceResponse `<NonceResponse>`}
+     */
+    nonce(addr: Hex, init?: RequestInit): Promise<ResponseWrapper<NonceResponse>>;
+    /**
+     * Authenticates a signer with the backend
+     * @param auth - authentication request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link AuthResponse `<AuthResponse>`}
+     */
+    authenticate(auth: AuthRequest, init?: RequestInit): Promise<ResponseWrapper<AuthResponse>>;
+    /**
+     * Fetches a signed quote from the backend
+     * @param quote - quote request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link QuoteResponse `<QuoteResponse>`}
+     */
+    quote(quote: QuoteRequest, init?: RequestInit): Promise<ResponseWrapper<QuoteResponse>>;
+    /**
+     * Creates a SilentSwap order, a prerequisite to depositing funds into the Gateway contract
+     * @param order - order request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link OrderResponse `<OrderResponse>`}
+     */
+    order(order: OrderRequest, init?: RequestInit): Promise<ResponseWrapper<OrderResponse>>;
+}
+export type { SilentSwapClient };
+/**
+ * Creates a new SilentSwap client
+ * @param gc_client - client configuration
+ * @returns a new {@link SilentSwapClient}
+ */
+export declare function createSilentSwapClient(gc_client: SilentSwapClientConfig): SilentSwapClient;

package/dist/client.js

@@ -0,0 +1,168 @@
+import { ENVIRONMENT, MAINNET_GATEWAY_ADDRESS, MAINNET_GATEWAY_PUBLIC_KEY, MAINNET_SILENTSWAP_API } from './constants.js';
+const ENVIRONMENT_CONFIGS = {
+    [ENVIRONMENT.MAINNET]: {
+        gatewayAddress: MAINNET_GATEWAY_ADDRESS,
+        proxyPublicKey: MAINNET_GATEWAY_PUBLIC_KEY,
+    },
+};
+/**
+ * SilentSwap client
+ */
+class SilentSwapClient {
+    config;
+    constructor(config) {
+        this.config = config;
+        // unsupported environment
+        if (!['MAINNET'].includes(this.config.environment)) {
+            throw new Error(`Unsupported environment: ${this.config.environment}`);
+        }
+    }
+    /**
+     * Performs a GET request to the backend API
+     * @param path - path to request
+     * @param params - query parameters
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `<ResponseWrapper>`}`<Data>`
+     */
+    async #get(path, params = {}, init = {}) {
+        const { config } = this;
+        // submit GET request
+        const res = await fetch(`${(config.baseUrl ?? MAINNET_SILENTSWAP_API) + path}?${new URLSearchParams(params).toString()}`, {
+            ...init || {},
+            method: 'GET',
+            headers: {
+                ...init?.headers
+                    ? Object === init.headers.constructor
+                        ? init.headers
+                        : () => { throw new Error('.headers value must be a plain object'); }
+                    : {},
+                authorization: config.apiKey,
+                accept: 'application/json',
+            },
+        });
+        // read body
+        const resBody = await res.text();
+        // attempt to parse response body JSON
+        try {
+            const resJson = JSON.parse(resBody);
+            // OK respose
+            if (res.ok) {
+                return [void 0, resJson];
+            }
+            // not OK
+            else {
+                return [resJson, void 0];
+            }
+        }
+        catch (_err) {
+            return [{
+                    type: 'SERVER_ERROR',
+                    error: `Failed to parse server response:\n${resBody}`,
+                }, void 0];
+        }
+    }
+    /**
+     * Performs a POST request to the backend API
+     * @param path - path to request
+     * @param reqBody - request body JSON object
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}`<Data>`
+     */
+    async #post(path, reqBody, init = {}) {
+        const { config } = this;
+        // submit POST request
+        const res = await fetch((config.baseUrl ?? MAINNET_SILENTSWAP_API) + path, {
+            ...init || {},
+            method: 'POST',
+            headers: {
+                ...init?.headers
+                    ? Object === init.headers.constructor
+                        ? init.headers
+                        : () => { throw new Error('.headers value must be a plain object'); }
+                    : {},
+                'authorization': config.apiKey,
+                'accept': 'application/json',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(reqBody),
+        });
+        // read body
+        const resBody = await res.text();
+        // attempt to parse response body JSON
+        try {
+            const resJson = JSON.parse(resBody);
+            // OK respose
+            if (res.ok) {
+                return [void 0, resJson];
+            }
+            // not OK
+            else {
+                return [resJson, void 0];
+            }
+        }
+        catch (_err) {
+            return [{
+                    type: 'SERVER_ERROR',
+                    error: `Failed to parse server response:\n${resBody}`,
+                }, void 0];
+        }
+    }
+    /**
+     * Returns the gateway address for the current environment
+     */
+    get gatewayAddress() {
+        return ENVIRONMENT_CONFIGS[this.config.environment].gatewayAddress;
+    }
+    /**
+     * Returns the proxy public key for the current environment
+     */
+    get proxyPublicKey() {
+        return ENVIRONMENT_CONFIGS[this.config.environment].proxyPublicKey;
+    }
+    /**
+     * Fetches a signed nonce from the backend for the given signer address
+     * @param addr - signer address
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link NonceResponse `<NonceResponse>`}
+     */
+    async nonce(addr, init = {}) {
+        return await this.#get('/nonce', {
+            address: addr,
+        }, init);
+    }
+    /**
+     * Authenticates a signer with the backend
+     * @param auth - authentication request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link AuthResponse `<AuthResponse>`}
+     */
+    async authenticate(auth, init = {}) {
+        return await this.#post('/authenticate', auth, init);
+    }
+    /**
+     * Fetches a signed quote from the backend
+     * @param quote - quote request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link QuoteResponse `<QuoteResponse>`}
+     */
+    async quote(quote, init = {}) {
+        return await this.#post('/quote', quote, init);
+    }
+    /**
+     * Creates a SilentSwap order, a prerequisite to depositing funds into the Gateway contract
+     * @param order - order request
+     * @param init - request initialization options
+     * @returns a {@link ResponseWrapper `ResponseWrapper`}{@link OrderResponse `<OrderResponse>`}
+     */
+    async order(order, init = {}) {
+        return await this.#post('/order', order, init);
+    }
+}
+/**
+ * Creates a new SilentSwap client
+ * @param gc_client - client configuration
+ * @returns a new {@link SilentSwapClient}
+ */
+export function createSilentSwapClient(gc_client) {
+    return new SilentSwapClient(gc_client);
+}

package/dist/constants.d.ts

@@ -0,0 +1,14 @@
+import { type Hex } from 'viem';
+export declare const EVM_PHONY_ADDRESS: Hex;
+export declare const EVM_NATIVE_ADDRESS: Hex;
+export declare const MAINNET_SILENTSWAP_API = "https://api.silentswap.com/v2";
+export declare const MAINNET_GATEWAY_ADDRESS = "0xA798d4D04faad17C309127C2B9B99Cc459635eDC";
+export declare const MAINNET_GATEWAY_PUBLIC_KEY = "0x0494913354a94d40604cd453d2a654489aa78472daf953c63cae4ceaaa40740d682905847e99618c34b360d8ef4645a954cc9686619995465dfdba6da34f35642f";
+export declare const COIN_TYPES: {
+    readonly ETH: "60";
+    readonly ATOM: "118";
+    readonly SCRT: "529";
+};
+export declare enum ENVIRONMENT {
+    MAINNET = "MAINNET"
+}

package/dist/constants.js

@@ -0,0 +1,19 @@
+// EVM addresses
+export const EVM_PHONY_ADDRESS = '0x1111111111111111111111111111111111111111';
+export const EVM_NATIVE_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+// Mainnet constants
+export const MAINNET_SILENTSWAP_API = 'https://api.silentswap.com/v2';
+export const MAINNET_GATEWAY_ADDRESS = '0xA798d4D04faad17C309127C2B9B99Cc459635eDC';
+export const MAINNET_GATEWAY_PUBLIC_KEY = '0x0494913354a94d40604cd453d2a654489aa78472daf953c63cae4ceaaa40740d682905847e99618c34b360d8ef4645a954cc9686619995465dfdba6da34f35642f';
+// Coin types
+export const COIN_TYPES = {
+    ETH: '60',
+    ATOM: '118',
+    SCRT: '529',
+};
+// Environments
+export var ENVIRONMENT;
+(function (ENVIRONMENT) {
+    ENVIRONMENT["MAINNET"] = "MAINNET";
+})(ENVIRONMENT || (ENVIRONMENT = {}));
+;

package/dist/facilitator-account.d.ts

@@ -0,0 +1,50 @@
+import { Account, Hex } from 'viem';
+import { OfflineAminoSigner } from '@cosmjs/amino';
+import { FacilitatorKeyType, type FacilitatorPublicKey } from './order.js';
+import type { EncryptSecretKeyArgs, ExportedFacilitator } from './types/sdk.js';
+import type { CoinTypeStr } from './types/core.js';
+import type { ProxyAuthInstruction } from './types/authorization.js';
+export declare const SECP256K1: import("@solar-republic/wasm-secp256k1").Secp256k1;
+export declare class FacilitatorAccount {
+    #private;
+    /**
+     * Creates a facilitator account
+     * @param secretKeyBytes optional secret key bytes
+     */
+    constructor(secretKeyBytes?: Uint8Array<ArrayBuffer>);
+    /**
+     * Exports the secret key
+     * @returns A copy of the secret key
+     */
+    exportSecretKey(): Uint8Array;
+    /**
+     * Exports the public key for the given coin type and key type
+     * @param coinType coin type
+     * @param keyType key type
+     * @returns the public key
+     */
+    exportPublicKey(coinType: CoinTypeStr, keyType: FacilitatorKeyType): FacilitatorPublicKey;
+    /**
+     * Returns a Viem {@link Account} instance for signing EVM transactions from this account
+     * @returns A Promise that resolves to the signer
+     */
+    evmSigner(): Promise<Account>;
+    /**
+     * Returns a CosmJS {@link OfflineAminoSigner} instance for signing Cosmos transactions from this account
+     * @param bech32Prefix - the bech32 prefix for the desired chain
+     * @returns A Promise that resolves to the signer
+     */
+    cosmosSigner(bech32Prefix: string): Promise<OfflineAminoSigner>;
+    /**
+     * Signs a proxy authorization instruction
+     * @param authorization the proxy authorization instruction to sign
+     * @returns the signature
+     */
+    signProxyAuthorization(authorization: ProxyAuthInstruction): Promise<Hex>;
+    /**
+     * Encrypts the secret key with the given public key
+     * @param args encryption arguments
+     * @returns the encrypted secret key
+     */
+    encryptSecretKeyForProxy(args: EncryptSecretKeyArgs): Promise<ExportedFacilitator>;
+}

package/dist/facilitator-account.js

@@ -0,0 +1,108 @@
+import { bytesToHex, stringToBytes } from 'viem';
+import { toBase64 } from '@cosmjs/encoding';
+import { initWasmSecp256k1 } from '@solar-republic/wasm-secp256k1';
+import { privateKeyToAccount } from 'viem/accounts';
+import { Secp256k1Wallet } from '@cosmjs/amino';
+import { normalizeBytesish, normalizeJson } from './util.js';
+import { FacilitatorKeyType } from './order.js';
+// wasm-secp256k1 instance
+export const SECP256K1 = await initWasmSecp256k1();
+export class FacilitatorAccount {
+    #secretKey;
+    /**
+     * Creates a facilitator account
+     * @param secretKeyBytes optional secret key bytes
+     */
+    constructor(secretKeyBytes) {
+        // if secret was given, copy its bytes into a new section of memory so parent can zeroize original
+        this.#secretKey = secretKeyBytes ? secretKeyBytes.slice() : SECP256K1.gen_sk();
+    }
+    /**
+     * Exports the secret key
+     * @returns A copy of the secret key
+     */
+    exportSecretKey() {
+        return this.#secretKey.slice();
+    }
+    /**
+     * Exports the public key for the given coin type and key type
+     * @param coinType coin type
+     * @param keyType key type
+     * @returns the public key
+     */
+    exportPublicKey(coinType, keyType) {
+        let publicKeyBytes;
+        switch (keyType) {
+            case FacilitatorKeyType.SECP256K1:
+                publicKeyBytes = SECP256K1.sk_to_pk(this.#secretKey, true);
+                break;
+            // case FacilitatorKeyType.ED25519:
+            //     publicKeyBytes =
+            //     break;
+            default:
+                throw new Error('Invalid key type');
+        }
+        return {
+            coinType,
+            keyType,
+            publicKeyBytes: bytesToHex(publicKeyBytes),
+        };
+    }
+    /**
+     * Returns a Viem {@link Account} instance for signing EVM transactions from this account
+     * @returns A Promise that resolves to the signer
+     */
+    evmSigner() {
+        return Promise.resolve(privateKeyToAccount(bytesToHex(this.#secretKey)));
+    }
+    /**
+     * Returns a CosmJS {@link OfflineAminoSigner} instance for signing Cosmos transactions from this account
+     * @param bech32Prefix - the bech32 prefix for the desired chain
+     * @returns A Promise that resolves to the signer
+     */
+    async cosmosSigner(bech32Prefix) {
+        return await Secp256k1Wallet.fromKey(this.#secretKey, bech32Prefix);
+    }
+    /**
+     * Signs a proxy authorization instruction
+     * @param authorization the proxy authorization instruction to sign
+     * @returns the signature
+     */
+    async signProxyAuthorization(authorization) {
+        // create local account
+        const account = privateKeyToAccount(bytesToHex(this.#secretKey));
+        // sign message
+        return await account.signMessage({
+            message: bytesToHex(stringToBytes(JSON.stringify(normalizeJson(authorization.content)))),
+        });
+    }
+    /**
+     * Encrypts the secret key with the given public key
+     * @param args encryption arguments
+     * @returns the encrypted secret key
+     */
+    async encryptSecretKeyForProxy(args) {
+        // import secret key
+        const privKey = await crypto.subtle.importKey('raw', this.#secretKey, { name: 'AES-GCM' }, true, ['encrypt']);
+        // normalize public key
+        const proxyPubKey = normalizeBytesish(args.proxyPublicKey);
+        // generate key pair for encryption
+        const encPrivKey = SECP256K1.gen_sk();
+        const encPubKey = SECP256K1.sk_to_pk(encPrivKey);
+        // derive shared secret
+        const sharedSecret = SECP256K1.ecdh(encPrivKey, proxyPubKey);
+        // zeroize secret key bytes
+        encPrivKey.fill(0);
+        // import secret as wrapping key
+        const ecdhPrivKey = await crypto.subtle.importKey('raw', sharedSecret, 'AES-KW', false, ['wrapKey']);
+        // zeroize shared secret bytes
+        sharedSecret.fill(0);
+        // encrypt secret key
+        const wrappedKey = await crypto.subtle.wrapKey('raw', privKey, ecdhPrivKey, 'AES-KW');
+        // export
+        return {
+            wrappedKey: toBase64(new Uint8Array(wrappedKey)),
+            encryptionPublicKey: toBase64(encPubKey),
+        };
+    }
+}