@aeternity/aepp-sdk 8.2.0 → 10.0.0-beta.1

package/src/tx/validator.js

@@ -1,229 +1,161 @@
-import {
-  verify,
-  decodeBase58Check,
-  assertedType
-} from '../utils/crypto'
-import { encode } from '../tx/builder/helpers'
+import { verify, hash } from '../utils/crypto'
+import { encode, decode } from './builder/helpers'
 
 import BigNumber from 'bignumber.js'
-import {
-  BASE_VERIFICATION_SCHEMA,
-  CONTRACT_VERIFICATION_SCHEMA,
-  MIN_GAS_PRICE,
-  NAME_CLAIM_VERIFICATION_SCHEMA,
-  OBJECT_ID_TX_TYPE,
-  OBJECT_TAG_SIGNED_TRANSACTION,
-  PROTOCOL_VM_ABI,
-  SIGNATURE_VERIFICATION_SCHEMA,
-  TX_TYPE
-} from './builder/schema'
-import { buildTxHash, calculateFee, unpackTx } from './builder'
-import NodePool from '../node-pool'
+import { MIN_GAS_PRICE, PROTOCOL_VM_ABI, TX_TYPE } from './builder/schema'
+import { calculateFee, unpackTx } from './builder'
 
 /**
  * Transaction validator
  * @module @aeternity/aepp-sdk/es/tx/validator
- * @export TransactionValidator
- * @example import { TransactionValidator } from '@aeternity/aepp-sdk'
+ * @export verifyTransaction
+ * @example import { verifyTransaction } from '@aeternity/aepp-sdk'
  */
 
