@haneullabs/haneul 0.1.0

package/dist/esm/jsonRpc/core.js

@@ -0,0 +1,624 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _jsonRpcClient;
+import { fromBase64 } from "@haneullabs/bcs";
+import { bcs } from "../bcs/index.js";
+import { Transaction } from "../transactions/Transaction.js";
+import { jsonRpcClientResolveTransactionPlugin } from "./json-rpc-resolver.js";
+import { TransactionDataBuilder } from "../transactions/TransactionData.js";
+import { chunk } from "@haneullabs/utils";
+import { normalizeHaneulAddress } from "../utils/haneul-types.js";
+import { Experimental_CoreClient } from "../experimental/core.js";
+import { ObjectError } from "../experimental/errors.js";
+import { parseTransactionBcs, parseTransactionEffectsBcs } from "../experimental/index.js";
+class JSONRpcCoreClient extends Experimental_CoreClient {
+  constructor({
+    jsonRpcClient,
+    mvr
+  }) {
+    super({ network: jsonRpcClient.network, base: jsonRpcClient, mvr });
+    __privateAdd(this, _jsonRpcClient);
+    __privateSet(this, _jsonRpcClient, jsonRpcClient);
+  }
+  async getObjects(options) {
+    const batches = chunk(options.objectIds, 50);
+    const results = [];
+    for (const batch of batches) {
+      const objects = await __privateGet(this, _jsonRpcClient).multiGetObjects({
+        ids: batch,
+        options: {
+          showOwner: true,
+          showType: true,
+          showBcs: true,
+          showPreviousTransaction: 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 __privateGet(this, _jsonRpcClient).getOwnedObjects({
+      owner: options.address,
+      limit: options.limit,
+      cursor: options.cursor,
+      options: {
+        showOwner: true,
+        showType: true,
+        showBcs: true,
+        showPreviousTransaction: 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);
+        }
+        return parseObject(result.data);
+      }),
+      hasNextPage: objects.hasNextPage,
+      cursor: objects.nextCursor ?? null
+    };
+  }
+  async getCoins(options) {
+    const coins = await __privateGet(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
+          },
+          previousTransaction: coin.previousTransaction
+        };
+      }),
+      hasNextPage: coins.hasNextPage,
+      cursor: coins.nextCursor ?? null
+    };
+  }
+  async getBalance(options) {
+    const balance = await __privateGet(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 __privateGet(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 __privateGet(this, _jsonRpcClient).getTransactionBlock({
+      digest: options.digest,
+      options: {
+        showRawInput: true,
+        showObjectChanges: true,
+        showRawEffects: true,
+        showEvents: true,
+        showEffects: true,
+        showBalanceChanges: true
+      },
+      signal: options.signal
+    });
+    return {
+      transaction: parseTransaction(transaction)
+    };
+  }
+  async executeTransaction(options) {
+    const transaction = await __privateGet(this, _jsonRpcClient).executeTransactionBlock({
+      transactionBlock: options.transaction,
+      signature: options.signatures,
+      options: {
+        showRawEffects: true,
+        showEvents: true,
+        showObjectChanges: true,
+        showRawInput: true,
+        showEffects: true,
+        showBalanceChanges: true
+      },
+      signal: options.signal
+    });
+    return {
+      transaction: parseTransaction(transaction)
+    };
+  }
+  async dryRunTransaction(options) {
+    const tx = Transaction.from(options.transaction);
+    const result = await __privateGet(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),
+        balanceChanges: result.balanceChanges.map((change) => ({
+          coinType: change.coinType,
+          address: parseOwnerAddress(change.owner),
+          amount: change.amount
+        }))
+      }
+    };
+  }
+  async getReferenceGasPrice(options) {
+    const referenceGasPrice = await __privateGet(this, _jsonRpcClient).getReferenceGasPrice({
+      signal: options?.signal
+    });
+    return {
+      referenceGasPrice: String(referenceGasPrice)
+    };
+  }
+  async getDynamicFields(options) {
+    const dynamicFields = await __privateGet(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 __privateGet(this, _jsonRpcClient).verifyZkLoginSignature({
+      bytes: options.bytes,
+      signature: options.signature,
+      intentScope: options.intentScope,
+      author: options.author
+    });
+    return {
+      success: result.success,
+      errors: result.errors
+    };
+  }
+  async defaultNameServiceName(options) {
+    const name = (await __privateGet(this, _jsonRpcClient).resolveNameServiceNames(options)).data[0];
+    return {
+      data: {
+        name
+      }
+    };
+  }
+  resolveTransactionPlugin() {
+    return jsonRpcClientResolveTransactionPlugin(__privateGet(this, _jsonRpcClient));
+  }
+  async getMoveFunction(options) {
+    const result = await __privateGet(this, _jsonRpcClient).getNormalizedMoveFunction({
+      package: (await this.mvr.resolvePackage({ package: options.packageId })).package,
+      module: options.moduleName,
+      function: options.name
+    });
+    return {
+      function: {
+        packageId: normalizeHaneulAddress(options.packageId),
+        moduleName: options.moduleName,
+        name: options.name,
+        visibility: parseVisibility(result.visibility),
+        isEntry: result.isEntry,
+        typeParameters: result.typeParameters.map((abilities) => ({
+          isPhantom: false,
+          constraints: parseAbilities(abilities)
+        })),
+        parameters: result.parameters.map((param) => parseNormalizedSuiMoveType(param)),
+        returns: result.return.map((ret) => parseNormalizedSuiMoveType(ret))
+      }
+    };
+  }
+}
+_jsonRpcClient = new WeakMap();
+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),
+    previousTransaction: object.previousTransaction ?? null
+  };
+}
+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 parseOwnerAddress(owner) {
+  if (owner === "Immutable") {
+    return null;
+  }
+  if ("ConsensusAddressOwner" in owner) {
+    return owner.ConsensusAddressOwner.owner;
+  }
+  if ("AddressOwner" in owner) {
+    return owner.AddressOwner;
+  }
+  if ("ObjectOwner" in owner) {
+    return owner.ObjectOwner;
+  }
+  if ("Shared" in owner) {
+    return null;
+  }
+  throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
+}
+function parseTransaction(transaction) {
+  const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction))[0];
+  const objectTypes = {};
+  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,
+    balanceChanges: transaction.balanceChanges?.map((change) => ({
+      coinType: change.coinType,
+      address: parseOwnerAddress(change.owner),
+      amount: change.amount
+    })) ?? []
+  };
+}
+function parseTransactionEffectsJson({
+  bytes,
+  effects,
+  objectChanges
+}) {
+  const changedObjects = [];
+  const unchangedConsensusObjects = [];
+  const objectTypes = {};
+  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,
+      unchangedConsensusObjects,
+      auxiliaryDataDigest: null
+    }
+  };
+}
+const Balance = bcs.struct("Balance", {
+  value: bcs.u64()
+});
+const Coin = bcs.struct("Coin", {
+  id: bcs.Address,
+  balance: Balance
+});
+function parseNormalizedSuiMoveType(type) {
+  if (typeof type !== "string") {
+    if ("Reference" in type) {
+      return {
+        reference: "immutable",
+        body: parseNormalizedSuiMoveTypeBody(type.Reference)
+      };
+    }
+    if ("MutableReference" in type) {
+      return {
+        reference: "mutable",
+        body: parseNormalizedSuiMoveTypeBody(type.MutableReference)
+      };
+    }
+  }
+  return {
+    reference: null,
+    body: parseNormalizedSuiMoveTypeBody(type)
+  };
+}
+function parseNormalizedSuiMoveTypeBody(type) {
+  switch (type) {
+    case "Address":
+      return { $kind: "address" };
+    case "Bool":
+      return { $kind: "bool" };
+    case "U8":
+      return { $kind: "u8" };
+    case "U16":
+      return { $kind: "u16" };
+    case "U32":
+      return { $kind: "u32" };
+    case "U64":
+      return { $kind: "u64" };
+    case "U128":
+      return { $kind: "u128" };
+    case "U256":
+      return { $kind: "u256" };
+  }
+  if (typeof type === "string") {
+    throw new Error(`Unknown type: ${type}`);
+  }
+  if ("Vector" in type) {
+    return {
+      $kind: "vector",
+      vector: parseNormalizedSuiMoveTypeBody(type.Vector)
+    };
+  }
+  if ("Struct" in type) {
+    return {
+      $kind: "datatype",
+      datatype: {
+        typeName: `${normalizeHaneulAddress(type.Struct.address)}::${type.Struct.module}::${type.Struct.name}`,
+        typeParameters: type.Struct.typeArguments.map((t) => parseNormalizedSuiMoveTypeBody(t))
+      }
+    };
+  }
+  if ("TypeParameter" in type) {
+    return {
+      $kind: "typeParameter",
+      index: type.TypeParameter
+    };
+  }
+  throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+}
+function parseAbilities(abilitySet) {
+  return abilitySet.abilities.map((ability) => {
+    switch (ability) {
+      case "Copy":
+        return "copy";
+      case "Drop":
+        return "drop";
+      case "Store":
+        return "store";
+      case "Key":
+        return "key";
+      default:
+        return "unknown";
+    }
+  });
+}
+function parseVisibility(visibility) {
+  switch (visibility) {
+    case "Public":
+      return "public";
+    case "Private":
+      return "private";
+    case "Friend":
+      return "friend";
+    default:
+      return "unknown";
+  }
+}
+export {
+  JSONRpcCoreClient
+};
+//# sourceMappingURL=core.js.map