@bsv/wallet-toolbox 1.3.22 → 1.3.24

package/src/services/chaintracker/chaintracks/util/dirtyHashes.ts

@@ -0,0 +1,29 @@
+/**
+ * These hashes are for blocks that are to known to have violated the Bitcoin
+ * protocol. Regardless of the amount of proof-of-work that chains built on top
+ * of them may have accumulated, they cannot be considered valid Bitcoin blocks.
+ *
+ * In the first instance, segregating witness data from transactions is not
+ * part of the design of Bitcoin.
+ *
+ * In the second instance, adding new opcodes to be used when evaluating
+ * scripts is also not allowed.
+ */
+export const dirtyHashes = {
+  // Block 478,558 with hash of 0000000000000000011865af4122fe3b144e2cbeea86142e8ff2fb4107352d43 was the last block shared by BSV, BCH and BTC
+  // Block 478,559 with hash of 00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148 was the first block of the BTC Segwit chain.
+  // Block 478,559 with hash of 000000000000000000651ef99cb9fcbe0dadde1d424bd9f15ff20136191a5eec was the valid Bitcoin block shared by BSV and BCH.
+  '00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148':
+    'This is the first header of the invalid SegWit chain.',
+  '0000000000000000004626ff6e3b936941d341c5932ece4357eeccac44e6d56c':
+    'This is the first header of the invalid ABC chain.'
+}
+
+/**
+ * Throws Error if blockHash is in the dirtyHashes list.
+ */
+export function validateAgainstDirtyHashes(blockHash: string): void {
+  if (dirtyHashes[blockHash]) {
+    throw new Error(`Not adding a header with a dirty hash: ${dirtyHashes[blockHash]}`)
+  }
+}

package/src/signer/methods/internalizeAction.ts

@@ -39,7 +39,7 @@ export async function internalizeAction(
   wallet: Wallet,
   auth: sdk.AuthId,
   args: InternalizeActionArgs
-): Promise<InternalizeActionResult> {
+): Promise<sdk.StorageInternalizeActionResult> {
   const vargs = sdk.validateInternalizeActionArgs(args)
 
   const { ab, tx, txid } = await validateAtomicBeef()
@@ -60,7 +60,7 @@ export async function internalizeAction(
     }
   }
 
-  const r: InternalizeActionResult = await wallet.storage.internalizeAction(args)
+  const r: sdk.StorageInternalizeActionResult = await wallet.storage.internalizeAction(args)
 
   return r
 

package/src/storage/StorageIdb.ts

@@ -1,7 +1,6 @@
 import { deleteDB, IDBPCursorWithValue, IDBPDatabase, IDBPTransaction, openDB } from 'idb'
 import { ListActionsResult, ListOutputsResult } from '@bsv/sdk'
 import {
-  sdk,
   TableCertificate,
   TableCertificateField,
   TableCertificateX,
@@ -18,10 +17,10 @@ import {
   TableTransaction,
   TableTxLabel,
   TableTxLabelMap,
-  TableUser,
-  verifyOne,
-  verifyOneOrNone
-} from '../index.client'
+  TableUser
+} from './schema/tables'
+import * as sdk from '../sdk/index'
+import { verifyOne, verifyOneOrNone } from '../utility/utilityHelpers'
 import { StorageAdminStats, StorageProvider, StorageProviderOptions } from './StorageProvider'
 import { StorageIdbSchema } from './schema/StorageIdbSchema'
 import { DBType } from './StorageReader'

package/src/storage/StorageKnex.ts

