@silentswap/sdk 0.0.1

package/dist/sdk.d.ts

@@ -0,0 +1,161 @@
+import type { Base64, SignInMessage } from './types/core.js';
+import type { QuoteResponse } from './types/api.js';
+import type { Hex } from 'viem';
+/**
+ * Creates a SIWE message for authentication with SilentSwap
+ * @param user - user's EVM address
+ * @param nonce - nonce from the server (base58)
+ * @returns SIWE message
+ */
+export declare function createSignInMessage(user: Hex, nonce: string): SignInMessage;
+/**
+ * Creates an EIP-712 document for a SilentSwap order
+ * @param quote - quote response
+ * @returns EIP-712 document
+ */
+export declare function createEip712DocForOrder(quote: QuoteResponse): {
+    types: {
+        readonly EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }];
+        readonly Order: readonly [{
+            readonly name: "quoteId";
+            readonly type: "string";
+        }, {
+            readonly name: "quote";
+            readonly type: "Quote";
+        }];
+        readonly Quote: readonly [{
+            readonly name: "signer";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "privacy";
+            readonly type: "string";
+        }, {
+            readonly name: "deposit";
+            readonly type: "uint256";
+        }, {
+            readonly name: "fee";
+            readonly type: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "Output[]";
+        }, {
+            readonly name: "metadata";
+            readonly type: "Metadata";
+        }];
+        readonly Output: readonly [{
+            readonly name: "method";
+            readonly type: "string";
+        }, {
+            readonly name: "asset";
+            readonly type: "string";
+        }, {
+            readonly name: "facilitatorPublicKeys";
+            readonly type: "Facilitator[]";
+        }, {
+            readonly name: "recipient";
+            readonly type: "string";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "extra";
+            readonly type: "string";
+        }];
+        readonly Facilitator: readonly [{
+            readonly name: "coinType";
+            readonly type: "string";
+        }, {
+            readonly name: "keyType";
+            readonly type: "string";
+        }, {
+            readonly name: "publicKeyBytes";
+            readonly type: "bytes";
+        }];
+        readonly Metadata: readonly [{
+            readonly name: "notaryContract";
+            readonly type: "NotaryContract";
+        }];
+        readonly NotaryContract: readonly [{
+            readonly name: "chainId";
+            readonly type: "string";
+        }, {
+            readonly name: "contractAddress";
+            readonly type: "string";
+        }, {
+            readonly name: "encryptionPk33";
+            readonly type: "string";
+        }, {
+            readonly name: "signerAddress";
+            readonly type: "address";
+        }, {
+            readonly name: "sessionProof";
+            readonly type: "string";
+        }];
+    };
+    domain: {
+        readonly name: "SilentSwap v2";
+        readonly version: "1";
+        readonly chainId: 43114;
+    };
+    primaryType: "Order";
+    message: {
+        quoteId: string;
+        quote: {
+            nonce: string;
+            signer: Hex;
+            privacy: import("./order.js").PrivacySetting;
+            deposit: import("./types/core.js").IntStr;
+            fee: import("./types/core.js").IntStr;
+            outputs: Array<import("./order.js").OrderOutputArg>;
+            metadata: import("./order.js").OrderMetadata;
+        };
+    };
+};
+/**
+ * Creates an EIP-712 document for a SilentSwap wallet generator
+ * @param token - token to generate a wallet for
+ * @returns EIP-712 document
+ */
+export declare function createEip712DocForWalletGeneration(token: string): {
+    types: {
+        readonly EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }];
+        readonly WalletGeneration: readonly [{
+            readonly name: "description";
+            readonly type: "string";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }];
+    };
+    domain: {
+        readonly name: "SilentSwap v2";
+        readonly version: "1";
+        readonly chainId: 43114;
+    };
+    primaryType: "WalletGeneration";
+    message: {
+        description: "Securely create a temporary, anonymous wallet for SilentSwap use only.";
+        token: Base64;
+    };
+};

package/dist/sdk.js

