@exodus/sui-api 0.1.0

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

@@ -0,0 +1,504 @@
+/* eslint-disable camelcase */
+
+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
+
+  constructor({ jsonRpcClient, mvr }) {
+    super({ network: jsonRpcClient.network, base: jsonRpcClient, mvr })
+    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,
+      coinType: options.coinType,
+      limit: options.limit,
+      cursor: options.cursor,
+      signal: options.signal,
+    })
+
+    return {
+      objects: coins.data.map((coin) => {
+        return {
+          id: coin.coinObjectId,
+          version: coin.version,
+          digest: coin.digest,
+          balance: coin.balance,
+          type: `0x2::coin::Coin<${coin.coinType}>`,
+          content: Promise.resolve(
+            Coin.serialize({
+              id: coin.coinObjectId,
+              balance: {
+                value: coin.balance,
+              },
+            }).toBytes()
+          ),
+          owner: {
+            $kind: 'ObjectOwner',
+            ObjectOwner: options.address,
+          },
+        }
+      }),
+      hasNextPage: coins.hasNextPage,
+      cursor: coins.nextCursor ?? null,
+    }
+  }
+
+  async getBalance(options) {
+    const balance = await this.#jsonRpcClient.getBalance({
+      owner: options.address,
+      coinType: options.coinType,
+      signal: options.signal,
+    })
+
+    return {
+      balance: {
+        coinType: balance.coinType,
+        balance: balance.totalBalance,
+      },
+    }
+  }
+
+  async getAllBalances(options) {
+    const balances = await this.#jsonRpcClient.getAllBalances({
+      owner: options.address,
+      signal: options.signal,
+    })
+
+    return {
+      balances: balances.map((balance) => ({
+        coinType: balance.coinType,
+        balance: balance.totalBalance,
+      })),
+      hasNextPage: false,
+      cursor: null,
+    }
+  }
+
+  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,
+    })
+    return {
+      referenceGasPrice: String(referenceGasPrice),
+    }
+  }
+
+  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(),
+})
+
+const Coin = bcs.struct('Coin', {
+  id: bcs.Address,
+  balance: Balance,
+})

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

@@ -0,0 +1,90 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+import { TransactionDataBuilder } from '../../transactions/TransactionData.js'
+
+const { bcs } = vendorLib
+
+function parseTransactionBcs(bytes) {
+  return {
+    ...TransactionDataBuilder.fromBytes(bytes).snapshot(),
+    bcs: bytes,
+  }
+}
+
+function parseTransactionEffectsBcs(effects) {
+  const parsed = bcs.TransactionEffects.parse(effects)
+  switch (parsed.$kind) {
+    case 'V1':
+      return parseTransactionEffectsV1({ bytes: effects, effects: parsed.V1 })
+    case 'V2':
+      return parseTransactionEffectsV2({ bytes: effects, effects: parsed.V2 })
+    default:
+      throw new Error(`Unknown transaction effects version: ${parsed.$kind}`)
+  }
+}
+
+function parseTransactionEffectsV1(_) {
+  throw new Error('V1 effects are not supported yet')
+}
+
+function parseTransactionEffectsV2({ bytes, effects }) {
+  const changedObjects = effects.changedObjects.map(([id, change]) => {
+    return {
+      id,
+      inputState: change.inputState.$kind === 'Exist' ? 'Exists' : 'DoesNotExist',
+      inputVersion: change.inputState.Exist?.[0][0] ?? null,
+      inputDigest: change.inputState.Exist?.[0][1] ?? null,
+      inputOwner: change.inputState.Exist?.[1] ?? null,
+      outputState:
+        change.outputState.$kind === 'NotExist' ? 'DoesNotExist' : change.outputState.$kind,
+      outputVersion:
+        change.outputState.$kind === 'PackageWrite'
+          ? change.outputState.PackageWrite?.[0]
+          : change.outputState.ObjectWrite
+            ? effects.lamportVersion
+            : null,
+      outputDigest:
+        change.outputState.$kind === 'PackageWrite'
+          ? change.outputState.PackageWrite?.[1]
+          : change.outputState.ObjectWrite?.[0] ?? null,
+      outputOwner: change.outputState.ObjectWrite ? change.outputState.ObjectWrite[1] : null,
+      idOperation: change.idOperation.$kind,
+    }
+  })
+  return {
+    bcs: bytes,
+    digest: effects.transactionDigest,
+    version: 2,
+    status:
+      effects.status.$kind === 'Success'
+        ? {
+            success: true,
+            error: null,
+          }
+        : {
+            success: false,
+            // TODO: add command
+            error: effects.status.Failed.error.$kind,
+          },
+    gasUsed: effects.gasUsed,
+    transactionDigest: effects.transactionDigest,
+    gasObject:
+      effects.gasObjectIndex === null ? null : changedObjects[effects.gasObjectIndex] ?? null,
+    eventsDigest: effects.eventsDigest,
+    dependencies: effects.dependencies,
+    lamportVersion: effects.lamportVersion,
+    changedObjects,
+    unchangedSharedObjects: effects.unchangedSharedObjects.map(([objectId, object]) => {
+      return {
+        kind: object.$kind,
+        objectId,
+        version: object.$kind === 'ReadOnlyRoot' ? object.ReadOnlyRoot[0] : object[object.$kind],
+        digest: object.$kind === 'ReadOnlyRoot' ? object.ReadOnlyRoot[1] : null,
+      }
+    }),
+    auxiliaryDataDigest: effects.auxDataDigest,
+  }
+}
+
+export { parseTransactionBcs, parseTransactionEffectsBcs }
+// # sourceMappingURL=utils.js.map

package/src/vendors/transactions/Arguments.js

@@ -0,0 +1,22 @@
+import { createObjectMethods } from './object.js'
+import { createPure } from './pure.js'
+
+const Arguments = {
+  pure: createPure((value) => (tx) => tx.pure(value)),
+  object: createObjectMethods((value) => (tx) => tx.object(value)),
+  sharedObjectRef:
+    (...args) =>
+    (tx) =>
+      tx.sharedObjectRef(...args),
+  objectRef:
+    (...args) =>
+    (tx) =>
+      tx.objectRef(...args),
+  receivingRef:
+    (...args) =>
+    (tx) =>
+      tx.receivingRef(...args),
+}
+
+export { Arguments }
+// # sourceMappingURL=Arguments.js.map