@@ -1,7 +1,6 @@
-import { ListActionsResult, ListOutputsResult, Transaction } from '@bsv/sdk'
+import { ListActionsResult, ListOutputsResult } from '@bsv/sdk'
 import { sdk, verifyOne, verifyOneOrNone, verifyTruthy } from '../index.all'
 import {
-  KnexMigrations,
   outputColumnsWithoutLockingScript,
   TableCertificate,
   TableCertificateField,
@@ -12,7 +11,6 @@ import {
   TableOutputBasket,
   TableOutputTag,
   TableOutputTagMap,
-  TableOutputX,
   TableProvenTx,
   TableProvenTxReq,
   TableSettings,
@@ -22,8 +20,8 @@ import {
   TableTxLabelMap,
   TableUser,
   transactionColumnsWithoutRawTx
-} from './index.all'
-
+} from './schema/tables'
+import { KnexMigrations } from './schema/KnexMigrations'
 import { Knex } from 'knex'
 import { StorageAdminStats, StorageProvider, StorageProviderOptions } from './StorageProvider'
 import { purgeData } from './methods/purgeData'
@@ -797,7 +795,10 @@ export class StorageKnex extends StorageProvider implements sdk.WalletStoragePro
     for (let i = 0; i < count; i++) {
       try {
         const r = await this.knex.migrate.down(config)
-        expect(r).toBeTruthy()
+        if (!r) {
+          console.error(`Migration returned falsy result await this.knex.migrate.down(config)`)
+          break
+        }
       } catch (eu: unknown) {
         break
       }

package/src/storage/StorageProvider.ts

@@ -170,7 +170,7 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     return r
   }
 
-  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult> {
+  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
     return await internalizeAction(this, auth, args)
   }
 
@@ -413,9 +413,10 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     mergeToBeef?: Beef,
     trustSelf?: TrustSelf,
     knownTxids?: string[],
-    trx?: sdk.TrxToken
+    trx?: sdk.TrxToken,
+    requiredLevels?: number
   ): Promise<Beef> {
-    const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx)
+    const beef = await this.getValidBeefForTxid(txid, mergeToBeef, trustSelf, knownTxids, trx, requiredLevels)
     if (!beef) throw new sdk.WERR_INVALID_PARAMETER('txid', `${txid} is not known to storage.`)
     return beef
   }
@@ -425,43 +426,50 @@ export abstract class StorageProvider extends StorageReaderWriter implements sdk
     mergeToBeef?: Beef,
     trustSelf?: TrustSelf,
     knownTxids?: string[],
