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

package/src/ae/aens.js

@@ -26,7 +26,6 @@
  * @example import { Aens } from '@aeternity/aepp-sdk'
  */
 
-import * as R from 'ramda'
 import { salt } from '../utils/crypto'
 import {
   commitmentHash,
@@ -63,12 +62,13 @@ import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
  */
 async function revoke (name, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
-  const nameRevokeTx = await this.nameRevokeTx(R.merge(opt, {
+  const nameRevokeTx = await this.nameRevokeTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt)
-  }))
+  })
 
   return this.send(nameRevokeTx, opt)
 }
@@ -103,18 +103,19 @@ async function revoke (name, options = {}) {
  */
 async function update (name, pointers = [], options = { extendPointers: false }) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   if (!validatePointers(pointers)) throw new Error('Invalid pointers array')
 
   pointers = [
     ...options.extendPointers ? (await this.getName(name)).pointers : [],
-    ...pointers.map(p => R.fromPairs([['id', p], ['key', classify(p)]]))
+    ...pointers.map(p => Object.fromEntries([['id', p], ['key', classify(p)]]))
   ].reduce((acc, el) => [...acc.filter(p => p.key !== el.key), el], [])
-  const nameUpdateTx = await this.nameUpdateTx(R.merge(opt, {
+  const nameUpdateTx = await this.nameUpdateTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt),
     pointers
-  }))
+  })
 
   return this.send(nameUpdateTx, opt)
 }
@@ -145,13 +146,14 @@ async function update (name, pointers = [], options = { extendPointers: false })
  */
 async function transfer (name, account, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
-  const nameTransferTx = await this.nameTransferTx(R.merge(opt, {
+  const nameTransferTx = await this.nameTransferTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt),
     recipientId: account
-  }))
+  })
 
   return this.send(nameTransferTx, opt)
 }
