chore(ts-sdk-sui): created submit instruction function

Signed-off-by: kaancaglan <[email protected]>

Author: Caglankaan

ts-sdk-sui/examples/sui-create-client-generate-instruction.ts

@@ -0,0 +1,65 @@
+// @ts-ignore
+if (typeof BigInt.prototype.toJSON !== "function") {
+  // @ts-ignore
+  BigInt.prototype.toJSON = function () {
+    return this.toString()
+  }
+}
+import { Effect, Logger } from "effect"
+import { getFullnodeUrl } from "@mysten/sui/client"
+import { PublicClient, WalletClient, writeContract, readCoinMetadata, readCoinBalances, sendInstruction } from "../src/Sui.js"
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"
+import { Transaction } from "@mysten/sui/transactions"
+
+const MNEMONIC = process.env.MNEMONIC ?? "fix auto gallery heart practice drip joke nice decline lift attend bread"
+const RECIPIENT = process.env.RECIPIENT ?? "0x03ff9dd9e093387bdd4432c6a3eb6a1bd5a8f39a530042ac7efe576f18d3232b"
+
+const keypair = Ed25519Keypair.deriveKeypair(MNEMONIC)
+
+
+const program = Effect.gen(function* () {
+  const { client } = yield* PublicClient
+  yield* Effect.log("Sui public client initialized", client.network )
+  const meta = yield* readCoinMetadata("0x2::sui::SUI" as any)
+  yield* Effect.log("SUI metadata", meta)
+
+  yield* Effect.log("keypair.getPublicKey().toSuiAddress()", keypair.getPublicKey().toSuiAddress())
+  const balances = yield* readCoinBalances("0x2::sui::SUI" as any, keypair.getPublicKey().toSuiAddress() as any)
+  yield* Effect.log("SUI balances", balances)
+
+
+  const wallet = yield* WalletClient
+  const amountMist = 10_000_000n // 0.01 SUI
+
+  const tx = new Transaction()
+  const coin = tx.splitCoins(tx.gas, [tx.pure.u64(amountMist)])
+  const recipient = tx.pure.address(RECIPIENT)
+
+  const res = yield* writeContract(
+    client,
+    keypair,
+    "0x2",                                // packageId: Sui framework
+    "transfer",                           // module: sui::transfer
+    "public_transfer",                    // function
+    ["0x2::coin::Coin<0x2::sui::SUI>"],   // type arg T
+    [coin, recipient],                    // (obj: T, recipient: address)
+    tx,
+  )
+
+  yield* Effect.log("Transfer submitted", res)
+
+  
+}).pipe(
+  Effect.provide(PublicClient.Live({ url: getFullnodeUrl("testnet") })),
+  Effect.provide(
+    WalletClient.Live({
+      url: getFullnodeUrl("testnet"),
+      account: keypair,              // signer
+      chain: "sui-testnet" as any,   // placeholder; not used internally
+    }),
+  ),
+
+  Effect.provide(Logger.replace(Logger.defaultLogger, Logger.prettyLoggerDefault)),
+)
+
+Effect.runPromise(program).catch(console.error)

ts-sdk-sui/src/Sui.ts

@@ -569,6 +569,159 @@ export const readCoinSymbol = (address: string) =>
   })
 
 
