@exodus/sui-api 1.0.1 → 1.0.3

package/src/vendors/experimental/transports/jsonRPC.js

@@ -2,16 +2,10 @@
 
 import { vendorLib } from '@exodus/sui-lib'
 
-import { Transaction } from '../../transactions/Transaction.js'
-import { TransactionDataBuilder } from '../../transactions/TransactionData.js'
 import { Experimental_CoreClient } from '../core.js'
-import { ObjectError } from '../errors.js'
 import { suiClientResolveTransactionPlugin } from './json-rpc-resolver.js'
-import { parseTransactionBcs, parseTransactionEffectsBcs } from './utils.js'
 
 const { bcs } = vendorLib
-const { chunk } = vendorLib.utils
-const { fromBase64 } = vendorLib.bcs
 
 export class JSONRpcTransport extends Experimental_CoreClient {
   #jsonRpcClient
@@ -21,62 +15,6 @@ export class JSONRpcTransport extends Experimental_CoreClient {
     this.#jsonRpcClient = jsonRpcClient
   }
 
-  async getObjects(options) {
-    const batches = chunk(options.objectIds, 50)
-    const results = []
-
-    for (const batch of batches) {
-      const objects = await this.#jsonRpcClient.multiGetObjects({
-        ids: batch,
-        options: {
-          showOwner: true,
-          showType: true,
-          showBcs: true,
-        },
-        signal: options.signal,
-      })
-
-      for (const [idx, object] of objects.entries()) {
-        if (object.error) {
-          results.push(ObjectError.fromResponse(object.error, batch[idx]))
-        } else {
-          results.push(parseObject(object.data))
-        }
-      }
-    }
-
-    return {
-      objects: results,
-    }
-  }
-
-  async getOwnedObjects(options) {
-    const objects = await this.#jsonRpcClient.getOwnedObjects({
-      owner: options.address,
-      limit: options.limit,
-      cursor: options.cursor,
-      options: {
-        showOwner: true,
-        showType: true,
-        showBcs: true,
-      },
-      filter: options.type ? { StructType: options.type } : null,
-      signal: options.signal,
-    })
-
-    return {
-      objects: objects.data.map((result) => {
-        if (result.error) {
-          throw ObjectError.fromResponse(result.error, options.address)
-        }
-
-        return parseObject(result.data)
-      }),
-      hasNextPage: objects.hasNextPage,
-      cursor: objects.nextCursor ?? null,
-    }
-  }
-
   async getCoins(options) {
     const coins = await this.#jsonRpcClient.getCoins({
       owner: options.address,
@@ -144,67 +82,6 @@ export class JSONRpcTransport extends Experimental_CoreClient {
     }
   }
 
-  async getTransaction(options) {
-    const transaction = await this.#jsonRpcClient.getTransactionBlock({
-      digest: options.digest,
-      options: {
-        showRawInput: true,
-        showObjectChanges: true,
-        showRawEffects: true,
-        showEvents: true,
-        showEffects: true,
-      },
-      signal: options.signal,
-    })
-
-    return {
-      transaction: parseTransaction(transaction),
-    }
-  }
-
-  async executeTransaction(options) {
-    const transaction = await this.#jsonRpcClient.executeTransactionBlock({
-      transactionBlock: options.transaction,
-      signature: options.signatures,
-      options: {
-        showRawEffects: true,
-        showEvents: true,
-        showObjectChanges: true,
-        showRawInput: true,
-        showEffects: true,
-      },
-      signal: options.signal,
-    })
-
-    return {
-      transaction: parseTransaction(transaction),
-    }
-  }
-
-  async dryRunTransaction(options) {
-    const tx = Transaction.from(options.transaction)
-    const result = await this.#jsonRpcClient.dryRunTransactionBlock({
-      transactionBlock: options.transaction,
-      signal: options.signal,
-    })
-
-    const { effects, objectTypes } = parseTransactionEffectsJson({
-      effects: result.effects,
-      objectChanges: result.objectChanges,
-    })
-
-    return {
-      transaction: {
-        digest: await tx.getDigest(),
-        epoch: null,
-        effects,
-        objectTypes: Promise.resolve(objectTypes),
-        signatures: [],
-        transaction: parseTransactionBcs(options.transaction),
-      },
-    }
-  }
-
   async getReferenceGasPrice(options) {
     const referenceGasPrice = await this.#jsonRpcClient.getReferenceGasPrice({
       signal: options?.signal,
@@ -214,286 +91,11 @@ export class JSONRpcTransport extends Experimental_CoreClient {
     }
   }
 
