@stellar-broker/client 0.4.0 → 0.5.0

package/src/quote-request.js

@@ -1,61 +1,57 @@
-import {StrKey} from '@stellar/stellar-sdk'
-import errors from './errors.js'
-import {parseAsset} from './asset.js'
-
-/**
- * @typedef {object} SwapQuoteParams
- * @property {string} sellingAsset - Asset to sell
- * @property {string} buyingAsset - Asset to buy
- * @property {string} [sellingAmount] - Amount of selling asset
- * @property {string} [buyingAmount] - Amount of buying asset
- * @property {number} [slippageTolerance] - Swap slippage tolerance (0.02 by default - 2%)
- * @property {string} [destination] - Trader account address
- */
-
-/**
- * @param {SwapQuoteParams} params
- * @return {SwapQuoteParams}
- */
-export function validateQuoteRequest(params) {
-    const {
-        destination, sellingAsset, selling_asset, buyingAsset, buying_asset, sellingAmount, selling_amount,
-        buyingAmount, buying_amount, slippageTolerance, slippage_tolerance, ...other
-    } = params
-    const res = {
-        sellingAsset: parseAsset(sellingAsset || selling_asset, 'sellingAsset'),
-        buyingAsset: parseAsset(buyingAsset || buying_asset, 'buyingAsset'),
-        sellingAmount: parseAmount(sellingAmount || selling_amount, 'sellingAmount'),
-        buyingAmount: parseAmount(buyingAmount || buying_amount, 'buyingAmount'),
-        slippageTolerance: parseSlippageTolerance(slippageTolerance || slippage_tolerance || 0.02, 'slippageTolerance'),
-        flow: 'direct'
-    }
-    if (res.buyingAsset === res.sellingAsset)
-        throw errors.invalidQuoteParam('buyingAsset', 'Buying asset can\'t be the same as selling asset')
-    if (res.buyingAmount === undefined && res.sellingAmount === undefined)
-        throw errors.invalidQuoteParam('sellingAmount', 'Either "buyingAmount" or "sellingAmount" parameter is required')
-    if (res.buyingAmount !== undefined && res.sellingAmount !== undefined)
-        throw errors.invalidQuoteParam('sellingAmount', 'Parameters "buyingAmount" and "sellingAmount" are mutually exclusive')
-    Object.assign(res, other) //add remaining optional params
-    Object.freeze(res)
-    return res
-}
-
-function parseAmount(amount, parameter) {
-    if (amount === undefined)
-        return undefined
-    const parsed = parseFloat(amount)
-    if (isNaN(parsed) || parsed <= 0)
-        throw errors.invalidQuoteParam(parameter, 'Invalid asset amount: ' + amount)
-    return amount
-}
-
-function parseSlippageTolerance(src, parameter) {
-    const tolerance = parseFloat(src)
-    if (isNaN(tolerance))
-        throw errors.invalidQuoteParam(parameter, 'Invalid slippage tolerance, number expected')
-    if (tolerance < 0)
-        throw errors.invalidQuoteParam(parameter, 'Slippage tolerance is too small, expected value >= 0')
-    if (tolerance > 0.5)
-        throw errors.invalidQuoteParam(parameter, 'Slippage tolerance is too large, expected value < 0.5 (50%)')
-    return tolerance
+import errors from './errors.js'
+import {parseAsset} from './asset.js'
+
+/**
+ * @typedef {object} SwapQuoteParams
+ * @property {string} sellingAsset - Asset to sell
+ * @property {string} buyingAsset - Asset to buy
+ * @property {string} [sellingAmount] - Amount of selling asset
+ * @property {number} [slippageTolerance] - Swap slippage tolerance (0.02 by default - 2%)
+ */
+
+/**
+ * @param {SwapQuoteParams} params
+ * @return {SwapQuoteParams}
+ */
+export function validateQuoteRequest(params) {
+    const {
+        sellingAsset, selling_asset, buyingAsset, buying_asset, sellingAmount, selling_amount,
+        buyingAmount, buying_amount, slippageTolerance, slippage_tolerance, ...other
+    } = params
+    const res = {
+        sellingAsset: parseAsset(sellingAsset || selling_asset, 'sellingAsset'),
+        buyingAsset: parseAsset(buyingAsset || buying_asset, 'buyingAsset'),
+        sellingAmount: parseAmount(sellingAmount || selling_amount, 'sellingAmount'),
+        //buyingAmount: parseAmount(buyingAmount || buying_amount, 'buyingAmount'),
+        slippageTolerance: parseSlippageTolerance(slippageTolerance || slippage_tolerance || 0.02, 'slippageTolerance')
+    }
+    if (res.buyingAsset === res.sellingAsset)
+        throw errors.invalidQuoteParam('buyingAsset', 'Buying asset can\'t be the same as selling asset')
+    if (res.sellingAmount === undefined)
+        throw errors.invalidQuoteParam('sellingAmount', 'Parameter "sellingAmount" parameter is required')
+    /*if (res.buyingAmount !== undefined && res.sellingAmount !== undefined)
+        throw errors.invalidQuoteParam('sellingAmount', 'Parameters "buyingAmount" and "sellingAmount" are mutually exclusive')*/
+    Object.assign(res, other) //add remaining optional params
+    Object.freeze(res)
+    return res
+}
+
+function parseAmount(amount, parameter) {
+    if (amount === undefined)
+        return undefined
+    const parsed = parseFloat(amount)
+    if (isNaN(parsed) || parsed <= 0)
+        throw errors.invalidQuoteParam(parameter, 'Invalid asset amount: ' + amount)
+    return amount
+}
+
+function parseSlippageTolerance(src, parameter) {
+    const tolerance = parseFloat(src)
+    if (isNaN(tolerance))
+        throw errors.invalidQuoteParam(parameter, 'Invalid slippage tolerance, number expected')
+    if (tolerance < 0)
+        throw errors.invalidQuoteParam(parameter, 'Slippage tolerance is too small, expected value >= 0')
+    if (tolerance > 0.5)
+        throw errors.invalidQuoteParam(parameter, 'Slippage tolerance is too large, expected value < 0.5 (50%)')
+    return tolerance
 }

package/src/tx-processor.js

@@ -1,162 +1,134 @@
-import {hash, Keypair, nativeToScVal, StrKey, TransactionBuilder, xdr} from '@stellar/stellar-sdk'
-import errors from './errors.js'
-
-/**
- * @param {StellarBrokerClient} client
- * @param {{xdr: string, hash: string, networkFee: string, [confirmed]: boolean}} txRequest
- * @return {Promise<string>}
- */
-export async function processTxRequest(client, txRequest) {
-    //parse incoming transaction
-    let tx
-    try {
-        tx = TransactionBuilder.fromXDR(txRequest.xdr, client.network)
-    } catch (e) {
-        throw errors.invalidSwapTx()
-    }
-    //check that transaction is correct
-    if (!validateTransaction(client, tx))
-        throw errors.invalidSwapTx()
-    //if transaction has not been authorized yet by the channel account
-    const isSorobanTx = tx.operations[0].auth?.length > 0
-    if (isSorobanTx) {
-        //send tx back to the server
-        if (!tx.signatures.length) {
-            //sign auth
-            await authorizeInvocation(client, tx)
-            tx = await signTx(client, tx)
-            return tx.toXDR()//wait for the signed tx from the server to wrap it with fee bump tx
-        }
-    } else {
-        //sign transaction
-        tx = await signTx(client, tx)
-    }
-    //wrap with fee bump
-    let wrapped = TransactionBuilder.buildFeeBumpTransaction(client.trader, txRequest.networkFee, tx, client.network)
-    //sign fee bump wrapper tx
-    wrapped = await signTx(client, wrapped)
-    //respond with signed transaction
-    return wrapped.toXDR()
-}
-
-/**
- * @param {StellarBrokerClient} client
- * @param {TransactionI} tx
- * @return {Promise<TransactionI>}
- * @private
- */
-async function authorizeInvocation(client, tx) {
-    //from https://github.com/stellar/js-stellar-base/blob/e3d6fc3351e7d242b374c7c6057668366364a279/src/auth.js#L97
-    const auth = tx.operations[0].auth[0]
-    /** @type {xdr.SorobanAddressCredentials} */
-    const addrAuth = auth.credentials().address()
-    addrAuth.signatureExpirationLedger(tx.ledgerBounds.maxLedger + 1)
-
-    const networkId = hash(Buffer.from(tx.networkPassphrase))
-    const preimage = xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
-        new xdr.HashIdPreimageSorobanAuthorization({
-            networkId,
-            nonce: addrAuth.nonce(),
-            invocation: auth.rootInvocation(),
-            signatureExpirationLedger: addrAuth.signatureExpirationLedger()
-        })
-    )
-    const payload = hash(preimage.toXDR())
-    let signature
-    if (client.authorization instanceof Keypair) {
-        signature = client.authorization.sign(payload)
-    } else {
-        signature = await promisify(client.authorization(payload))
-    }
-    const publicKey = StrKey.encodeEd25519PublicKey(addrAuth.address().accountId().value())
-    const sigScVal = nativeToScVal(
-        {
-            public_key: StrKey.decodeEd25519PublicKey(publicKey),
-            signature
-        },
-        {
-            type: {
-                public_key: ['symbol', null],
-                signature: ['symbol', null]
-            }
-        }
-    )
-
-    addrAuth.signature(xdr.ScVal.scvVec([sigScVal]))
-}
-
-/**
- * @param {StellarBrokerClient} client
- * @param {TransactionI} tx
- * @return {Promise<TransactionI>}
- * @private
- */
-async function signTx(client, tx) {
-    let promise
-    if (client.authorization instanceof Keypair) {
-        promise = new Promise((resolve, reject) => {
-            try {
-                tx.sign(client.authorization)
-                resolve(tx)
-            } catch (e) {
-                reject(e)
-            }
-        })
-    } else {
-        //normalize external auth result
-        promise = promisify(client.authorization(tx))
-    }
-    return promise
-        .then(tx => {
-            if (typeof tx === 'string') { //normalize response
-                tx = TransactionBuilder.fromXDR(tx, client.network)
-            }
-            if (!tx || tx.signatures?.length < 1)
-                throw new Error(`Transaction was not signed`)
-            return tx
-        })
-        .catch(e => {
-            console.error(e)
-            throw errors.failedToSignTx()
-        })
-}
-
-/**
- * @param {StellarBrokerClient} client
- * @param {Transaction} tx
- * @throws {StellarBrokerError} Invalid swap transaction received
- */
-function validateTransaction(client, tx) {
-    /*if (!(tx instanceof FeeBumpTransaction))
-        return false
-    const {innerTransaction} = tx
-    if (tx.feeSource !== this.source)
-        return false*/
-    for (let swap of tx.operations) {
-        if (swap.type === 'invokeHostFunction')
-            continue //TODO: add additional validation
-        if (swap.type !== 'pathPaymentStrictSend' && swap.type !== 'pathPaymentStrictReceive')
-            return false
-        const isFee = swap.destination !== client.trader
-        if (isFee) {
-            if (swap.type !== 'pathPaymentStrictSend')
-                return false
-            if ((swap.source && swap.source !== client.trader))
-                return false
-        } else {
-            if ((swap.source && swap.source !== swap.destination) || swap.destination !== client.trader)
-                return false
-        }
-    }
-    //TODO: check assets and amounts
-    return true
-}
-
-function promisify(callResult) {
-    if (!(callResult instanceof Promise)) {
-        if (!callResult)
-            return Promise.reject()
-        callResult = Promise.resolve(callResult)
-    }
-    return callResult
+import {hash, Keypair, nativeToScVal, StrKey, TransactionBuilder, xdr} from '@stellar/stellar-sdk'
+import errors from './errors.js'
+
+/**
+ * @param {StellarBrokerClient} client
+ * @param {{xdr: string, hash: string, networkFee: string, [confirmed]: boolean}} txRequest
+ * @return {Promise<string>}
+ */
+export async function processTxRequest(client, txRequest) {
+    //parse incoming transaction
+    let tx
+    try {
+        tx = TransactionBuilder.fromXDR(txRequest.xdr, client.network)
+    } catch (e) {
+        throw errors.invalidSwapTx()
+    }
+    //check that transaction is correct
+    if (!validateTransaction(client, tx))
+        throw errors.invalidSwapTx()
+    //if transaction has not been authorized yet by the channel account
+    const isSorobanTx = tx.operations[0].auth?.length > 0
+    if (isSorobanTx) {
+        //send tx back to the server
+        if (!tx.signatures.length) {
+            //sign auth
+            await authorizeInvocation(client, tx)
+            tx = await signTx(client, tx)
+            return tx.toXDR()//wait for the signed tx from the server to wrap it with fee bump tx
+        }
+    } else {
+        //sign transaction
+        tx = await signTx(client, tx)
+    }
+    //wrap with fee bump
+    let wrapped = TransactionBuilder.buildFeeBumpTransaction(client.trader, txRequest.networkFee, tx, client.network)
+    //sign fee bump wrapper tx
+    wrapped = await signTx(client, wrapped)
+    //respond with signed transaction
+    return wrapped.toXDR()
+}
+
+/**
+ * @param {StellarBrokerClient} client
+ * @param {TransactionI} tx
+ * @return {Promise<TransactionI>}
+ * @private
+ */
+async function authorizeInvocation(client, tx) {
+    //from https://github.com/stellar/js-stellar-base/blob/e3d6fc3351e7d242b374c7c6057668366364a279/src/auth.js#L97
+    const auth = tx.operations[0].auth[0]
+    /** @type {xdr.SorobanAddressCredentials} */
+    const addrAuth = auth.credentials().address()
+    addrAuth.signatureExpirationLedger(tx.ledgerBounds.maxLedger + 1)
+
+    const networkId = hash(Buffer.from(tx.networkPassphrase))
+    const preimage = xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
+        new xdr.HashIdPreimageSorobanAuthorization({
+            networkId,
+            nonce: addrAuth.nonce(),
+            invocation: auth.rootInvocation(),
+            signatureExpirationLedger: addrAuth.signatureExpirationLedger()
+        })
+    )
+    const payload = hash(preimage.toXDR())
+    const signature = await client.authorization.authorize(payload)
+    const publicKey = StrKey.encodeEd25519PublicKey(addrAuth.address().accountId().value())
+    const sigScVal = nativeToScVal(
+        {
+            public_key: StrKey.decodeEd25519PublicKey(publicKey),
+            signature
+        },
+        {
+            type: {
+                public_key: ['symbol', null],
+                signature: ['symbol', null]
+            }
+        }
+    )
+
+    addrAuth.signature(xdr.ScVal.scvVec([sigScVal]))
+}
+
+/**
+ * @param {StellarBrokerClient} client
+ * @param {TransactionI} tx
+ * @return {Promise<TransactionI>}
+ * @private
+ */
+function signTx(client, tx) {
+    return client.authorization.authorize(tx)
+        .then(tx => {
+            if (typeof tx === 'string') { //normalize response
+                tx = TransactionBuilder.fromXDR(tx, client.network)
+            }
+            if (!tx || tx.signatures?.length < 1)
+                throw new Error(`Transaction was not signed`)
+            return tx
+        })
+        .catch(e => {
+            console.error(e)
+            throw errors.failedToSignTx()
+        })
+}
+
+/**
+ * @param {StellarBrokerClient} client
+ * @param {Transaction} tx
+ * @throws {StellarBrokerError} Invalid swap transaction received
+ */
+function validateTransaction(client, tx) {
+    /*if (!(tx instanceof FeeBumpTransaction))
+        return false
+    const {innerTransaction} = tx
+    if (tx.feeSource !== this.source)
+        return false*/
+    for (let swap of tx.operations) {
+        if (swap.type === 'invokeHostFunction')
+            continue //TODO: add additional validation
+        if (swap.type !== 'pathPaymentStrictSend' && swap.type !== 'pathPaymentStrictReceive')
+            return false
+        const isFee = swap.destination !== client.trader
+        if (isFee) {
+            if (swap.type !== 'pathPaymentStrictSend')
+                return false
+            if ((swap.source && swap.source !== client.trader))
+                return false
+        } else {
+            if ((swap.source && swap.source !== swap.destination) || swap.destination !== client.trader)
+                return false
+        }
+    }
+    //TODO: check assets and amounts
+    return true
 }