@silentswap/sdk 0.0.1

package/dist/hd-facilitator-group.d.ts

@@ -0,0 +1,34 @@
+import { EnglishMnemonic } from '@cosmjs/crypto';
+import { FacilitatorAccount } from './facilitator-account.js';
+import type { FacilitatorInstruction, FacilitatorPublicKey, FacilitatorReply } from './order.js';
+import type { EncryptSecretKeyArgs } from './types/sdk.js';
+import type { CoinTypeStr, IntStr } from './types/core.js';
+export declare class HdFacilitatorGroup {
+    #private;
+    readonly accountIndex: number;
+    constructor(seed: Uint8Array, accountIndex: number);
+    /**
+     * Derives the facilitator account for the given BIP-44 coin type and index as in `m / purpose' / coin_type' / account' / change / address_index`
+     * @param coinType - SLIP-44 coin type (for the `coin_type` component of the BIP-44), '*' defaults to '0'
+     * @param addressIndex - `address_index` of the BIP-44
+     * @returns
+     */
+    account(coinType: number | CoinTypeStr, addressIndex: number | IntStr): Promise<FacilitatorAccount>;
+    exportPublicKeys(facilitatorCount: number, keySpecs: Omit<FacilitatorPublicKey, 'publicKeyBytes'>[]): Promise<FacilitatorPublicKey[][]>;
+    approveProxyAuthorizations(instructions: FacilitatorInstruction[], encryptArgs: EncryptSecretKeyArgs): Promise<FacilitatorReply[]>;
+}
+/**
+ * Exports a secret mnemonic seed phrase from the given entropy
+ * @param entropy - the secure entropy source to use
+ * @returns the English mnemonic seed phrase (24 words)
+ */
+export declare function exportSecretMnemonicFromEntropy(entropy: Uint8Array): Promise<EnglishMnemonic>;
+/**
+ * Creates a new hierarchical deterministic facilitator group of the given size from entropy, at some BIP-44 `account_index` offset
+ * @param entropy - the secure entropy source to use (should be derived deterministically so that accounts can be recovered)
+ * @param facilitatorCount - number of facilitators to create in this group, corresponds to number of order outputs
+ * @param orderIndex - increment for each new SilentSwap order; corresponds to the `account_index` in BIP-44
+ * @param password - optional password to use during mnemonic generation
+ * @returns
+ */
+export declare function createHdFacilitatorGroupFromEntropy(entropy: Uint8Array, orderIndex: number | bigint, password?: string): Promise<HdFacilitatorGroup>;

package/dist/hd-facilitator-group.js