-  async getDynamicFields(options) {
-    const dynamicFields = await this.#jsonRpcClient.getDynamicFields({
-      parentId: options.parentId,
-      limit: options.limit,
-      cursor: options.cursor,
-    })
-
-    return {
-      dynamicFields: dynamicFields.data.map((dynamicField) => {
-        return {
-          id: dynamicField.objectId,
-          type: dynamicField.objectType,
-          name: {
-            type: dynamicField.name.type,
-            bcs: fromBase64(dynamicField.bcsName),
-          },
-        }
-      }),
-      hasNextPage: dynamicFields.hasNextPage,
-      cursor: dynamicFields.nextCursor,
-    }
-  }
-
-  async verifyZkLoginSignature(options) {
-    const result = await this.#jsonRpcClient.verifyZkLoginSignature({
-      bytes: options.bytes,
-      signature: options.signature,
-      intentScope: options.intentScope,
-      author: options.author,
-    })
-
-    return {
-      success: result.success,
-      errors: result.errors,
-    }
-  }
-
-  resolveNameServiceNames(options) {
-    return this.#jsonRpcClient.resolveNameServiceNames(options)
-  }
-
   resolveTransactionPlugin() {
     return suiClientResolveTransactionPlugin(this.#jsonRpcClient)
   }
 }
 