@@ -0,0 +1,57 @@
+import { createSiweMessage } from 'viem/siwe';
+import { EIP712_DOMAIN_ORDER_DEFAULT, EIP712_TYPES_ORDER, EIP712_TYPES_WALLET_GENERATION } from './order.js';
+/**
+ * Creates a SIWE message for authentication with SilentSwap
+ * @param user - user's EVM address
+ * @param nonce - nonce from the server (base58)
+ * @returns SIWE message
+ */
+export function createSignInMessage(user, nonce) {
+    // create params
+    const params = {
+        domain: 'app.silentswap.com',
+        address: user,
+        statement: 'Sign in with Ethereum to SilentSwap',
+        uri: 'https://app.silentswap.com',
+        version: '1',
+        chainId: 1, // always Ethereum mainnet
+        nonce: nonce,
+    };
+    // prepare and return the message for signing
+    return {
+        params,
+        message: createSiweMessage(params),
+    };
+}
+/**
+ * Creates an EIP-712 document for a SilentSwap order
+ * @param quote - quote response
+ * @returns EIP-712 document
+ */
+export function createEip712DocForOrder(quote) {
+    return {
+        types: EIP712_TYPES_ORDER,
+        domain: EIP712_DOMAIN_ORDER_DEFAULT,
+        primaryType: 'Order',
+        message: {
+            quoteId: quote.quoteId,
+            quote: { ...quote.quote },
+        },
+    };
+}
+/**
+ * Creates an EIP-712 document for a SilentSwap wallet generator
+ * @param token - token to generate a wallet for
+ * @returns EIP-712 document
+ */
+export function createEip712DocForWalletGeneration(token) {
+    return {
+        types: EIP712_TYPES_WALLET_GENERATION,
+        domain: EIP712_DOMAIN_ORDER_DEFAULT,
+        primaryType: 'WalletGeneration',
+        message: {
+            description: 'Securely create a temporary, anonymous wallet for SilentSwap use only.',
+            token: token,
+        },
+    };
+}

package/dist/signer-adapters/viem.d.ts

@@ -0,0 +1,16 @@
+import type { EvmTransaction } from '../types/core.js';
+import type { Account, Client, PrepareTransactionRequestParameters, PublicActions, WalletActions } from 'viem';
+import type { EvmSigner } from '../types/sdk.js';
+/**
+ * Creates an EvmSigner from a viem Account and Client.
+ * @param account the viem Account
+ * @param client the viem Client (must implement {@link PublicActions} and {@link WalletActions})
+ * @returns an {@link EvmSigner}
+ */
+export declare function createViemSigner(account: Account, client: Client & PublicActions & WalletActions): EvmSigner;
+/**
+ * Parses an EvmTransaction into a viem .
+ * @param tx the EvmTransaction to parse
+ * @returns a viem PrepareTransactionRequestParameters
+ */
+export declare function parseTransactionRequestForViem(tx: EvmTransaction): PrepareTransactionRequestParameters<undefined, Account, undefined, undefined>;

package/dist/signer-adapters/viem.js

@@ -0,0 +1,30 @@
+/**
+ * Creates an EvmSigner from a viem Account and Client.
+ * @param account the viem Account
+ * @param client the viem Client (must implement {@link PublicActions} and {@link WalletActions})
+ * @returns an {@link EvmSigner}
+ */
+export function createViemSigner(account, client) {
+    return {
+        address: account.address,
+        getTransactionCount: async () => client.getTransactionCount({ address: account.address }),
+        signEip191Message: message => client.signMessage({ account, message }),
+        signEip712TypedData: data => client.signTypedData({ account, ...data }),
+    };
+}
+/**
+ * Parses an EvmTransaction into a viem .
+ * @param tx the EvmTransaction to parse
+ * @returns a viem PrepareTransactionRequestParameters
+ */
+export function parseTransactionRequestForViem(tx) {
+    return {
+        chainId: Number(tx.chainId),
+        to: tx.target,
+        data: tx.data,
+        nonce: tx.nonce,
+        value: BigInt(tx.value ?? 0),
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? BigInt(tx.maxPriorityFeePerGas) : undefined,
+        maxFeePerGas: tx.maxFeePerGas ? BigInt(tx.maxFeePerGas) : undefined,
+    };
+}

