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

package/src/utils/swagger.js

@@ -39,10 +39,14 @@ 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
 
@@ -64,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
       }
     })
   }))
@@ -97,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')

package/src/contract/aci/helpers.js

@@ -1,140 +0,0 @@
-import * as R from 'ramda'
-import { unpackTx } from '../../tx/builder'
-import { decodeEvents as unpackEvents, transform, transformDecodedData, validateArguments } from './transformation'
-
-/**
- * Get function schema from contract ACI object
- * @param {Object} aci Contract ACI object
- * @param {String} name Function name
- * @param external
- * @return {Object} function ACI
- */
-export function getFunctionACI (aci, name, { external }) {
-  if (!aci) throw new Error('ACI required')
-  const fn = aci.functions.find(f => f.name === name)
-  if (!fn && name !== 'init') throw new Error(`Function ${name} doesn't exist in contract`)
-
-  return {
-    ...fn,
-    bindings: [
-      {
-        state: aci.state,
-        type_defs: aci.type_defs,
-        name: aci.name
-      },
-      ...external.map(R.pick(['state', 'type_defs', 'name']))
-    ],
-    event: aci.event ? aci.event.variant : []
-  }
-}
-
-/**
- * Build contract methods base on ACI
- * @return {Object} Contract instance methods
- */
-export const buildContractMethods = (instance) => () => ({
-  ...instance.aci
-    ? instance
-      .aci
-      .functions
-      .reduce(
-        (acc, { name, arguments: aciArgs, stateful }) => ({
-          ...acc,
-          [name]: Object.assign(
-            function () {
-              const { opt, args } = parseArguments(aciArgs)(arguments)
-              if (name === 'init') return instance.deploy(args, opt)
-              return instance.call(name, args, { callStatic: !stateful, ...opt })
-            },
-            {
-              get () {
-                const { opt, args } = parseArguments(aciArgs)(arguments)
-                return instance.call(name, args, { ...opt, callStatic: true })
-              },
-              send () {
-                const { opt, args } = parseArguments(aciArgs)(arguments)
-                if (name === 'init') return instance.deploy(args, opt)
-                return instance.call(name, args, { ...opt, callStatic: false })
-              },
-              decodeEvents (events) {
-                return instance.decodeEvents(name, events)
-              }
-            }
-          )
-        }),
-        {}
-      )
-    : {},
-  ...instance.aci ? {
-    init: Object.assign(
-      function () {
-        const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-        const { opt, args } = parseArguments(aciArgs)(arguments)
-        return instance.deploy(args, opt)
-      },
-      {
-        get () {
-          const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-          const { opt, args } = parseArguments(aciArgs)(arguments)
-          return instance.deploy(args, { ...opt, callStatic: true })
-        },
-        send () {
-          const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-          const { opt, args } = parseArguments(aciArgs)(arguments)
-          return instance.deploy(args, { ...opt, callStatic: false })
-        }
-      }
-    )
-  } : {}
-})
-
-export const parseArguments = (aciArgs = []) => (args) => ({
-  opt: args.length > aciArgs.length ? R.last(args) : {},
-  args: Object.values(args).slice(0, aciArgs.length)
-})
-
-export const unpackByteCode = (bytecode) => unpackTx(bytecode, false, 'cb').tx
-
-/**
- * Validated contract call arguments using contract ACI
- * @function validateCallParams
- * @rtype (aci: Object, params: Array) => Object
- * @param {Object} aci Contract ACI
- * @param {Array} params Contract call arguments
- * @return Promise{Array} Object with validation errors
- */
-export const prepareArgsForEncode = async (aci, params) => {
-  if (!aci || !aci.arguments) return params
-  // Validation
-  if (aci.arguments.length > params.length) {
-    throw new Error(`Function "${aci.name}" require ${aci.arguments.length} arguments of types [${aci.arguments.map(a => JSON.stringify(a.type))}] but get [${params.map(JSON.stringify)}]`)
-  }
-
-  validateArguments(aci, params)
-  const bindings = aci.bindings
-  // Cast argument from JS to Sophia type
-  return Promise.all(aci.arguments.map(async ({ type }, i) => transform(type, params[i], {
-    bindings
-  })))
-}
-
-export const decodeEvents = (events, fnACI) => {
-  if (!fnACI || !fnACI.event || !fnACI.event.length) return []
-
-  const eventsSchema = fnACI.event.map(e => {
-    const name = Object.keys(e)[0]
-    return { name, types: e[name] }
-  })
-  return unpackEvents(events, { schema: eventsSchema })
-}
-
-export const decodeCallResult = async (result, fnACI, opt) => {
-  return {
-    decodedResult: await transformDecodedData(
-      fnACI.returns,
-      await result.decode(),
-      { ...opt, bindings: fnACI.bindings }
-    ),
-    decodedEvents: decodeEvents(result.result.log, fnACI)
-  }
-}