-function parseObject(object) {
-  return {
-    id: object.objectId,
-    version: object.version,
-    digest: object.digest,
-    type: object.type,
-    content: Promise.resolve(
-      object.bcs?.dataType === 'moveObject' ? fromBase64(object.bcs.bcsBytes) : new Uint8Array()
-    ),
-    owner: parseOwner(object.owner),
-  }
-}
-
-function parseOwner(owner) {
-  if (owner === 'Immutable') {
-    return {
-      $kind: 'Immutable',
-      Immutable: true,
-    }
-  }
-
-  if ('ConsensusAddressOwner' in owner) {
-    return {
-      $kind: 'ConsensusAddressOwner',
-      ConsensusAddressOwner: {
-        owner: owner.ConsensusAddressOwner.owner,
-        startVersion: owner.ConsensusAddressOwner.start_version,
-      },
-    }
-  }
-
-  if ('AddressOwner' in owner) {
-    return {
-      $kind: 'AddressOwner',
-      AddressOwner: owner.AddressOwner,
-    }
-  }
-
-  if ('ObjectOwner' in owner) {
-    return {
-      $kind: 'ObjectOwner',
-      ObjectOwner: owner.ObjectOwner,
-    }
-  }
-
-  if ('Shared' in owner) {
-    return {
-      $kind: 'Shared',
-      Shared: {
-        initialSharedVersion: owner.Shared.initial_shared_version,
-      },
-    }
-  }
-
-  throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`)
-}
-
-function parseTransaction(transaction) {
-  const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction))[0]
-  const objectTypes = Object.create(null)
-
-  transaction.objectChanges?.forEach((change) => {
-    if (change.type !== 'published') {
-      objectTypes[change.objectId] = change.objectType
-    }
-  })
-
-  const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes()
-
-  const data = TransactionDataBuilder.restore({
-    version: 2,
-    sender: parsedTx.intentMessage.value.V1.sender,
-    expiration: parsedTx.intentMessage.value.V1.expiration,
-    gasData: parsedTx.intentMessage.value.V1.gasData,
-    inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction.inputs,
-    commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction.commands,
-  })
-
-  return {
-    digest: transaction.digest,
-    epoch: transaction.effects?.executedEpoch ?? null,
-    effects: parseTransactionEffectsBcs(new Uint8Array(transaction.rawEffects)),
-    objectTypes: Promise.resolve(objectTypes),
-    transaction: {
-      ...data,
-      bcs: bytes,
-    },
-    signatures: parsedTx.txSignatures,
-  }
-}
-
-function parseTransactionEffectsJson({ bytes, effects, objectChanges }) {
-  const changedObjects = []
-  const unchangedSharedObjects = []
-  const objectTypes = Object.create(null)
-
-  objectChanges?.forEach((change) => {
-    switch (change.type) {
-      case 'published':
-        changedObjects.push({
-          id: change.packageId,
-          inputState: 'DoesNotExist',
-          inputVersion: null,
-          inputDigest: null,
-          inputOwner: null,
-          outputState: 'PackageWrite',
-          outputVersion: change.version,
-          outputDigest: change.digest,
-          outputOwner: null,
-          idOperation: 'Created',
-        })
-        break
-      case 'transferred':
-        changedObjects.push({
-          id: change.objectId,
-          inputState: 'Exists',
-          inputVersion: change.version,
-          inputDigest: change.digest,
-          inputOwner: {
-            $kind: 'AddressOwner',
-            AddressOwner: change.sender,
-          },
-          outputState: 'ObjectWrite',
-          outputVersion: change.version,
-          outputDigest: change.digest,
-          outputOwner: parseOwner(change.recipient),
-          idOperation: 'None',
-        })
-        objectTypes[change.objectId] = change.objectType
-        break
-      case 'mutated':
-        changedObjects.push({
-          id: change.objectId,
-          inputState: 'Exists',
-          inputVersion: change.previousVersion,
-          inputDigest: null,
-          inputOwner: parseOwner(change.owner),
-          outputState: 'ObjectWrite',
-          outputVersion: change.version,
-          outputDigest: change.digest,
-          outputOwner: parseOwner(change.owner),
-          idOperation: 'None',
-        })
-        objectTypes[change.objectId] = change.objectType
-        break
-      case 'deleted':
-        changedObjects.push({
-          id: change.objectId,
-          inputState: 'Exists',
-          inputVersion: change.version,
-          inputDigest: effects.deleted?.find((d) => d.objectId === change.objectId)?.digest ?? null,
-          inputOwner: null,
-          outputState: 'DoesNotExist',
-          outputVersion: null,
-          outputDigest: null,
-          outputOwner: null,
-          idOperation: 'Deleted',
-        })
-        objectTypes[change.objectId] = change.objectType
-        break
-      case 'wrapped':
-        changedObjects.push({
-          id: change.objectId,
-          inputState: 'Exists',
-          inputVersion: change.version,
-          inputDigest: null,
-          inputOwner: {
-            $kind: 'AddressOwner',
-            AddressOwner: change.sender,
-          },
-          outputState: 'ObjectWrite',
-          outputVersion: change.version,
-          outputDigest:
-            effects.wrapped?.find((w) => w.objectId === change.objectId)?.digest ?? null,
-          outputOwner: {
-            $kind: 'ObjectOwner',
-            ObjectOwner: change.sender,
-          },
-          idOperation: 'None',
-        })
-        objectTypes[change.objectId] = change.objectType
-        break
-      case 'created':
-        changedObjects.push({
-          id: change.objectId,
-          inputState: 'DoesNotExist',
-          inputVersion: null,
-          inputDigest: null,
-          inputOwner: null,
-          outputState: 'ObjectWrite',
-          outputVersion: change.version,
-          outputDigest: change.digest,
-          outputOwner: parseOwner(change.owner),
-          idOperation: 'Created',
-        })
-        objectTypes[change.objectId] = change.objectType
-        break
-    }
-  })
-
-  return {
-    objectTypes,
-    effects: {
-      bcs: bytes ?? null,
-      digest: effects.transactionDigest,
-      version: 2,
-      status:
-        effects.status.status === 'success'
-          ? { success: true, error: null }
-          : { success: false, error: effects.status.error },
-      gasUsed: effects.gasUsed,
-      transactionDigest: effects.transactionDigest,
-      gasObject: {
-        id: effects.gasObject?.reference.objectId,
-        inputState: 'Exists',
-        inputVersion: null,
-        inputDigest: null,
-        inputOwner: null,
-        outputState: 'ObjectWrite',
-        outputVersion: effects.gasObject.reference.version,
-        outputDigest: effects.gasObject.reference.digest,
-        outputOwner: parseOwner(effects.gasObject.owner),
-        idOperation: 'None',
-      },
-      eventsDigest: effects.eventsDigest ?? null,
-      dependencies: effects.dependencies ?? [],
-      lamportVersion: effects.gasObject.reference.version,
-      changedObjects,
-      unchangedSharedObjects,
-      auxiliaryDataDigest: null,
-    },
-  }
-}
-
 const Balance = bcs.struct('Balance', {
   value: bcs.u64(),
 })

package/src/vendors/transactions/Commands.js

@@ -6,12 +6,6 @@ import { Argument } from './data/internal.js'
 
 const { toBase64, normalizeSuiObjectId } = vendorLib.utils
 
-var UpgradePolicy = /* @__PURE__ */ ((UpgradePolicy2) => {
-  UpgradePolicy2[(UpgradePolicy2['COMPATIBLE'] = 0)] = 'COMPATIBLE'
-  UpgradePolicy2[(UpgradePolicy2['ADDITIVE'] = 128)] = 'ADDITIVE'
-  UpgradePolicy2[(UpgradePolicy2['DEP_ONLY'] = 192)] = 'DEP_ONLY'
-  return UpgradePolicy2
-})(Object.create(null))
 const Commands = {
   MoveCall(input) {
     const [pkg, mod = '', fn = ''] =
@@ -104,5 +98,5 @@ const Commands = {
   },
 }
 
-export { Commands, UpgradePolicy }
+export { Commands }
 // # sourceMappingURL=Commands.js.map

package/src/vendors/transactions/Transaction.js

@@ -5,7 +5,6 @@ import { vendorLib } from '@exodus/sui-lib'
 import { is, parse } from '../valibot.js'
 import { Commands } from './Commands.js'
 import { Argument, NormalizedCallArg, ObjectRef, TransactionExpiration } from './data/internal.js'
-import { serializeV1TransactionData } from './data/v1.js'
 import { SerializedTransactionDataV2 } from './data/v2.js'
 import { Inputs } from './Inputs.js'
 import { createObjectMethods } from './object.js'
@@ -321,11 +320,6 @@ const _Transaction = class _Transaction {
     )
   }
 
-  /** @deprecated Use `getData()` instead. */
-  get blockData() {
-    return serializeV1TransactionData(__privateGet(this, _data).snapshot())
-  }
-
   /** Get a snapshot of the transaction data, in JSON form: */
   getData() {
     return __privateGet(this, _data).snapshot()
@@ -519,14 +513,6 @@ const _Transaction = class _Transaction {
     )
   }
 
-  /**
-   * @deprecated Use toJSON instead.
-   * For synchronous serialization, you can use `getData()`
-   */
-  serialize() {
-    return JSON.stringify(serializeV1TransactionData(__privateGet(this, _data).snapshot()))
-  }
-
   async toJSON(options = Object.create(null)) {
     await this.prepareForSerialization(options)
     const fullyResolved = this.isFullyResolved()

package/src/vendors/transactions/data/internal.js

@@ -77,13 +77,6 @@ const GasData = object({
   owner: nullable(SuiAddress),
   payment: nullable(array(ObjectRef)),
 })
-const StructTag = object({
-  address: string(),
-  module: string(),
-  name: string(),
-  // type_params in rust, should be updated to use camelCase
-  typeParams: array(string()),
-})
 const OpenMoveTypeSignatureBody = union([
   literal('address'),
   literal('bool'),
@@ -197,19 +190,12 @@ const TransactionData = object({
 })
 
 export {
-  $Intent,
   Argument,
   BCSBytes,
-  Command,
-  GasData,
   JsonU64,
   NormalizedCallArg,
-  ObjectArg,
   ObjectID,
   ObjectRef,
-  OpenMoveTypeSignature,
-  OpenMoveTypeSignatureBody,
-  StructTag,
   SuiAddress,
   TransactionData,
   TransactionExpiration,