package/dist/types/api.d.ts

@@ -0,0 +1,145 @@
+import type { Hex } from 'viem';
+import type { Base58, Base64, EvmTransaction, IntStr } from './core.js';
+import type { AuthorizationInstruction, AuthorizationReply, FacilitatorInstruction, FacilitatorReply, OrderOutputArg, PrivacySetting, Quote } from '../order.js';
+/**
+ * API response schema for /nonce endpoint
+ */
+export type NonceResponse = {
+    readonly nonce: Base64;
+};
+/**
+ * API request body schema for /authenticate endpoint
+ */
+export type AuthRequest = {
+    /**
+     * SIWE message and signature
+     */
+    siwe: {
+        message: string;
+        signature: Hex;
+    };
+};
+/**
+ * API response schema for /authenticate endpoint
+ */
+export type AuthResponse = {
+    /**
+     * Signer address
+     */
+    readonly address: Hex;
+    /**
+     * Token to be used for generating a secret seed
+     */
+    readonly secretToken: Base64;
+    /**
+     * Denotes when the SIWE signature expires
+     */
+    readonly authExpires: number;
+};
+/**
+ * API request body schema for /quote endpoint
+ */
+export type QuoteRequest = {
+    /**
+     * Address of the quote signer
+     */
+    signer: Hex;
+    /**
+     * Privacy setting
+     */
+    privacy?: PrivacySetting;
+    /**
+     * If ommitted, computes sum of `.outputs[i].value` and adds fees
+     */
+    deposit?: IntStr;
+    /**
+     * Optional 33-byte or 65-byte public key to use when deriving shared session secret
+     */
+    trustPublicKeyBytes?: Base64;
+    /**
+     * Output specifications
+     */
+    outputs: OrderOutputArg[];
+};
+/**
+ * API response schema for /quote endpoint
+ */
+export type QuoteResponse = {
+    /**
+     * Quote ID required when placing an order
+     */
+    readonly quoteId: Base64;
+    /**
+     * Quote object contains details of the quote
+     */
+    readonly quote: Quote;
+    /**
+     * Array of authorizations required to be signed before placing an order
+     */
+    readonly authorizations: Array<AuthorizationInstruction>;
+    /**
+     * Array of facilitator instructions required to be signed before placing an order
+     */
+    readonly facilitators: Array<FacilitatorInstruction>;
+};
+/**
+ * API request body schema for /order endpoint
+ */
+export type OrderRequest = Omit<QuoteResponse, 'authorizations' | 'facilitators'> & {
+    /**
+     * EIP-712 domain
+     */
+    eip712Domain: {
+        name: 'SilentSwap v2';
+        version?: IntStr;
+        chainId: number;
+        verifyingContract?: Hex;
+    };
+    /**
+     * Signature of the EIP-712 order document
+     */
+    signature: Hex;
+    /**
+     * Array of signed authorizations
+     */
+    authorizations: Array<AuthorizationReply>;
+    /**
+     * Array of signed facilitator instructions
+     */
+    facilitators: Array<FacilitatorReply>;
+};
+/**
+ * Parameters for the deposit transaction
+ */
+export type DepositParams<B extends bigint | IntStr = bigint> = {
+    signer: Hex;
+    orderId: Hex;
+    notary: Hex;
+    approver: Hex;
+    orderApproval: Hex;
+    approvalExpiration: B;
+    duration: B;
+    domainSepHash: Hex;
+    payloadHash: Hex;
+    typedDataSignature: Hex;
+    receiveAuthorization: Hex;
+};
+/**
+ * API response schema for /order endpoint
+ */
+export interface OrderResponse {
+    /**
+     * Deposit transaction
+     */
+    transaction: EvmTransaction<DepositParams<IntStr>>;
+    /**
+     * Order response object
+     */
+    response: {
+        approver: Hex;
+        orderApproval: Hex;
+        approvalExpiration: number;
+        orderId: Base58;
+        order: Quote;
+    };
+}