@@ -0,0 +1,115 @@
+import { keccak256 } from 'viem';
+import { Bip39, Slip10, Slip10Curve, stringToPath } from '@cosmjs/crypto';
+import { FacilitatorAccount } from './facilitator-account.js';
+export class HdFacilitatorGroup {
+    accountIndex;
+    #seed;
+    constructor(seed, accountIndex) {
+        this.accountIndex = accountIndex;
+        // copy the bytes into a new section of memory so parent can zeroize original
+        this.#seed = seed.slice();
+    }
+    /**
+     * Derives the facilitator account for the given BIP-44 coin type and index as in `m / purpose' / coin_type' / account' / change / address_index`
+     * @param coinType - SLIP-44 coin type (for the `coin_type` component of the BIP-44), '*' defaults to '0'
+     * @param addressIndex - `address_index` of the BIP-44
+     * @returns
+     */
+    async account(coinType, addressIndex) {
+        // if global fallback type, use BTC (`0`)
+        if ('*' === coinType)
+            coinType = '0';
+        // derive BIP-32 nodem using BIP-44m for intended coin type at group's account index and given address index
+        const path = stringToPath(`m/44'/${coinType}'/${this.accountIndex}'/0/${addressIndex}`);
+        // export private key
+        const slip10Result = Slip10.derivePath(Slip10Curve.Secp256k1, this.#seed, path);
+        // create facilitator account
+        try {
+            return await new FacilitatorAccount(slip10Result.privkey);
+        }
+        // destroy the secret key
+        finally {
+            slip10Result.privkey.fill(0);
+        }
+    }
+    async exportPublicKeys(facilitatorCount, keySpecs) {
+        const exported = [];
+        for (let addrIndex = 0; addrIndex < facilitatorCount; addrIndex++) {
+            const pubKeys = [];
+            for (const spec of keySpecs) {
+                const account = await this.account(spec.coinType, addrIndex);
+                pubKeys.push(account.exportPublicKey(spec.coinType, spec.keyType));
+            }
+            exported.push(pubKeys);
+        }
+        return exported;
+    }
+    async approveProxyAuthorizations(instructions, encryptArgs) {
+        // each facilitator instruction
+        return await Promise.all(instructions.map(async (instruction, facilitatorIndex) => {
+            const accountsMap = {};
+            const exportedKeys = {};
+            // build mapping of public keys to accounts and exported private keys
+            for (const pubKey of instruction.publicKeys) {
+                const facilitatorPk = pubKey.publicKeyBytes;
+                // create facilitator account
+                const facilitator = accountsMap[facilitatorPk] = await this.account(pubKey.coinType, facilitatorIndex);
+                // encrypt its secret key and save to exports
+                exportedKeys[facilitatorPk] = await facilitator.encryptSecretKeyForProxy(encryptArgs);
+            }
+            // sign each authorization
+            const proxyAuthorizations = await Promise.all(instruction.proxyAuthorizations
+                .map(async (authorization, authIndex) => {
+                // ref facilitator's public key
+                const facilitatorPk = authorization.content.facilitator_pk;
+                // look up account
+                const account = accountsMap[facilitatorPk];
+                if (!account) {
+                    throw Error(`Instruction at .facilitators[${facilitatorIndex}].proxyAuthorizations[${authIndex}] depends on public key ${facilitatorPk} which wasn't explicitly expressed in public keys map for this output`);
+                }
+                // sign proxy auth
+                return {
+                    ...authorization,
+                    signature: await account.signProxyAuthorization(authorization),
+                };
+            }));
+            return {
+                proxyAuthorizations,
+                exportedKeys,
+            };
+        }));
+    }
+}
+/**
+ * Exports a secret mnemonic seed phrase from the given entropy
+ * @param entropy - the secure entropy source to use
+ * @returns the English mnemonic seed phrase (24 words)
+ */
+export async function exportSecretMnemonicFromEntropy(entropy) {
+    // get keccak256 hash of the entropy
+    const hash = keccak256(entropy, 'bytes');
+    // encode hash as mnemonic
+    return Bip39.encode(hash);
+}
+/**
+ * Creates a new hierarchical deterministic facilitator group of the given size from entropy, at some BIP-44 `account_index` offset
+ * @param entropy - the secure entropy source to use (should be derived deterministically so that accounts can be recovered)
+ * @param facilitatorCount - number of facilitators to create in this group, corresponds to number of order outputs
+ * @param orderIndex - increment for each new SilentSwap order; corresponds to the `account_index` in BIP-44
+ * @param password - optional password to use during mnemonic generation
+ * @returns
+ */
+export async function createHdFacilitatorGroupFromEntropy(entropy, orderIndex, password) {
+    // generate mnemonic from entropy
+    const mnemonic = await exportSecretMnemonicFromEntropy(entropy);
+    // generate seed from mnemonic
+    const seed = await Bip39.mnemonicToSeed(mnemonic, password);
+    // create group from seed
+    try {
+        return new HdFacilitatorGroup(seed, Number(orderIndex));
+    }
+    // zeroize original seed bytes
+    finally {
+        seed.fill(0);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { SilentSwapClientConfig, SilentSwapClient, } from './client.js';
+export type * from './types/api.js';
+export type { EvmSigner } from './types/sdk.js';
+export type * from './order.js';
+export { createSilentSwapClient, } from './client.js';
+export * from './constants.js';
+export { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, } from './sdk.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createSilentSwapClient, } from './client.js';
+export * from './constants.js';
+export { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, } from './sdk.js';

package/dist/order.d.ts

@@ -0,0 +1,277 @@
+import type { Hex } from 'viem';
+import type { ExportedFacilitator, TypedDataDocument } from './types/sdk.js';
+import type { Base64, Caip19, CoinTypeStr, IntStr } from './types/core.js';
+import type { ProxyAuthInstruction, ProxyAuthReply } from './types/authorization.js';
+import type { QuoteResponse } from './types/api.js';
+import type { AbiParameter, ParseAbiParameters, TypedDataDomain } from 'abitype';
+export declare enum DeliveryMethod {
+    SNIP = "SNIP"
+}
+export declare enum PrivacySetting {
+    LEAST_PRIVACY_FASTEST_SWAP = "LEAST_PRIVACY_FASTEST_SWAP",
+    WEAK = "WEAK",
+    FAIR = "FAIR",
+    STRONG = "STRONG",
+    EXTREME = "EXTREME"
+}
+export declare enum FacilitatorKeyType {
+    SECP256K1 = "SECP256K1",
+    ED25519 = "ED25519"
+}
+export type FacilitatorPublicKey = {
+    coinType: CoinTypeStr;
+    keyType: FacilitatorKeyType;
+    publicKeyBytes: Hex;
+};
+export declare const PublicKeyArgGroups: {
+    readonly GENERIC: readonly [{
+        readonly coinType: "*";
+        readonly keyType: FacilitatorKeyType.SECP256K1;
+    }, {
+        readonly coinType: "60";
+        readonly keyType: FacilitatorKeyType.SECP256K1;
+    }, {
+        readonly coinType: "118";
+        readonly keyType: FacilitatorKeyType.SECP256K1;
+    }, {
+        readonly coinType: "529";
+        readonly keyType: FacilitatorKeyType.SECP256K1;
+    }];
+};
+type Eip712DocumentParams = {
+    domainParams: readonly AbiParameter[];
+    customTypes: Record<string, readonly AbiParameter[]>;
+    primaryType: string;
+    domain: TypedDataDomain;
+    message: object;
+};
+export type Eip712Document<P extends Eip712DocumentParams = Eip712DocumentParams> = {
+    types: {
+        EIP712Domain?: P['domainParams'];
+    } & P['customTypes'];
+    primaryType: P['primaryType'];
+    domain: P['domain'];
+    message: P['message'];
+};
+export type Eip3009TypedData = Eip712Document<{
+    domainParams: ParseAbiParameters<'string name, string version, uint256 chainId, address verifyingContract'>;
+    customTypes: {
+        ReceiveWithAuthorization: ParseAbiParameters<'address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce'>;
+    };
+    primaryType: 'ReceiveWithAuthorization';
+    domain: {
+        name: 'USD Coin';
+        version: '2';
+        chainId: number;
+        verifyingContract: Hex;
+    };
+    message: {
+        from: Hex;
+        to: Hex;
+        value: IntStr;
+        validAfter: IntStr;
+        validBefore: IntStr;
+        nonce: Hex;
+    };
+}>;
+export type AuthorizationInstruction = {
+    id: Base64;
+    address: Hex;
+} & (({
+    hash?: Hex;
+} & ({
+    type: 'eip3009_deposit';
+    eip712: Eip3009TypedData;
+})));
+export type AuthorizationReply = AuthorizationInstruction & {
+    signature: Hex;
+};
+export type FacilitatorInstruction = {
+    publicKeys: FacilitatorPublicKey[];
+    proxyAuthorizations: ProxyAuthInstruction[];
+};
+export type FacilitatorReply = {
+    proxyAuthorizations: ProxyAuthReply[];
+    exportedKeys: Record<Hex, ExportedFacilitator>;
+};
+export type OrderOutputArg = {
+    /**
+     * Funds delivery method
+     */
+    method: DeliveryMethod;
+    /**
+     * CAIP-19 token ID
+     */
+    asset: Caip19;
+    /**
+     * Facilitator public keys
+     */
+    facilitatorPublicKeys: FacilitatorPublicKey[];
+    /**
+     * Recipient address
+     */
+    recipient: string;
+    /**
+     * Value
+     */
+    value: IntStr;
+    /**
+     * Extra optional settings
+     */
+    extra?: {
+        /**
+         * Swap settings
+         */
+        swap?: {
+            /**
+             * Slippage in basis points
+             */
+            slippageBps?: IntStr;
+            /**
+             * Minimum amount of output token to receive in base units
+             */
+            minimumAmount?: IntStr;
+            /**
+             * If present, performs a swap for exact amount out and sets the designated address as the refundee for overflow
+             */
+            exactAmountOutRefundee?: string;
+        };
+    };
+};
+export type OrderMetadata = {
+    notaryContract: {
+        chainId: 'secret-4';
+        contractAddress: `secret1${string}`;
+        encryptionPk33: Base64;
+        signerAddress: Hex;
+        sessionProof: Base64;
+    };
+};
+export type Quote = {
+    nonce: string;
+    signer: Hex;
+    privacy: PrivacySetting;
+    deposit: IntStr;
+    fee: IntStr;
+    outputs: Array<OrderOutputArg>;
+    metadata: OrderMetadata;
+};
+export type Order = {
+    orderId: string;
+} & Quote;
+export declare const EIP712_TYPES_ORDER: {
+    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";
+    }];
+};
+export declare const EIP712_TYPES_WALLET_GENERATION: {
+    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";
+    }];
+};
+export declare const EIP712_DOMAIN_ORDER_DEFAULT: {
+    readonly name: "SilentSwap v2";
+    readonly version: "1";
+    readonly chainId: 43114;
+};
+export declare function quoteResponseToEip712Document(quoteResponse: QuoteResponse): TypedDataDocument<typeof EIP712_DOMAIN_ORDER_DEFAULT>;
+export {};