+  /**
+ * PTB: begin_send -> (send_with_coin<T> ...)* -> end_send
+ *
+ * Mirrors:
+ * sui client ptb \
+ *   --move-call "$PKG::$MOD::begin_send" $CHANNEL_ID $SALT \
+ *   --assign send_ctx1 \
+ *   --move-call "$PKG::$MOD::send_with_coin" "<$TYPE_T>" \
+ *       $RELAY_STORE $VAULT $IBC_STORE $COIN $VERSION $OPCODE $OPERAND send_ctx1 \
+ *   --assign send_ctx2 \
+ *   --move-call "$PKG::$MOD::end_send" $IBC_STORE $CLOCK $T_HEIGHT $T_TS send_ctx2 \
+ *   --gas-budget 150000000
+ */
+export const sendInstruction = (params: {
+  packageId: string
+
+  /** coin type, e.g. "0x2::sui::SUI" (used in typeArguments of send_with_coin) */
+  typeArg: string
+
+  relayStoreId: string        // $RELAY_STORE
+  vaultId: string             // $VAULT
+  ibcStoreId: string          // $IBC_STORE
+  coinObjectId: string        // $COIN
+
+  // extraSendCalls?: Array<{
+  //   relayStoreId?: string
+  //   vaultId?: string
+  //   ibcStoreId?: string
+  //   coinObjectId?: string
+  //   version?: number
+  //   opcode?: number
+  //   operandHex?: `0x${string}`
+  //   typeArg?: string
+  // }>
+
+  /** the instruction used purely for encoding operand just like EVM */
+  instruction: Ucs03.Instruction
+
+}) =>
+  Effect.gen(function* () {
+    const module = "zkgm"
+    const clockObjectId = "0x6" // Sui system clock object
+
+    const { client, signer } = yield* WalletClient
+    const channelId = (yield* ChannelSource).channelId
+
+    const salt = yield* Utils.generateSalt("evm") // TODO: check if evm will work here or not
+    const timeoutNs = Utils.getTimeoutInNanoseconds24HoursFromNow()
+    const tHeight = BigInt(0)
+
+    const operandHex = (yield* S.encode(Ucs03.InstructionFromHex)(params.instruction)) as `0x${string}`
+
+    // helpers
+    const hexToBytes = (hex: `0x${string}`): Uint8Array => {
+      const s = hex.slice(2)
+      const out = new Uint8Array(s.length / 2)
+      for (let i = 0; i < out.length; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16)
+      return out
+    }
+
+    const tx = new Transaction()
+    // if (params.gasBudget !== undefined) tx.setGasBudget(BigInt(params.gasBudget as any))
+
+    let sendCtx = tx.moveCall({
+      target: `${params.packageId}::${module}::begin_send`,
+      typeArguments: [],
+      arguments: [
+        tx.pure.u32(channelId), 
+        tx.pure.vector("u8", hexToBytes(salt as `0x${string}`)), 
+      ],
+    })
+
+    const pushSendWithCoin = (cfg: {
+      relayStoreId: string
+      vaultId: string
+      ibcStoreId: string
+      coinObjectId: string
+      version: number
+      opcode: number
+      operandHex: `0x${string}`
+      typeArg: string
+    }) => {
+      sendCtx = tx.moveCall({
+        target: `${params.packageId}::${module}::send_with_coin`,
+        typeArguments: [cfg.typeArg],
+        arguments: [
+          tx.object(cfg.relayStoreId),
+          tx.object(cfg.vaultId),
+          tx.object(cfg.ibcStoreId),
+          tx.object(cfg.coinObjectId),
+          tx.pure.u8(cfg.version),
+          tx.pure.u8(cfg.opcode), 
+          tx.pure.vector("u8", hexToBytes(cfg.operandHex)),
+          sendCtx,
+        ],
+      })
+    }
+
+    pushSendWithCoin({
+      relayStoreId: params.relayStoreId,
+      vaultId: params.vaultId,
+      ibcStoreId: params.ibcStoreId,
+      coinObjectId: params.coinObjectId,
+      version: params.instruction.version,
+      opcode: params.instruction.opcode,
+      operandHex,
+      typeArg: params.typeArg,
+    })
+
+    // TODO: multiple send_with_coin calls if needed??? will this work?
+    // for (const extra of params.extraSendCalls ?? []) {
+    //   pushSendWithCoin({
+    //     relayStoreId: extra.relayStoreId ?? params.relayStoreId,
+    //     vaultId: extra.vaultId ?? params.vaultId,
+    //     ibcStoreId: extra.ibcStoreId ?? params.ibcStoreId,
+    //     coinObjectId: extra.coinObjectId ?? params.coinObjectId,
+    //     version: extra.version ?? params.version,
+    //     opcode: extra.opcode ?? params.opcode,
+    //     operandHex: (extra.operandHex ?? operandHex) as `0x${string}`,
+    //     typeArg: extra.typeArg ?? params.typeArg,
+    //   })
+    // }
+
+    tx.moveCall({
+      target: `${params.packageId}::${module}::end_send`,
+      typeArguments: [],
+      arguments: [
+        tx.object(params.ibcStoreId),
+        tx.object(clockObjectId),
+        tx.pure.u64(tHeight),
+        tx.pure.u64(BigInt(timeoutNs)), // ns
+        sendCtx,
+      ],
+    })
+
+    const res = yield* Effect.tryPromise({
+      try: async () =>
+        client.signAndExecuteTransaction({
+          signer,
+          transaction: tx,
+        }),
+      catch: (e) => new WriteContractError({ cause: extractErrorDetails(e as Error) }),
+    })
+
+    return res
+  })
+  
+// turn a hex string like "0xdeadbeef" into a number[] of bytes
+function hexToBytes(hex: string): number[] {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex
+  return h.match(/.{1,2}/g)!.map(b => parseInt(b, 16))
+}
+
 // // TODO: Decide the parameters here.
 // /**
 //  * @category utils