package/dist/types/api.js

@@ -0,0 +1 @@
+export {};

package/dist/types/authorization.d.ts

@@ -0,0 +1,245 @@
+import type { Hex } from 'viem';
+import type { Base64, IntStr, Json } from './core.js';
+import type { AbiFunction, TypedDataDomain } from 'abitype';
+/**
+ * For including the `entry_required` matcher
+ */
+type IncludeRequired<M extends object> = M & {
+    entry_optional?: boolean;
+};
+/**
+ * Matches any value
+ */
+export type MatcherAny = IncludeRequired<{
+    any_type: 'any' | 'boolean' | 'uint32' | 'uint256' | 'string' | 'array' | 'struct';
+}> | {
+    entry_absent: true;
+};
+/**
+ * Matches a boolean
+ */
+export type MatcherBoolean = MatcherAny | IncludeRequired<{
+    boolean_const: boolean;
+}>;
+/**
+ * Matches a uint32
+ */
+export type MatcherUint32<L extends number = number> = MatcherAny | IncludeRequired<{
+    uint32_const: L;
+} | {
+    uint32_enum: L[];
+} | {
+    uint32_range: readonly [L, L | 'MAX'];
+}>;
+/**
+ * Matches a string
+ */
+export type MatcherString<S extends string = string> = MatcherAny | IncludeRequired<{
+    string_const: S;
+} | {
+    string_enum: S[];
+}>;
+/**
+ * Matches a uint128
+ */
+export type MatcherUint128 = MatcherAny | IncludeRequired<{
+    uint128_const: IntStr;
+} | {
+    uint128_enum: IntStr[];
+} | {
+    uint128_range: readonly [IntStr, IntStr | 'MAX'];
+}>;
+/**
+ * Matches a uint256
+ */
+export type MatcherUint256 = MatcherAny | IncludeRequired<{
+    uint256_const: IntStr;
+} | {
+    uint256_enum: IntStr[];
+} | {
+    uint256_range: readonly [IntStr, IntStr | 'MAX'];
+}>;
+/**
+ * Matches an Amino array
+ */
+export type MatcherAminoArray = MatcherAny | IncludeRequired<({
+    array_unordered?: boolean;
+    array_items: {
+        item_optional?: boolean;
+        item_match: UnionAminoValue;
+    }[];
+} | {
+    array_json: MatcherString<Json>;
+})>;
+/**
+ * Matches an Amino struct
+ */
+export type MatcherAminoStruct = IncludeRequired<{
+    struct_entries: Record<string, UnionAminoValue>;
+} | {
+    struct_json: MatcherString<Json>;
+}>;
+/**
+ * Union of matchers available to Amino
+ */
+export type UnionAminoValue = MatcherBoolean | MatcherString | MatcherUint32 | MatcherUint128 | MatcherAminoArray | MatcherAminoStruct;
+/**
+ * Matches an EVM address
+ */
+export type MatcherEvmAddress = {
+    address_0x: MatcherString<Hex>;
+};
+/**
+ * Matches an EVM bytes
+ */
+export type MatcherEvmBytes<L extends number = number> = {
+    bytes_len: MatcherUint32<L>;
+    bytes_hex: MatcherString;
+};
+/**
+ * Matches an EVM struct
+ */
+export type MatcherEvmStruct<S extends Record<string, object> = Record<string, UnionEvmValue>> = {
+    struct_entries: S;
+} | {
+    struct_json: MatcherString<Json>;
+};
+/**
+ * Union of matchers available to EVM
+ */
+export type UnionEvmValuePrimitives = MatcherString | MatcherUint256 | MatcherEvmAddress | MatcherEvmBytes;
+/**
+ * Union of matchers available to EVM
+ */
+export type UnionEvmValue = UnionEvmValuePrimitives | MatcherEvmStruct<Record<string, UnionEvmValuePrimitives>>;
+/**
+ * Helper utility type to vaidate a declared matcher type for JSON arrays
+ */
+type ImplementsMatcherAminoArray<S extends MatcherAminoArray> = S;
+/**
+ * Helper utility type to vaidate a declared matcher type for JSON structs
+ */
+type ImplementsMatcherAminoStruct<S extends MatcherAminoStruct> = S;
+/**
+ * Arbitrary Cosmos Amino
+ */
+export type ProxyAuthMsgCosmosAmino = {
+    type: 'cosmos/amino-stdsigndoc';
+    signdoc: {
+        chain_id: MatcherString;
+        account_number: MatcherUint128;
+        sequence: MatcherUint128;
+        msgs: ImplementsMatcherAminoArray<{
+            array_unordered?: boolean;
+            array_items: {
+                item_optional?: boolean;
+                item_match: {
+                    struct_entries: {
+                        type: MatcherString;
+                        value: MatcherAminoStruct;
+                    };
+                };
+            }[];
+        } | {
+            array_json: MatcherString<Json>;
+        }>;
+        fee: ImplementsMatcherAminoStruct<{
+            struct_entries: {
+                amount: {
+                    array_unordered?: false;
+                    array_items: {
+                        item_optional?: boolean;
+                        item_match: {
+                            struct_entries: {
+                                denom: MatcherString;
+                                amount: MatcherUint128;
+                            };
+                        };
+                    }[];
+                };
+                gas: MatcherUint128;
+            };
+        } | {
+            struct_json: MatcherString<Json>;
+        }>;
+        memo: MatcherString;
+    };
+    metadata?: undefined | {
+        secret_wasm_seed?: Base64;
+        secret_wasm_nonce?: Base64;
+    };
+};
+/**
+ * EVM transaction
+ */
+export type ProxyAuthMsgEvmTx = {
+    type: 'evm/tx';
+    to: MatcherEvmAddress;
+    value: MatcherUint256;
+    chainId: MatcherUint256;
+    nonce: MatcherUint256;
+    data: MatcherEvmBytes | {
+        functionAbi: Omit<AbiFunction, 'constant' | 'gas' | 'outputs' | 'payable' | 'stateMutability'>;
+        arguments: MatcherEvmStruct;
+    };
+    gas: {
+        type0: {
+            gasLimit: MatcherUint256;
+            gasPrice: MatcherUint256;
+        };
+    } | {
+        type2: {
+            gasLimit: MatcherUint256;
+            maxFeePerGas: MatcherUint256;
+            maxPriorityFeePerGas: MatcherUint256;
+        };
+    };
+};
+/**
+ * EVM EIP-712 typed data
+ */
+export type ProxyAuthMsgEvmEip712 = {
+    type: 'evm/eip712';
+    domain: MatcherEvmStruct<{
+        name?: MatcherString;
+        version?: MatcherString;
+        chainId?: MatcherUint256;
+        verifyingContract?: MatcherEvmAddress;
+        salt?: MatcherEvmBytes<32>;
+    }>;
+    types: MatcherEvmStruct<{
+        EIP712Domain: object;
+    } & Record<string, object>>;
+    primaryType?: MatcherString;
+    message: MatcherEvmStruct;
+};
+export type ProxyAuthMsg = ProxyAuthMsgCosmosAmino | ProxyAuthMsgEvmTx | ProxyAuthMsgEvmEip712;
+export type ProxyAuthContent = {
+    description?: undefined | string;
+    facilitator_pk: Hex;
+    executor_pk33: Base64;
+    message: ProxyAuthMsg;
+};
+export type ProxyAuthInstruction = {
+    id: Base64;
+    content: ProxyAuthContent;
+};
+export type ProxyAuthReply = ProxyAuthInstruction & {
+    signature: Hex;
+};
+export type ProxyAuthWrapper = {
+    content: ProxyAuthContent;
+    signatures: {
+        facilitator: Hex;
+        executor: Base64;
+    };
+};
+export type ProxyStructEvmEip712Config = {
+    domain: TypedDataDomain;
+};
+export type ProxyStructCosmWasmFeeConfig = {
+    denom: string;
+    gasPrice: number;
+    maxGasLimit: bigint;
+};
+export {};

package/dist/types/authorization.js

@@ -0,0 +1 @@
+export {};