-    trx?: sdk.TrxToken
+    trx?: sdk.TrxToken,
+    requiredLevels?: number
   ): Promise<Beef | undefined> {
     const beef = mergeToBeef || new Beef()
 
     const r = await this.getProvenOrRawTx(txid, trx)
     if (r.proven) {
-      if (trustSelf === 'known') beef.mergeTxidOnly(txid)
-      else {
-        beef.mergeRawTx(r.proven.rawTx)
-        const mp = new EntityProvenTx(r.proven).getMerklePath()
-        beef.mergeBump(mp)
-        return beef
+      if (requiredLevels) {
+        r.rawTx = r.proven.rawTx
+      } else {
+        if (trustSelf === 'known') beef.mergeTxidOnly(txid)
+        else {
+          beef.mergeRawTx(r.proven.rawTx)
+          const mp = new EntityProvenTx(r.proven).getMerklePath()
+          beef.mergeBump(mp)
+          return beef
+        }
       }
     }
 
-    if (r.rawTx && r.inputBEEF) {
-      if (trustSelf === 'known') beef.mergeTxidOnly(txid)
-      else {
-        beef.mergeRawTx(r.rawTx)
-        beef.mergeBeef(r.inputBEEF)
-        const tx = Transaction.fromBinary(r.rawTx)
-        for (const input of tx.inputs) {
-          const btx = beef.findTxid(input.sourceTXID!)
-          if (!btx) {
-            if (knownTxids && knownTxids.indexOf(input.sourceTXID!) > -1) beef.mergeTxidOnly(input.sourceTXID!)
-            else await this.getValidBeefForKnownTxid(input.sourceTXID!, beef, trustSelf, knownTxids, trx)
-          }
+    if (!r.rawTx) return undefined
+
+    if (trustSelf === 'known') {
+      beef.mergeTxidOnly(txid)
+    } else {
+      beef.mergeRawTx(r.rawTx)
+      if (r.inputBEEF) beef.mergeBeef(r.inputBEEF)
+      const tx = Transaction.fromBinary(r.rawTx)
+      if (requiredLevels) requiredLevels--
+      for (const input of tx.inputs) {
+        const btx = beef.findTxid(input.sourceTXID!)
+        if (!btx) {
+          if (!requiredLevels && knownTxids && knownTxids.indexOf(input.sourceTXID!) > -1)
+            beef.mergeTxidOnly(input.sourceTXID!)
+          else await this.getValidBeefForKnownTxid(input.sourceTXID!, beef, trustSelf, knownTxids, trx, requiredLevels)
         }
-        return beef
       }
     }
-
-    return undefined
+    return beef
   }
 
   async getBeefForTransaction(txid: string, options: sdk.StorageGetBeefOptions): Promise<Beef> {
-    return await getBeefForTransaction(this, txid, options)
+    const beef = await getBeefForTransaction(this, txid, options)
+    return beef
   }
 
   async findMonitorEventById(id: number, trx?: sdk.TrxToken): Promise<TableMonitorEvent | undefined> {

package/src/storage/StorageReader.ts

@@ -1,6 +1,4 @@
 import {
-  sdk,
-  TableCertificate,
   TableCertificateField,
   TableCertificateX,
   TableCommission,
@@ -16,11 +14,10 @@ import {
   TableTransaction,
   TableTxLabel,
   TableTxLabelMap,
-  TableUser,
-  validateSecondsSinceEpoch,
-  verifyOneOrNone,
-  verifyTruthy
-} from '../index.client'
+  TableUser
+} from './schema/tables'
+import * as sdk from '../sdk/index'
+import { validateSecondsSinceEpoch, verifyOneOrNone, verifyTruthy } from '../utility/utilityHelpers'
 import { getSyncChunk } from './methods/getSyncChunk'
 
 /**

package/src/storage/StorageReaderWriter.ts

@@ -1,6 +1,4 @@
 import {
-  randomBytesBase64,
-  sdk,
   TableCertificate,
   TableCertificateField,
   TableCommission,
@@ -15,12 +13,10 @@ import {
   TableTransaction,
   TableTxLabel,
   TableTxLabelMap,
-  TableUser,
-  verifyId,
-  verifyOne,
-  verifyOneOrNone,
-  verifyTruthy
-} from '../index.client'
+  TableUser
+} from './schema/tables'
+import { randomBytesBase64, verifyOneOrNone, verifyId, verifyOne } from '../utility/utilityHelpers'
+import * as sdk from '../sdk/index'
 import { createSyncMap } from './schema/entities'
 import { StorageReader, StorageReaderOptions } from './StorageReader'
 

package/src/storage/StorageSyncReader.ts

@@ -1,22 +1,5 @@
-import {
-  sdk,
-  TableCertificate,
-  TableCertificateField,
-  TableCertificateX,
-  TableCommission,
-  TableOutput,
-  TableOutputBasket,
-  TableOutputTag,
-  TableOutputTagMap,
-  TableProvenTx,
-  TableProvenTxReq,
-  TableSettings,
-  TableSyncState,
-  TableTransaction,
-  TableTxLabel,
-  TableTxLabelMap,
-  TableUser
-} from '../index.client'
+import * as sdk from '../sdk/index'
+import { TableSettings } from '../storage/schema/tables/TableSettings'
 import { StorageReader } from './StorageReader'
 
 /**

package/src/storage/WalletStorageManager.ts

@@ -438,7 +438,7 @@ export class WalletStorageManager implements sdk.WalletStorage {
       return await writer.createAction(auth, vargs)
     })
   }
-  async internalizeAction(args: InternalizeActionArgs): Promise<InternalizeActionResult> {
+  async internalizeAction(args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
     sdk.validateInternalizeActionArgs(args)
     return await this.runAsWriter(async writer => {
       const auth = await this.getAuth(true)

package/src/storage/__test/StorageIdb.test.ts

@@ -17,6 +17,7 @@ describe('StorageIdb tests', () => {
   })
 
   test('1', async () => {
+    // TODO: THIS TEST PASSES WHEN Describe is run alone, but fails to exit cleanly when run with `npm run test`
     if (Setup.noEnv('test')) return
     const env = Setup.getEnv('test')
     const wallet = await SetupClient.createWalletClientNoEnv({

package/src/storage/__test/adminStats.man.test.ts

@@ -4,6 +4,7 @@ import { Setup } from '../../Setup'
 import { StorageKnex } from '../StorageKnex'
 import { AuthFetch, WalletInterface } from '@bsv/sdk'
 import { StorageAdminStats, StorageClient } from '../index.client'
+import { Format } from '../../utility/Format'
 
 describe('storage adminStats tests', () => {
   jest.setTimeout(99999999)
@@ -36,6 +37,7 @@ describe('storage adminStats tests', () => {
 
   test('0 adminStats StorageKnex', async () => {
     const r = await storage.adminStats(env.identityKey)
+    console.log(Format.toLogStringAdminStats(r))
     expect(r.requestedBy).toBe(env.identityKey)
     expect(r.usersTotal).toBeGreaterThan(0)
   })

package/src/storage/index.mobile.ts

@@ -3,4 +3,4 @@ export * from './StorageProvider'
 export * from './StorageSyncReader'
 export * from './schema/tables/index'
 export * from './schema/entities/index'
-export * from './remoting/StorageClient'
+export * from './remoting/StorageMobile'

package/src/storage/methods/generateChange.ts

@@ -1,4 +1,5 @@
 import { sdk, validateStorageFeeModel } from '../../index.client'
+import { transactionSize } from './utils'
 
 /**
  * An output of this satoshis amount will be adjusted to the largest fundable amount.
@@ -545,57 +546,3 @@ export function generateChangeSdkMakeStorage(availableChange: GenerateChangeSdkC
 
   return { allocateChangeInput, releaseChangeInput, getLog }
 }
-
-/**
- * Returns the byte size required to encode number as Bitcoin VarUint
- * @publicbody
- */
-export function varUintSize(val: number): 1 | 3 | 5 | 9 {
-  if (val < 0) throw new sdk.WERR_INVALID_PARAMETER('varUint', 'non-negative')
-  return val <= 0xfc ? 1 : val <= 0xffff ? 3 : val <= 0xffffffff ? 5 : 9
-}
-
-/**
- * @param scriptSize byte length of input script
- * @returns serialized byte length a transaction input
- */
-export function transactionInputSize(scriptSize: number): number {
-  return (
-    32 + // txid
-    4 + // vout
-    varUintSize(scriptSize) + // script length, this is already in bytes
-    scriptSize + // script
-    4
-  ) // sequence number
-}
-
-/**
- * @param scriptSize byte length of output script
- * @returns serialized byte length a transaction output
- */
-export function transactionOutputSize(scriptSize: number): number {
-  return (
-    varUintSize(scriptSize) + // output script length, from script encoded as hex string
-    scriptSize + // output script
-    8
-  ) // output amount (satoshis)
-}
-
-/**
- * Compute the serialized binary transaction size in bytes
- * given the number of inputs and outputs,
- * and the size of each script.
- * @param inputs array of input script lengths, in bytes
- * @param outputs array of output script lengths, in bytes
- * @returns total transaction size in bytes
- */
-export function transactionSize(inputs: number[], outputs: number[]): number {
-  return (
-    4 + // Version
-    varUintSize(inputs.length) + // Number of inputs
-    inputs.reduce((a, e) => a + transactionInputSize(e), 0) + // all inputs
-    varUintSize(outputs.length) + // Number of outputs
-    outputs.reduce((a, e) => a + transactionOutputSize(e), 0) + // all outputs
-    4
-  ) // lock time
-}

package/src/storage/methods/getBeefForTransaction.ts

@@ -71,7 +71,15 @@ async function mergeBeefForTransactionRecurse(
 
   if (!options.ignoreStorage) {
     // if we can use storage, ask storage if it has the txid
-    const knownBeef = await storage.getValidBeefForTxid(txid, beef, options.trustSelf, options.knownTxids)
+    const requiredLevels = options.minProofLevel === undefined ? undefined : options.minProofLevel + recursionDepth
+    const knownBeef = await storage.getValidBeefForTxid(
+      txid,
+      beef,
+      options.trustSelf,
+      options.knownTxids,
+      undefined,
+      requiredLevels
+    )
     if (knownBeef) return knownBeef
   }
 
@@ -82,7 +90,7 @@ async function mergeBeefForTransactionRecurse(
   // to find it and if it has a proof, remember it.
   const r = await getProvenOrRawTxFromServices(storage, txid, options)
 
-  if (r.proven && options.minProofLevel && options.minProofLevel > recursionDepth) {
+  if (r.proven && options.minProofLevel !== undefined && options.minProofLevel > recursionDepth) {
     // ignore proof at this recursion depth
     r.proven = undefined
   }

package/src/storage/methods/internalizeAction.ts

@@ -5,7 +5,6 @@ import {
   WalletPayment,
   BasketInsertion,
   InternalizeActionArgs,
-  InternalizeActionResult,
   TransactionOutput,
   Beef
 } from '@bsv/sdk'
@@ -13,7 +12,6 @@ import {
   EntityProvenTxReq,
   randomBytesBase64,
   sdk,
-  stampLog,
   StorageProvider,
   TableOutput,
   TableOutputBasket,
@@ -22,15 +20,7 @@ import {
   verifyOne,
   verifyOneOrNone
 } from '../../index.client'
-
-export interface StorageInternalizeActionResult extends InternalizeActionResult {
-  /** true if internalizing outputs on an existing storage transaction */
-  isMerge: boolean
-  /** txid of transaction being internalized */
-  txid: string
-  /** net change in change balance for user due to this internalization */
-  satoshis: number
-}
+import { shareReqsWithWorld } from './processAction'
 
 /**
  * Internalize Action allows a wallet to take ownership of outputs in a pre-existing transaction.
@@ -62,7 +52,7 @@ export async function internalizeAction(
   storage: StorageProvider,
   auth: sdk.AuthId,
   args: InternalizeActionArgs
-): Promise<InternalizeActionResult> {
+): Promise<sdk.StorageInternalizeActionResult> {
   const ctx = new InternalizeActionContext(storage, auth, args)
   await ctx.asyncSetup()
 
@@ -94,7 +84,7 @@ interface WalletPaymentX extends WalletPayment {
 
 class InternalizeActionContext {
   /** result to be returned */
-  r: StorageInternalizeActionResult
+  r: sdk.StorageInternalizeActionResult
   /** the parsed input AtomicBEEF */
   ab: Beef
   /** the incoming transaction extracted from AtomicBEEF */
@@ -356,11 +346,29 @@ class InternalizeActionContext {
     // transaction record for user is new, but the txid may not be new to storage
     // make sure storage pursues getting a proof for it.
     const newReq = EntityProvenTxReq.fromTxid(this.txid, this.tx.toBinary(), this.args.tx)
-    newReq.status = 'unmined'
+    // this status is only relevant if the transaction is new to storage.
+    newReq.status = 'unprocessed'
+    // this history and notify will be merged into an existing req if it exists.
     newReq.addHistoryNote({ what: 'internalizeAction', userId: this.userId })
     newReq.addNotifyTransactionId(transactionId)
     const pr = await this.storage.getProvenOrReq(this.txid, newReq.toApi())
 
+    if (pr.isNew) {
+      // This storage doesn't know about this txid yet.
+
+      // TODO Can we immediately prove this txid?
+
+      // Attempt to broadcast it to the network, throwing an error if it fails.
+
+      const { swr, ndr } = await shareReqsWithWorld(this.storage, this.userId, [this.txid], false)
+      if (ndr![0].status !== 'success') {
+        this.r.sendWithResults = swr
+        this.r.notDelayedResults = ndr
+        // abort the internalize action, WERR_REVIEW_ACTIONS exception will be thrown
+        return
+      }
+    }
+
     await this.addLabels(transactionId)
 
     for (const payment of this.walletPayments) {

package/src/storage/methods/processAction.ts

@@ -108,7 +108,7 @@ export interface PostBeefResultForTxidApi {
  * @param txids
  * @param isDelayed
  */
-async function shareReqsWithWorld(
+export async function shareReqsWithWorld(
   storage: StorageProvider,
   userId: number,
   txids: string[],
@@ -154,7 +154,10 @@ async function shareReqsWithWorld(
   // If isDelayed, this (or a different beef) will have to be rebuilt at the time of sending.
   if (readyToSendReqs.length > 0) {
     const beefIsValid = await r.beef.verify(await storage.getServices().getChainTracker())
-    if (!beefIsValid) throw new sdk.WERR_INTERNAL(`merged Beef failed validation.`)
+    if (!beefIsValid) {
+      console.log(`VERIFY FALSE BEEF: ${r.beef.toLogString()}`)
+      throw new sdk.WERR_INTERNAL(`merged Beef failed validation.`)
+    }
   }
 
   // Set req batch property for the reqs being sent

package/src/storage/methods/utils.Buffer.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns a copy of a Buffer with byte order reversed.
+ * @returns new buffer with byte order reversed.
+ * @publicbody
+ */
+export function swapByteOrder(buffer: Buffer): Buffer {
+  return Buffer.from(buffer).reverse()
+}
+
+/**
+ * @param num a number value in the Uint32 value range
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns four byte buffer with Uint32 number encoded
+ * @publicbody
+ */
+export function convertUint32ToBuffer(num: number, littleEndian = true): Buffer {
+  const arr = new ArrayBuffer(4)
+  const view = new DataView(arr)
+  view.setUint32(0, num, littleEndian) // byteOffset = 0
+  return Buffer.from(arr)
+}
+
+/**
+ * @param buffer four byte buffer with Uint32 number encoded
+ * @param littleEndian true for little-endian byte order in Buffer
+ * @returns a number value in the Uint32 value range
+ * @publicbody
+ */
+export function convertBufferToUint32(buffer: Buffer, littleEndian = true): number {
+  const arr = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+  const view = new DataView(arr)
+  return view.getUint32(0, littleEndian)
+}

package/src/storage/methods/utils.ts

@@ -0,0 +1,56 @@
+import { sdk } from '../../index.client'
+
+/**
+ * Returns the byte size required to encode number as Bitcoin VarUint
+ * @publicbody
+ */
+export function varUintSize(val: number): 1 | 3 | 5 | 9 {
+  if (val < 0) throw new sdk.WERR_INVALID_PARAMETER('varUint', 'non-negative')
+  return val <= 0xfc ? 1 : val <= 0xffff ? 3 : val <= 0xffffffff ? 5 : 9
+}
+
+/**
+ * @param scriptSize byte length of input script
+ * @returns serialized byte length a transaction input
+ */
+export function transactionInputSize(scriptSize: number): number {
+  return (
+    32 + // txid
+    4 + // vout
+    varUintSize(scriptSize) + // script length, this is already in bytes
+    scriptSize + // script
+    4
+  ) // sequence number
+}
+
+/**
+ * @param scriptSize byte length of output script
+ * @returns serialized byte length a transaction output
+ */
+
+export function transactionOutputSize(scriptSize: number): number {
+  return (
+    varUintSize(scriptSize) + // output script length, from script encoded as hex string
+    scriptSize + // output script
+    8
+  ) // output amount (satoshis)
+}
+
+/**
+ * Compute the serialized binary transaction size in bytes
+ * given the number of inputs and outputs,
+ * and the size of each script.
+ * @param inputs array of input script lengths, in bytes
+ * @param outputs array of output script lengths, in bytes
+ * @returns total transaction size in bytes
+ */
+export function transactionSize(inputs: number[], outputs: number[]): number {
+  return (
+    4 + // Version
+    varUintSize(inputs.length) + // Number of inputs
+    inputs.reduce((a, e) => a + transactionInputSize(e), 0) + // all inputs
+    varUintSize(outputs.length) + // Number of outputs
+    outputs.reduce((a, e) => a + transactionOutputSize(e), 0) + // all outputs
+    4
+  ) // lock time
+}

package/src/storage/remoting/StorageClient.ts

@@ -13,7 +13,6 @@ import {
 } from '@bsv/sdk'
 import {
   sdk,
-  TableCertificate,
   TableCertificateX,
   TableOutput,
   TableOutputBasket,
@@ -196,8 +195,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
    * @param args Original wallet `internalizeAction` arguments.
    * @returns `internalizeAction` results
    */
-  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<InternalizeActionResult> {
-    return this.rpcCall<InternalizeActionResult>('internalizeAction', [auth, args])
+  async internalizeAction(auth: sdk.AuthId, args: InternalizeActionArgs): Promise<sdk.StorageInternalizeActionResult> {
+    return this.rpcCall<sdk.StorageInternalizeActionResult>('internalizeAction', [auth, args])
   }
 
   /**