package/dist/order.js

@@ -0,0 +1,111 @@
+export var DeliveryMethod;
+(function (DeliveryMethod) {
+    DeliveryMethod["SNIP"] = "SNIP";
+})(DeliveryMethod || (DeliveryMethod = {}));
+export var PrivacySetting;
+(function (PrivacySetting) {
+    PrivacySetting["LEAST_PRIVACY_FASTEST_SWAP"] = "LEAST_PRIVACY_FASTEST_SWAP";
+    PrivacySetting["WEAK"] = "WEAK";
+    PrivacySetting["FAIR"] = "FAIR";
+    PrivacySetting["STRONG"] = "STRONG";
+    PrivacySetting["EXTREME"] = "EXTREME";
+})(PrivacySetting || (PrivacySetting = {}));
+export var FacilitatorKeyType;
+(function (FacilitatorKeyType) {
+    FacilitatorKeyType["SECP256K1"] = "SECP256K1";
+    FacilitatorKeyType["ED25519"] = "ED25519";
+})(FacilitatorKeyType || (FacilitatorKeyType = {}));
+export const PublicKeyArgGroups = {
+    GENERIC: [
+        {
+            coinType: '*',
+            keyType: FacilitatorKeyType.SECP256K1,
+        },
+        {
+            coinType: '60',
+            keyType: FacilitatorKeyType.SECP256K1,
+        },
+        {
+            coinType: '118',
+            keyType: FacilitatorKeyType.SECP256K1,
+        },
+        // {
+        //     coinType: '501',
+        //     keyType: FacilitatorKeyType.ED25519,
+        // },
+        {
+            coinType: '529',
+            keyType: FacilitatorKeyType.SECP256K1,
+        },
+    ],
+};
+export const EIP712_TYPES_ORDER = {
+    EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+    ],
+    Order: [
+        { name: 'quoteId', type: 'string' },
+        { name: 'quote', type: 'Quote' },
+    ],
+    Quote: [
+        { name: 'signer', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'privacy', type: 'string' },
+        { name: 'deposit', type: 'uint256' },
+        { name: 'fee', type: 'uint256' },
+        { name: 'outputs', type: 'Output[]' },
+        { name: 'metadata', type: 'Metadata' },
+    ],
+    Output: [
+        { name: 'method', type: 'string' },
+        { name: 'asset', type: 'string' },
+        { name: 'facilitatorPublicKeys', type: 'Facilitator[]' },
+        { name: 'recipient', type: 'string' },
+        { name: 'value', type: 'uint256' },
+        { name: 'extra', type: 'string' },
+    ],
+    Facilitator: [
+        { name: 'coinType', type: 'string' },
+        { name: 'keyType', type: 'string' },
+        { name: 'publicKeyBytes', type: 'bytes' },
+    ],
+    Metadata: [
+        { name: 'notaryContract', type: 'NotaryContract' },
+    ],
+    NotaryContract: [
+        { name: 'chainId', type: 'string' },
+        { name: 'contractAddress', type: 'string' },
+        { name: 'encryptionPk33', type: 'string' },
+        { name: 'signerAddress', type: 'address' },
+        { name: 'sessionProof', type: 'string' },
+    ],
+};
+export const EIP712_TYPES_WALLET_GENERATION = {
+    EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+    ],
+    WalletGeneration: [
+        { name: 'description', type: 'string' },
+        { name: 'token', type: 'string' },
+    ],
+};
+export const EIP712_DOMAIN_ORDER_DEFAULT = {
+    name: 'SilentSwap v2',
+    version: '1',
+    chainId: 43114,
+};
+export function quoteResponseToEip712Document(quoteResponse) {
+    return {
+        domain: EIP712_DOMAIN_ORDER_DEFAULT,
+        types: EIP712_TYPES_ORDER,
+        primaryType: 'Order',
+        message: {
+            quoteId: quoteResponse.quoteId,
+            quote: quoteResponse.quote,
+        },
+    };
+}