-const VALIDATORS = {
-  // VALIDATE SIGNATURE
-  signature ({ rlpEncoded, signature, ownerPublicKey, networkId = 'ae_mainnet' }) {
-    const txWithNetworkId = Buffer.concat([Buffer.from(networkId), rlpEncoded])
-    const txHashWithNetworkId = Buffer.concat([Buffer.from(networkId), buildTxHash(rlpEncoded, { raw: true })])
-    const decodedPub = decodeBase58Check(assertedType(ownerPublicKey, 'ak'))
-    return verify(txWithNetworkId, signature, decodedPub) || verify(txHashWithNetworkId, signature, decodedPub)
+const validators = [
+  async ({ encodedTx, signatures }, { account, node, parentTxTypes }) => {
+    if ((encodedTx ?? signatures) === undefined) return []
+    if (signatures.length !== 1) return [] // TODO: Support multisignature?
+    const prefix = Buffer.from([
+      node.nodeNetworkId,
+      ...parentTxTypes.includes(TX_TYPE.payingFor) ? ['inner_tx'] : []
+    ].join('-'))
+    const txWithNetworkId = Buffer.concat([prefix, encodedTx.rlpEncoded])
+    const txHashWithNetworkId = Buffer.concat([prefix, hash(encodedTx.rlpEncoded)])
+    const decodedPub = decode(account.id, 'ak')
+    if (verify(txWithNetworkId, signatures[0], decodedPub) ||
+      verify(txHashWithNetworkId, signatures[0], decodedPub)) return []
+    return [{
+      message: 'Signature cannot be verified, please ensure that you transaction have' +
+        ' the correct prefix and the correct private key for the sender address',
+      key: 'InvalidSignature',
+      checkedKeys: ['encodedTx', 'signatures']
+    }]
   },
-  // VALIDATE IF ENOUGH FEE
-  insufficientFee ({ minFee, fee }) {
-    return BigNumber(minFee).lte(BigNumber(fee))
+  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
+    if ((encodedTx ?? tx) === undefined) return []
+    return verifyTransaction(
+      encode((encodedTx ?? tx).rlpEncoded, 'tx'),
+      node,
+      [...parentTxTypes, txType]
+    )
   },
-  // VALIDATE IF TTL VALID
-  expiredTTL ({ ttl, height }) {
-    return BigNumber(ttl).eq(0) || BigNumber(ttl).gte(BigNumber(height))
-  },
-  // Insufficient Balance for Amount plus Fee
-  insufficientBalanceForAmountFee ({ balance, amount = 0, fee }) {
-    return BigNumber(balance).gte(BigNumber(amount).plus(fee))
+  (tx, { txType }) => {
+    if (tx.fee === undefined) return []
+    const minFee = calculateFee(0, txType, {
+      gas: +tx.gas || 0, params: tx, showWarning: false, vsn: tx.VSN
+    })
+    if (new BigNumber(minFee).lte(tx.fee)) return []
+    return [{
+      message: `Fee ${tx.fee} is too low, minimum fee for this transaction is ${minFee}`,
+      key: 'InsufficientFee',
+      checkedKeys: ['fee']
+    }]
   },
-  // Insufficient Balance for Amount
-  insufficientBalanceForAmount ({ balance, amount = 0 }) {
-    return BigNumber(balance).gte(BigNumber(amount))
+  ({ ttl }, { height }) => {
+    if (ttl === undefined) return []
+    ttl = +ttl
+    if (ttl === 0 || ttl >= height) return []
+    return [{
+      message: `TTL ${ttl} is already expired, current height is ${height}`,
+      key: 'ExpiredTTL',
+      checkedKeys: ['ttl']
+    }]
   },
-  // IF NONCE USED
-  nonceUsed ({ accountNonce, nonce }) {
-    return BigNumber(nonce).gt(BigNumber(accountNonce))
+  ({ amount, fee, nameFee, tx }, { account, parentTxTypes, txType }) => {
+    if ((amount ?? fee ?? nameFee) === undefined) return []
+    const cost = new BigNumber(fee).plus(nameFee || 0).plus(amount || 0)
+      .plus(txType === TX_TYPE.payingFor ? tx.tx.encodedTx.tx.fee : 0)
+      .minus(parentTxTypes.includes(TX_TYPE.payingFor) ? fee : 0)
+    if (cost.lte(account.balance)) return []
+    return [{
+      message: `Account balance ${account.balance} is not enough to execute the transaction that costs ${cost.toFixed()}`,
+      key: 'InsufficientBalance',
+      checkedKeys: ['amount', 'fee', 'nameFee']
+    }]
   },
-  // IF NONCE TO HIGH
-  nonceHigh ({ accountNonce, nonce }) {
-    return !(BigNumber(nonce).gt(BigNumber(accountNonce).plus(1)))
+  ({ nonce }, { account, parentTxTypes }) => {
+    if (nonce === undefined || parentTxTypes.includes(TX_TYPE.gaMeta)) return []
+    nonce = +nonce
+    const validNonce = account.nonce + 1
+    if (nonce === validNonce) return []
+    return [{
+      ...nonce < validNonce
+        ? {
+            message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
+            key: 'NonceAlreadyUsed'
+          }
+        : {
+            message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
+            key: 'NonceHigh'
+          },
+      checkedKeys: ['nonce']
+    }]
   },
-  minGasPrice ({ gasPrice }) {
-    return isNaN(gasPrice) || BigNumber(gasPrice).gte(BigNumber(MIN_GAS_PRICE))
+  ({ gasPrice }) => {
+    if (gasPrice === undefined) return []
+    if (gasPrice >= MIN_GAS_PRICE) return []
+    return [{
+      message: `Gas price ${gasPrice} must be bigger then ${MIN_GAS_PRICE}`,
+      key: 'MinGasPrice',
+      checkedKeys: ['gasPrice']
+    }]
   },
-  // VM/ABI version validation based on consensus protocol version
-  vmAndAbiVersion ({ ctVersion, abiVersion, consensusProtocolVersion, txType }) {
-    // If not contract tx
+  ({ ctVersion, abiVersion }, { txType, node }) => {
+    const { consensusProtocolVersion } = node.getNodeInfo()
+    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
+    if (!protocol) throw new Error(`Unsupported protocol: ${consensusProtocolVersion}`)
+    // If not contract create tx
     if (!ctVersion) ctVersion = { abiVersion }
-    const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
-    // If protocol not implemented
-    if (!supportedProtocol) return true
-    // If protocol for tx type not implemented
-    const txProtocol = supportedProtocol[txType]
-
-    return !Object.entries(ctVersion)
-      .reduce((acc, [key, value]) =>
-        [...acc, value === undefined ? true : txProtocol[key].includes(parseInt(value))],
-      []).includes(false)
-  },
-  insufficientBalanceForFeeNameFee ({ nameFee, fee, balance, VSN }) {
-    return VSN === 1 || BigNumber(balance).gte(BigNumber(nameFee).plus(fee))
-  }
-}
-
-const resolveDataForBase = async (chain, { ownerPublicKey }) => {
-  let accountNonce = 0
-  let accountBalance = 0
-  try {
-    const { nonce, balance } = await chain.api.getAccountByPubkey(ownerPublicKey)
-    accountNonce = nonce
-    accountBalance = balance
-  } catch (e) { console.log('We can not get info about this publicKey') }
-  return {
-    height: (await chain.api.getCurrentKeyBlockHeight()).height,
-    balance: accountBalance,
-    accountNonce,
-    ownerPublicKey,
-    ...chain.getNodeInfo()
-  }
-}
-
-// Verification using SCHEMA
-const verifySchema = (schema, data) => {
-  // Verify through schema
-  return schema.reduce(
-    (acc, [msg, validatorKey, { key, type, txKey }]) => {
-      if (!VALIDATORS[validatorKey](data)) acc.push({ msg: msg(data), txKey, type })
-      return acc
-    },
-    []
-  )
-}
-
-/**
- * Unpack and verify transaction (verify nonce, ttl, fee, signature, account balance)
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/validator
- *
- * @param {String} txHash Base64Check transaction hash
- * @param {Object} [options={}] Options
- * @param {String} [options.networkId] networkId Use in signature verification
- * @return {Promise<Object>} Object with verification errors and warnings
- */
-async function unpackAndVerify (txHash, { networkId } = {}) {
-  const { tx: unpackedTx, rlpEncoded, txType } = unpackTx(txHash)
-
-  if (+unpackedTx.tag === OBJECT_TAG_SIGNED_TRANSACTION) {
-    const { txType, tx } = unpackedTx.encodedTx
-    const signatures = unpackedTx.signatures.map(raw => ({ raw, hash: encode(raw, 'sg') }))
-    const rlpEncodedTx = unpackedTx.encodedTx.rlpEncoded
-
-    return {
-      validation: await this.verifyTx({ tx, signatures, rlpEncoded: rlpEncodedTx }, networkId),
-      tx,
-      signatures,
-      txType
+    const txProtocol = protocol[txType]
+    if (!txProtocol) return []
+    if (Object.entries(ctVersion).some(([key, value]) => !txProtocol[key].includes(+value))) {
+      return [{
+        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
+        key: 'VmAndAbiVersionMismatch',
+        checkedKeys: ['ctVersion', 'abiVersion']
+      }]
     }
+    return []
   }
-  return {
-    validation: await this.verifyTx({ tx: unpackedTx, rlpEncoded }, networkId),
-    tx: unpackedTx,
-    txType
-  }
-}
+]
 
-const getOwnerPublicKey = (tx) =>
-  tx[['senderId', 'accountId', 'ownerId', 'callerId', 'oracleId', 'fromId', 'initiator', 'gaId'].find(key => tx[key])].replace('ok_', 'ak_')
+const getSenderAddress = tx => [
+  'senderId', 'accountId', 'ownerId', 'callerId',
+  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId'
+]
+  .map(key => tx[key])
+  .filter(a => a)
+  .map(a => a.replace(/^ok_/, 'ak_'))[0]
 
 /**
- * Verify transaction (verify nonce, ttl, fee, signature, account balance)
+ * Transaction Validator
+ * This function validates some of transaction properties,
+ * to make sure it can be posted it to the chain
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/validator
- *
- * @param {Object} [data={}] data TX data object
- * @param {String} [data.tx] tx Transaction hash
- * @param {Array} [data.signatures] signatures Transaction signature's
- * @param {Array} [data.rlpEncoded] rlpEncoded RLP encoded transaction
- * @param {String} networkId networkId Use in signature verification
- * @return {Promise<Array>} Object with verification errors and warnings
+ * @rtype (tx: String, node) => void
+ * @param {String} transaction Base64Check-encoded transaction
+ * @param {Object} node Node to validate transaction against
+ * @param {String[]} [parentTxTypes] Types of parent transactions
+ * @return {Promise<Object[]>} Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
  */
-async function verifyTx ({ tx, signatures, rlpEncoded }, networkId) {
-  networkId = networkId || this.getNetworkId() || 'ae_mainnet'
-  // Fetch data for verification
-  const ownerPublicKey = getOwnerPublicKey(tx)
-  const gas = Object.prototype.hasOwnProperty.call(tx, 'gas') ? +tx.gas : 0
-  const txType = OBJECT_ID_TX_TYPE[+tx.tag]
-  const resolvedData = {
-    minFee: calculateFee(0, txType, { gas, params: tx, showWarning: false, vsn: tx.VSN }),
-    ...(await resolveDataForBase(this, { ownerPublicKey })),
-    ...tx,
-    txType
-  }
-  const signatureVerification = signatures && signatures.length
-    ? verifySchema(SIGNATURE_VERIFICATION_SCHEMA, {
-      rlpEncoded,
-      signature: signatures[0].raw,
-      ownerPublicKey,
-      networkId
-    })
-    : []
-  const baseVerification = verifySchema(BASE_VERIFICATION_SCHEMA, resolvedData)
+export default async function verifyTransaction (transaction, node, parentTxTypes = []) {
+  const { tx, txType } = unpackTx(transaction)
 
-  return [
-    ...baseVerification,
-    ...signatureVerification,
-    ...customVerification(txType, resolvedData)
-  ]
-}
+  const address = getSenderAddress(tx) ??
+    (txType === TX_TYPE.signed ? getSenderAddress(tx.encodedTx.tx) : null)
+  const [account, height] = await Promise.all([
+    address && node.api.getAccountByPubkey(address).catch(() => ({
+      id: address,
+      balance: new BigNumber(0),
+      nonce: 0
+    })),
+    node.api.getCurrentKeyBlockHeight().then(({ height }) => height)
+  ])
 
-/**
- * Verification for speciific txType
- * @param txType
- * @param data
- * @return {Array}
- */
-function customVerification (txType, data) {
-  switch (txType) {
-    case TX_TYPE.contractCreate:
-    case TX_TYPE.contractCall:
-    case TX_TYPE.oracleRegister:
-      return verifySchema(CONTRACT_VERIFICATION_SCHEMA, data)
-    case TX_TYPE.nameClaim:
-      return verifySchema(NAME_CLAIM_VERIFICATION_SCHEMA, data)
-    default:
-      return []
-  }
+  return (await Promise.all(
+    validators.map(v => v(tx, { txType, node, account, height, parentTxTypes })))
+  ).flat()
 }
-
-/**
- * Transaction Validator Stamp
- * This stamp give us possibility to unpack and validate some of transaction properties,
- * to make sure we can post it to the chain
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/validator
- * @rtype Stamp
- * @param {Object} [options={}] - Initializer object
- * @param {Object} [options.url] - Node url
- * @param {Object} [options.internalUrl] - Node internal url
- * @return {Object} Transaction Validator instance
- * @example TransactionValidator({url: 'https://testnet.aeternity.io'})
- */
-const TransactionValidator = NodePool.compose({
-  methods: {
-    verifyTx,
-    unpackAndVerify
-  }
-})
-
-export default TransactionValidator

package/src/utils/aepp-wallet-communication/rpc/aepp-rpc.js

@@ -5,9 +5,7 @@
  * @export AeppRpc
  * @example import ContentScriptBridge from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
  */
-import * as R from 'ramda'
 import { v4 as uuid } from 'uuid'
-
 import Ae from '../../../ae'
 import RpcClient from './rpc-client'
 import { getHandler, message, voidFn } from '../helpers'
@@ -236,7 +234,7 @@ export default Ae.compose({
       if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
       if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.')
       if (options.onAccount && !this.rpcClient.hasAccessToAccount(options.onAccount)) throw new Error(`You do not have access to account ${options.onAccount}`)
-      const opt = R.merge(this.Ae.defaults, options)
+      const opt = { ...this.Ae.defaults, ...options }
       if (!opt.walletBroadcast) {
         const signed = await this.signTransaction(tx, { onAccount: opt.onAccount })
         return this.sendTransaction(signed, opt)

package/src/utils/aepp-wallet-communication/rpc/wallet-rpc.js

@@ -7,6 +7,7 @@
  */
 import { v4 as uuid } from 'uuid'
 import Ae from '../../../ae'
+import verifyTransaction from '../../../tx/validator'
 import AccountMultiple from '../../../account/multiple'
 import TxObject from '../../../tx/tx-object'
 import RpcClient from './rpc-client'
@@ -73,7 +74,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },
@@ -111,22 +112,20 @@ const REQUESTS = {
         try {
           onAcc = resolveOnAccount(instance.addresses(), address, opt)
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
         try {
           return {
-            result: {
-              ...returnSigned
-                ? { signedTransaction: await instance.signTransaction(rawTx || tx, { onAccount: onAcc }) }
-                : { transactionHash: await instance.send(rawTx || tx, { onAccount: onAcc, verify: false }) }
-            }
+            result: returnSigned
+              ? { signedTransaction: await instance.signTransaction(rawTx || tx, { onAccount: onAcc }) }
+              : { transactionHash: await instance.send(rawTx || tx, { onAccount: onAcc, verify: false }) }
           }
         } catch (e) {
           if (!returnSigned) {
             // Validate transaction
-            const validationResult = await instance.unpackAndVerify(rawTx || tx)
-            if (validationResult.validation.length) return { error: ERRORS.invalidTransaction(validationResult) }
+            const validation = await verifyTransaction(rawTx || tx, instance.selectedNode.instance)
+            if (validation.length) return { error: ERRORS.invalidTransaction(validation) }
             // Send broadcast failed error to aepp
             return { error: ERRORS.broadcastFailed(e.message) }
           }
@@ -157,7 +156,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },

package/src/utils/aepp-wallet-communication/schema.js

@@ -1,6 +1,4 @@
-import * as R from 'ramda'
-
-const asEnum = (array) => R.zipObj(array, array)
+const asEnum = (array) => Object.fromEntries(array.map(a => [a, a]))
 
 export const VERSION = 1
 

package/src/utils/amount-formatter.ts

@@ -88,7 +88,7 @@ export const formatAmount = (
   const denominations = Object.values(AE_AMOUNT_FORMATS)
   if (!denominations.includes(denomination)) throw new Error(`Invalid denomination: ${denomination}`)
   if (!denominations.includes(targetDenomination)) throw new Error(`Invalid target denomination: ${targetDenomination}`)
-  if (!isBigNumber(value)) throw new Error(`Value ${value.toString()} is not type of number`)
+  if (!isBigNumber(value)) throw new Error(`Value ${value?.toString()} is not type of number`)
 
   return new BigNumber(value)
     .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])

package/src/utils/bignumber.ts

@@ -19,7 +19,8 @@ export const parseBigNumber = (number: string | number | BigNumber): string =>
  * @return {Boolean}
  */
 export const isBigNumber = (number: string | number | BigNumber): boolean =>
-  !isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number)
+  ['number', 'object', 'string', 'bigint'].includes(typeof number) &&
+  (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
 
 /**
  * BigNumber ceil operation

package/src/utils/crypto.js

@@ -28,6 +28,7 @@ import aesjs from 'aes-js'
 import shajs from 'sha.js'
 
 import { str2buf, toBytes } from './bytes'
+import { decode } from '../tx/builder/helpers'
 import { hash } from './crypto-ts'
 
 export * from './crypto-ts'
@@ -56,7 +57,7 @@ export function getAddressFromPriv (secret) {
 export function isAddressValid (address, prefix = 'ak') {
   if (typeof address !== 'string') return false
   try {
-    return decodeBase58Check(assertedType(address, prefix)).length === 32
+    return decode(address, prefix).length === 32
   } catch (e) {
     return false
   }
@@ -173,7 +174,7 @@ export function encodeUnsigned (value) {
  * @return {String} - Contract address
  */
 export function encodeContractAddress (owner, nonce) {
-  const publicKey = decodeBase58Check(assertedType(owner, 'ak'))
+  const publicKey = decode(owner, 'ak')
   const binary = Buffer.concat([publicKey, encodeUnsigned(nonce)])
   return `ct_${encodeBase58Check(hash(binary))}`
 }
@@ -296,20 +297,6 @@ export function aeEncodeKey (binaryKey) {
   return `ak_${pubKeyAddress}`
 }
 
-/**
- * Assert encoded type and return its payload
- * @rtype (data: String, type: String) => String, throws: Error
- * @param {String} data - ae data
- * @param {String} type - Prefix
- * @param {Boolean} omitError - Return false instead of throwing the error if data doesn't match expected type
- * @return {String|Boolean} Payload
- */
-export function assertedType (data, type, omitError) {
-  if (RegExp(`^${type}_.+$`).test(data)) return data.split('_')[1]
-  else if (omitError) return false
-  else throw new Error(`Data doesn't match expected type ${type}`)
-}
-
 /**
  * Check key pair for validity
  *
@@ -336,7 +323,7 @@ export function isValidKeypair (privateKey, publicKey) {
  */
 export function encryptData (msg, publicKey) {
   const ephemeralKeyPair = nacl.box.keyPair()
-  const pubKeyUInt8Array = decodeBase58Check(assertedType(publicKey, 'ak'))
+  const pubKeyUInt8Array = decode(publicKey, 'ak')
   const nonce = nacl.randomBytes(nacl.box.nonceLength)
 
   const encryptedMessage = nacl.box(

package/src/utils/other.ts

@@ -1,6 +1,6 @@
 import { snakeToPascal, pascalToSnake } from './string'
 
-export const pause = async (duration: number): Promise<undefined> =>
+export const pause = async (duration: number): Promise<void> =>
   await new Promise(resolve => setTimeout(resolve, duration))
 
 export const mapObject = (

package/src/utils/semver-satisfies.ts

@@ -1,6 +1,6 @@
 export default function (version: string, geVersion: string, ltVersion: string): boolean {
   const getComponents = (v: string): number[] => v
-    .split('-')[0].split('.').map(i => +i)
+    .split(/[-+]/)[0].split('.').map(i => +i)
 
   const versionComponents = getComponents(version)
   const geComponents = getComponents(geVersion)

package/src/utils/swagger.js

@@ -39,13 +39,27 @@ let warnedAboutInternalApiUsage = false
  * @param {String} [options.internalUrl] - Node internal URL
  * @param {Boolean} [options.disableBigNumbers]
  * @param {Boolean} [options.disableCaseConversion]
+ * @param {Function} [options.responseInterceptor]
  * @return {Object} Swagger client
  * @example (await genSwaggerClient('https://mainnet.aeternity.io/api')).getAccountByPubkey('ak_jupBUgZNbcC4krDLR3tAkw1iBZoBbkNeShAq4atBtpFWmz36r')
  */
-export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCaseConversion } = {}) => {
+export default async (
+  specUrl,
+  { spec, internalUrl, disableBigNumbers, disableCaseConversion, responseInterceptor } = {}
+) => {
   spec = spec || await (await fetch(specUrl)).json()
   const jsonImp = disableBigNumbers ? JSON : JsonBig
 
+  if (
+    [
+      'https://compiler.aepps.com',
+      'https://latest.compiler.aepps.com'
+    ].includes(new URL(specUrl).origin) ||
+    new URL(specUrl).origin.includes('https://')
+  ) {
+    spec.schemes = ['https']
+  }
+
   const [external, internal] = await Promise.all([specUrl, internalUrl].map((url) => {
     if (!url) return null
     return SwaggerClient({
@@ -54,9 +68,10 @@ export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCa
       responseInterceptor: response => {
         if (!response.text) return response
         const body = jsonImp.parse(response.text)
-        return Object.assign(response, {
+        Object.assign(response, {
           body: disableCaseConversion ? body : pascalizeKeys(body)
         })
+        return (responseInterceptor && responseInterceptor(response)) || response
       }
     })
   }))
@@ -87,11 +102,13 @@ export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCa
       const opSpec = opSpecs[opId]
       const parameters = [
         ...opSpec.parameters,
-        ...opSpec.requestBody ? [{
-          required: opSpec.requestBody.required,
-          schema: Object.values(opSpec.requestBody.content)[0].schema,
-          name: '__requestBody'
-        }] : []
+        ...opSpec.requestBody
+          ? [{
+              required: opSpec.requestBody.required,
+              schema: Object.values(opSpec.requestBody.content)[0].schema,
+              name: '__requestBody'
+            }]
+          : []
       ]
       const required = parameters.filter(param => param.required).map(p => p.name)
       if (args.length < required.length) throw new Error('swagger: Not enough arguments')