@@ -186,22 +188,22 @@ async function query (name, opt = {}) {
     pointers: o.pointers || [],
     update: async (pointers = [], options = {}) => {
       return {
-        ...(await this.aensUpdate(name, pointers, R.merge(opt, options))),
+        ...(await this.aensUpdate(name, pointers, { ...opt, ...options })),
         ...(await this.aensQuery(name))
       }
     },
     transfer: async (account, options = {}) => {
       return {
-        ...(await this.aensTransfer(name, account, R.merge(opt, options))),
+        ...(await this.aensTransfer(name, account, { ...opt, ...options })),
         ...(await this.aensQuery(name))
       }
     },
-    revoke: async (options = {}) => this.aensRevoke(name, R.merge(opt, options)),
+    revoke: async (options = {}) => this.aensRevoke(name, { ...opt, ...options }),
     extendTtl: async (nameTtl = NAME_TTL, options = {}) => {
       if (!nameTtl || typeof nameTtl !== 'number' || nameTtl > NAME_TTL) throw new Error('Ttl must be an number and less then 180000 blocks')
 
       return {
-        ...(await this.aensUpdate(name, o.pointers.map(p => p.id), { ...R.merge(opt, options), nameTtl })),
+        ...(await this.aensUpdate(name, o.pointers.map(p => p.id), { ...opt, ...options, nameTtl })),
         ...(await this.aensQuery(name))
       }
     }
@@ -233,18 +235,19 @@ async function query (name, opt = {}) {
  */
 async function claim (name, salt, options) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
   const minNameFee = getMinimumNameFee(name)
   if (opt.nameFee !== this.Ae.defaults.nameFee && minNameFee.gt(opt.nameFee)) {
     throw new Error(`the provided fee ${opt.nameFee} is not enough to execute the claim, required: ${minNameFee}`)
   }
   opt.nameFee = opt.nameFee !== this.Ae.defaults.nameFee ? opt.nameFee : minNameFee
-  const claimTx = await this.nameClaimTx(R.merge(opt, {
+  const claimTx = await this.nameClaimTx({
+    ...opt,
     accountId: await this.address(opt),
     nameSalt: salt,
     name: encode(name, 'nm')
-  }))
+  })
 
   const result = await this.send(claimTx, opt)
   if (!isAuctionName(name)) {
@@ -282,15 +285,16 @@ async function claim (name, salt, options) {
  */
 async function preclaim (name, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   const _salt = salt()
   const height = await this.height()
   const commitmentId = commitmentHash(name, _salt)
 
-  const preclaimTx = await this.namePreclaimTx(R.merge(opt, {
+  const preclaimTx = await this.namePreclaimTx({
+    ...opt,
     accountId: await this.address(opt),
     commitmentId
-  }))
+  })
 
   const result = await this.send(preclaimTx, opt)
 

package/src/ae/contract.js

@@ -27,87 +27,23 @@
  */
 
 import Ae from './'
-import * as R from 'ramda'
 import ContractCompilerAPI from '../contract/compiler'
 import ContractBase from '../contract'
 import getContractInstance from '../contract/aci'
 import NodePool from '../node-pool'
-import { AMOUNT, DEPOSIT, DRY_RUN_ACCOUNT, GAS, MIN_GAS_PRICE } from '../tx/builder/schema'
+import { AMOUNT, DEPOSIT, GAS, MIN_GAS_PRICE } from '../tx/builder/schema'
 import { decode, produceNameId } from '../tx/builder/helpers'
-import TxObject from '../tx/tx-object'
-
-async function _sendAndProcess (tx, source, name, options) {
-  const txData = await this.send(tx, options)
-  const result = { hash: txData.hash, tx: TxObject({ tx: txData.rawTx }), txData, rawTx: txData.rawTx }
-  if (options.waitMined === false) return result
-  const txInfo = await this.getTxInfo(txData.hash)
-  await this._handleCallError(source, name, txInfo)
-  return { ...result, result: txInfo }
-}
-
-/**
- * Handle contract call error
- * @function
- * @private
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source contract source code
- * @param {String} name name of called method
- * @param {Object} result call result object
- * @throws Error Decoded error
- * @return {Promise<void>}
- */
-async function _handleCallError (source, name, result) {
-  if (result.returnType === 'ok') return
-  const error = await this.contractDecodeCallResultAPI(source, name, result.returnValue, result.returnType)
-  const message = error[{ revert: 'abort' }[result.returnType] || result.returnType][0]
-  throw new Error(`Invocation failed${message ? `: "${message}"` : ''}`)
-}
-
-/**
- * Encode call data for contract call
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source Contract source code
- * @param {String} name Name of function to call
- * @param {Array} args Argument's for call
- * @param {Object} [options={}]  Options
- * @param {Object} [options.filesystem={}] Contract external namespaces map
-  * @return {Promise<String>}
- */
-async function contractEncodeCall (source, name, args, options) {
-  return this.contractEncodeCallDataAPI(source, name, args, options)
-}
-
-/**
- * Decode contract call result data
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source - source code
- * @param {String } fn - function name
- * @param {String} callValue - result call data
- * @param {String} callResult - result status
- * @param {Object} [options={}]  Options
- * @param {Object} [options.filesystem={}] Contract external namespaces map
- * @return {Promise<String>} Result object
- * @example
- * const decodedData = await client.contractDecodeData(SourceCode ,'functionName', 'cb_asdasdasd...', 'ok|revert')lt
- */
-async function contractDecodeData (source, fn, callValue, callResult, options) {
-  return this.contractDecodeCallResultAPI(source, fn, callValue, callResult, options)
-}
 
 /**
  * Static contract call(using dry-run)
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
+ * @deprecated
  * @param {String} source Contract source code
- * @param {String} address Contract address
+ * @param {String} contractAddress Contract address
  * @param {String} name Name of function to call
- * @param {Array|String} args Argument's or callData for call/deploy transaction
+ * @param {Array} args Arguments array for call/deploy transaction
  * @param {Object} [options]
  * @param {Number|String} [options.top] Block height or hash on which you want to call contract
  * @param {String} [options.bytecode] Block hash on which you want to call contract
@@ -120,39 +56,9 @@ async function contractDecodeData (source, fn, callValue, callResult, options) {
  *   decode: (type) => Decode call result
  * }
  */
-async function contractCallStatic (source, address, name, args = [], options = {}) {
-  const callerId = await this.address(options).catch(() => DRY_RUN_ACCOUNT.pub)
-  if (typeof options.top === 'number') {
-    options.top = (await this.getKeyBlock(options.top)).hash
-  }
-  const txOpt = {
-    ...this.Ae.defaults,
-    ...options,
-    callData: Array.isArray(args) ? await this.contractEncodeCall(source, name, args, options) : args,
-    nonce: options.top && (await this.getAccount(callerId, { hash: options.top })).nonce + 1
-  }
-  const tx = name === 'init'
-    ? (await this.contractCreateTx({
-      ...txOpt,
-      code: options.bytecode,
-      ownerId: callerId
-    })).tx
-    : await this.contractCallTx({
-      ...txOpt,
-      callerId,
-      contractId: await this.resolveName(address, 'ct', { resolveByNode: true })
-    })
-
-  const { callObj, ...dryRunOther } = await this.txDryRun(tx, callerId, options)
-
-  await this._handleCallError(source, name, callObj)
-  const { returnType, returnValue } = callObj
-  return {
-    ...dryRunOther,
-    tx: TxObject({ tx }),
-    result: callObj,
-    decode: () => this.contractDecodeData(source, name, returnValue, returnType, options)
-  }
+async function contractCallStatic (source, contractAddress, name, args = [], options) {
+  const contract = await this.getContractInstance({ ...options, source, contractAddress })
+  return contract.call(name, args, { ...options, callStatic: true })
 }
 
 /**
@@ -160,12 +66,14 @@ async function contractCallStatic (source, address, name, args = [], options = {
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
+ * @deprecated
  * @param {String} source Contract source code
- * @param {String} address Contract address or AENS name
+ * @param {String} contractAddress Contract address or AENS name
  * @param {String} name Name of function to call
- * @param {Array|String} argsOrCallData Argument's array or callData for call function
- * @param {Object} [options={}] Transaction options (fee, ttl, gas, amount, deposit)
- * @param {Object} [options.filesystem={}] Contract external namespaces map* @return {Promise<Object>} Result object
+ * @param {Array} args Arguments array for call/deploy transaction
+ * @param {Object} [options] Transaction options (fee, ttl, gas, amount, deposit)
+ * @param {Object} [options.filesystem] Contract external namespaces map
+ * @return {Promise<Object>} Result object
  * @example
  * const callResult = await client.contractCall(source, address, fnName, args = [], options)
  * {
@@ -174,23 +82,9 @@ async function contractCallStatic (source, address, name, args = [], options = {
  *   decode: (type) => Decode call result
  * }
  */
-async function contractCall (source, address, name, argsOrCallData = [], options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
-
-  const tx = await this.contractCallTx(R.merge(opt, {
-    callerId: await this.address(opt),
-    contractId: await this.resolveName(address, 'ct', { resolveByNode: true }),
-    callData: Array.isArray(argsOrCallData) ? await this.contractEncodeCall(source, name, argsOrCallData, opt) : argsOrCallData
-  }))
-
-  const { hash, rawTx, result, txData } = await this._sendAndProcess(tx, source, name, opt)
-  return {
-    hash,
-    rawTx,
-    result,
-    txData,
-    decode: () => result ? this.contractDecodeData(source, name, result.returnValue, result.returnType, opt) : {}
-  }
+async function contractCall (source, contractAddress, name, args, options) {
+  const contract = await this.getContractInstance({ ...options, source, contractAddress })
+  return contract.call(name, args, options)
 }
 
 /**
@@ -198,10 +92,11 @@ async function contractCall (source, address, name, argsOrCallData = [], options
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
+ * @deprecated
  * @param {String} code Compiled contract
  * @param {String} source Contract source code
- * @param {Array|String} initState Arguments of contract constructor(init) function. Can be array of arguments or callData string
- * @param {Object} [options={}] Transaction options (fee, ttl, gas, amount, deposit)
+ * @param {Array} params Arguments of contract constructor(init) function. Can be array of arguments or callData string
+ * @param {Object} [options] Transaction options (fee, ttl, gas, amount, deposit)
  * @param {Object} [options.filesystem={}] Contract external namespaces map* @return {Promise<Object>} Result object
  * @return {Promise<Object>} Result object
  * @example
@@ -216,31 +111,10 @@ async function contractCall (source, address, name, argsOrCallData = [], options
  *   callStatic: (fnName, args = [], options) => Static all contract function
  * }
  */
-async function contractDeploy (code, source, initState = [], options = {}) {
-  const opt = { ...this.Ae.defaults, ...options }
-  const callData = Array.isArray(initState) ? await this.contractEncodeCall(source, 'init', initState, opt) : initState
-  const ownerId = await this.address(opt)
-
-  const { tx, contractId } = await this.contractCreateTx(R.merge(opt, {
-    callData,
-    code,
-    ownerId
-  }))
-
-  const { hash, rawTx, result, txData } = await this._sendAndProcess(tx, source, 'init', opt)
-  return Object.freeze({
-    result,
-    owner: ownerId,
-    transaction: hash,
-    rawTx,
-    txData,
-    address: contractId,
-    call: (name, args, options) =>
-      this.contractCall(source, contractId, name, args, { ...opt, ...options }),
-    callStatic: (name, args, options) =>
-      this.contractCallStatic(source, contractId, name, args, { ...opt, ...options }),
-    createdAt: new Date()
-  })
+async function contractDeploy (code, source, params, options) {
+  const contract = await this.getContractInstance({ ...options, source })
+  contract.bytecode = code
+  return contract.deploy(params, options)
 }
 
 /**
@@ -264,7 +138,7 @@ async function contractCompile (source, options = {}) {
   const opt = { ...this.Ae.defaults, ...options }
   const bytecode = await this.compileContractAPI(source, options)
   return Object.freeze({
-    encodeCall: (name, args) => this.contractEncodeCall(source, name, args, opt),
+    encodeCall: (name, args) => this.contractEncodeCallDataAPI(source, name, args, opt),
     deploy: (init, options) => this.contractDeploy(bytecode, source, init, { ...opt, ...options }),
     deployStatic: (init, options) => this.contractCallStatic(source, null, 'init', init, {
       ...opt,
@@ -286,111 +160,65 @@ async function contractCompile (source, options = {}) {
  * @return {Promise<String>} Signature in hex representation
  */
 async function delegateSignatureCommon (ids = [], opt = {}) {
-  return this.sign(
-    Buffer.concat(
-      [
-        Buffer.from(this.getNetworkId(opt)),
-        decode(await this.address(opt)),
-        ...ids.map(e => decode(e))
-      ]
-    ),
+  const signature = await this.sign(
+    Buffer.concat([
+      Buffer.from(this.getNetworkId(opt)),
+      ...(Object.prototype.hasOwnProperty.call(opt, 'onAccount') ? [decode(await this.address(opt))] : []),
+      ...ids.map(e => decode(e))
+    ]),
     opt
-  ).then(s => Buffer.from(s).toString('hex'))
-}
-
-/**
- * Helper to generate a signature to delegate a name pre-claim to a contract.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} contractId Contract Id
- * @param {{ onAccount: String | Object }} [opt={}] opt Options
- * @return {Promise<String>} Signature for delegation
- */
-async function delegateNamePreclaimSignature (contractId, opt = {}) {
-  return this.delegateSignatureCommon([contractId], opt)
-}
-
-/**
- * Helper to generate a signature to delegate a name claim to a contract.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} name The name being claimed
- * @param {String} contractId Contract Id
- * @param {{ onAccount: String | Object }} [opt={}] opt Options
- * @return {Promise<String>} Signature for delegation
- */
-async function delegateNameClaimSignature (contractId, name, opt = {}) {
-  return this.delegateSignatureCommon([produceNameId(name), contractId], opt)
-}
-
-/**
- * Helper to generate a signature to delegate a name transfer to a contract.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} contractId Contract Id
- * @param {String} name The name being transferred
- * @param {{ onAccount: String | Object }} [opt={}] opt Options
- * @return {Promise<String>} Signature for delegation
- */
-async function delegateNameTransferSignature (contractId, name, opt = {}) {
-  return this.delegateSignatureCommon([produceNameId(name), contractId], opt)
+  )
+  return Buffer.from(signature).toString('hex')
 }
 
 /**
- * Helper to generate a signature to delegate a name revoke to a contract.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} contractId Contract Id
- * @param {String} name The name being revoked
- * @param {{ onAccount: String | Object }} [opt={}] opt Options
- * @return {Promise<String>} Signature for delegation
- */
-async function delegateNameRevokeSignature (contractId, name, opt = {}) {
-  return this.delegateSignatureCommon([produceNameId(name), contractId], opt)
-}
-
-/**
- * Helper to generate a signature to delegate a Oracle register to a contract.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} contractId Contract Id
- * @param {{ onAccount: String | Object }} [opt={}] opt Options
- * @return {Promise<String>} Signature for delegation
- */
-async function delegateOracleRegisterSignature (contractId, opt = {}) {
-  return this.delegateSignatureCommon([contractId], opt)
-}
-
-/**
- * Helper to generate a signature to delegate a Oracle extend to a contract.
+ * Helper to generate a signature to delegate pre-claim/claim/transfer/revoke of a name to a contract.
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
  * @param {String} contractId Contract Id
+ * @param {String} [name] The name
  * @param {{ onAccount: String | Object }} [opt={}] opt Options
  * @return {Promise<String>} Signature for delegation
+ * @example
+ * const client = await Universal({ ... })
+ * const contractId = 'ct_asd2ks...' // contract address
+ * const name = 'example.chain' // AENS name
+ * const onAccount = await client.address() // Sign with a specific account
+ * // Preclaim signature
+ * const params = { contractId }
+ * const preclaimSig = await client.createAensDelegationSignature(params, { onAccount: current })
+ * // Claim, transfer and revoke signature
+ * const params = { contractId, name }
+ * const aensDelegationSig = await contract.createAensDelegationSignature(params, name, { onAccount: current })
  */
-async function delegateOracleExtendSignature (contractId, opt = {}) {
-  return this.delegateSignatureCommon([contractId], opt)
+async function createAensDelegationSignature ({ contractId, name }, opt = {}) {
+  return this.delegateSignatureCommon([...name ? [produceNameId(name)] : [], contractId], opt)
 }
 
 /**
- * Helper to generate a signature to delegate a Oracle respond to a contract.
+ * Helper to generate a signature to delegate register/extend/respond of a Oracle to a contract.
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
- * @param {String} queryId Oracle Query Id
  * @param {String} contractId Contract Id
+ * @param {String} [queryId] Oracle Query Id
  * @param {{ onAccount: String | Object }} [opt={}] opt Options
  * @return {Promise<String>} Signature for delegation
+ * @example
+ * const client = await Universal({ ... })
+ * const contractId = 'ct_asd2ks...' // contract address
+ * const queryId = 'oq_...' // Oracle Query Id
+ * const onAccount = await client.address() // Sign with a specific account
+ * // Oracle register and extend signature
+ * const params = { contractId }
+ * const oracleDelegationSig = await contract.createOracleDelegationSignature(params, { onAccount })
+ * // Oracle respond signature
+ * const params = { contractId, queryId }
+ * const respondSig = await contract.createOracleDelegationSignature(params, queryId)
  */
-async function delegateOracleRespondSignature (queryId, contractId, opt = {}) {
-  return this.delegateSignatureCommon([queryId, contractId], opt)
+async function createOracleDelegationSignature ({ contractId, queryId }, opt = {}) {
+  return this.delegateSignatureCommon([...queryId ? [queryId] : [], contractId], opt)
 }
 
 /**
@@ -429,21 +257,12 @@ export const ContractAPI = Ae.compose(ContractBase, {
     contractCallStatic,
     contractDeploy,
     contractCall,
-    contractEncodeCall,
-    contractDecodeData,
-    _handleCallError,
-    _sendAndProcess,
     // Delegation for contract
-    // AENS
     delegateSignatureCommon,
-    delegateNamePreclaimSignature,
-    delegateNameClaimSignature,
-    delegateNameTransferSignature,
-    delegateNameRevokeSignature,
+    // AENS
+    createAensDelegationSignature,
     // Oracle
-    delegateOracleRegisterSignature,
-    delegateOracleExtendSignature,
-    delegateOracleRespondSignature
+    createOracleDelegationSignature
   },
   deepProps: {
     Ae: {

package/src/ae/index.js

@@ -27,7 +27,6 @@ import Tx from '../tx'
 import Chain from '../chain'
 import AccountBase from '../account/base'
 import TxBuilder from '../tx/builder'
-import * as R from 'ramda'
 import BigNumber from 'bignumber.js'
 import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
 
@@ -38,16 +37,20 @@ import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
  * @rtype (tx: String, options: Object) => Promise[String]
  * @param {String} tx - Transaction
  * @param {Object} [options={}] options - Options
- * @param {Object} [options.verify] verify - Verify transaction before broadcast, throw error if not valid
+ * @param {Object} [options.verify=true] verify - Verify transaction before broadcast, throw error if not valid
  * @return {Object} Transaction
  */
 async function send (tx, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
-  const { contractId: gaId, authFun } = await this.getAccount(await this.address(opt))
-  const signed = gaId
+  const opt = { ...this.Ae.defaults, ...options }
+  const { contractId, authFun } = options.innerTx
+    ? { contractId: false }
+    : await this.getAccount(await this.address(opt))
+  const signed = contractId
     ? await this.signUsingGA(tx, { ...opt, authFun })
     : await this.signTransaction(tx, opt)
-  return this.sendTransaction(signed, opt)
+  return opt.innerTx
+    ? { hash: TxBuilder.buildTxHash(signed), rawTx: signed }
+    : this.sendTransaction(signed, opt)
 }
 
 async function signUsingGA (tx, { authData, authFun, ...options } = {}) {
@@ -105,6 +108,27 @@ async function transferFunds (fraction, recipientIdOrName, options) {
   return this.send(await this.spendTx({ ...opt, senderId, recipientId, amount }), opt)
 }
 
+/**
+ * Submit transaction of another account paying for it (fee and gas)
+ * @instance
+ * @category async
+ * @rtype (transaction: String, options?: Object) => Promise[String]
+ * @param {String} transaction - tx_<base64>-encoded transaction
+ * @param {Object} [options]
+ * @return {Object} Transaction
+ */
+async function payForTransaction (transaction, options) {
+  const opt = { ...this.Ae.defaults, ...options }
+  return this.send(
+    await this.payingForTx({
+      ...opt,
+      payerId: await this.address(opt),
+      tx: transaction
+    }),
+    opt
+  )
+}
+
 /**
  * Remove all listeners for RPC
  * @instance
@@ -135,7 +159,7 @@ function destroyInstance () {
  * @return {Object} Ae instance
  */
 const Ae = stampit(Tx, AccountBase, Chain, {
-  methods: { send, spend, transferFunds, destroyInstance, signUsingGA },
+  methods: { send, spend, transferFunds, payForTransaction, destroyInstance, signUsingGA },
   deepProps: { Ae: { defaults: { denomination: AE_AMOUNT_FORMATS.AETTOS } } }
 })