Sdk stake

app2/examples/unbond.ts

@@ -13,6 +13,7 @@ if (typeof BigInt.prototype.toJSON !== "function") {
 import {
   Batch,
   Call,
+  Token,
   TokenOrder,
   Ucs05,
   ZkgmClient,
@@ -22,16 +23,16 @@ import {
 import { Evm, EvmZkgmClient } from "@unionlabs/sdk-evm"
 import { ChainRegistry } from "@unionlabs/sdk/ChainRegistry"
 import {
-  ON_ZKGM_CALL_PROXY,
-  U_BANK,
-  U_ERC20,
-  U_TO_UNION_SOLVER_METADATA,
+  EU_ERC20,
+  EU_LST,
+  EU_SOLVER_ON_UNION_METADATA,
+  EU_STAKING_HUB,
 } from "@unionlabs/sdk/Constants"
 import { UniversalChainId } from "@unionlabs/sdk/schema/chain"
 import { ChannelId } from "@unionlabs/sdk/schema/channel"
 import { HexFromJson } from "@unionlabs/sdk/schema/hex"
 import { Effect, Logger, pipe, Schema } from "effect"
-import { http } from "viem"
+import { bytesToHex, encodeAbiParameters, fromHex, http, keccak256 } from "viem"
 import { privateKeyToAccount } from "viem/accounts"
 import { holesky } from "viem/chains"
 
@@ -40,76 +41,223 @@ const JsonFromBase64 = Schema.compose(
   Schema.parseJson(),
 )
 
-const AMOUNT = 1n
+const AMOUNT = 5n
 const ETHEREUM_CHAIN_ID = UniversalChainId.make("ethereum.17000")
 const UNION_CHAIN_ID = UniversalChainId.make("union.union-testnet-10")
-const SOURCE_CHANNEL_ID = ChannelId.make(1) // FIXME
-const UCS03_MINTER = Ucs05.EvmDisplay.make({
+const UCS03_ZKGM = Ucs05.CosmosDisplay.make({
+  address: "union1336jj8ertl8h7rdvnz4dh5rqahd09cy0x43guhsxx6xyrztx292qpe64fh",
+})
+const SOURCE_CHANNEL_ID = ChannelId.make(6)
+const DESTINATION_CHANNEL_ID = ChannelId.make(20)
+const UCS03_EVM = Ucs05.EvmDisplay.make({
   address: "0x5fbe74a283f7954f10aa04c2edf55578811aeb03",
 })
 const VIEM_CHAIN = holesky
 const RPC_URL = "https://rpc.17000.ethereum.chain.kitchen"
+const VIEM_ACCOUNT = privateKeyToAccount(
+  process.env.KEY as any,
+)
 const SENDER = Ucs05.EvmDisplay.make({
-  address: "0x06627714f3F17a701f7074a12C02847a5D2Ca487",
-})
-const EU_STAKING_HUB = Ucs05.CosmosDisplay.make({
-  address: "union1eueueueu9var4yhdruyzkjcsh74xzeug6ckyy60hs0vcqnzql2hq0lxc2f", // FIXME
+  address: VIEM_ACCOUNT.address,
 })
 
-const VIEM_ACCOUNT = privateKeyToAccount(
-  process.env.KEY as any,
+const checkAndSubmitAllowance = pipe(
+  Evm.readErc20Allowance(
+    EU_ERC20.address,
+    SENDER.address,
+    UCS03_EVM.address,
+  ),
+  Effect.flatMap((amount) =>
+    Effect.if(amount < AMOUNT, {
+      onTrue: () =>
+        pipe(
+          Effect.log(`Increasing allowance by ${AMOUNT - amount} for ${EU_ERC20.address}`),
+          Effect.andThen(() =>
+            pipe(
+              Evm.increaseErc20Allowance(
+                EU_ERC20.address,
+                UCS03_EVM,
+                AMOUNT - amount,
+              ),
+              Effect.andThen(Evm.waitForTransactionReceipt),
+            )
+          ),
+        ),
+      onFalse: () =>
+        Effect.log(`Allowance fulfilled by ${AMOUNT - amount} for ${EU_ERC20.address}`),
+    })
+  ),
+)
+
+const bytecode_base_checksum =
+  "0xec827349ed4c1fec5a9c3462ff7c979d4c40e7aa43b16ed34469d04ff835f2a1" as const
+const canonical_zkgm = Ucs05.anyDisplayToCanonical(UCS03_ZKGM)
+const module_hash = "0x120970d812836f19888625587a4606a5ad23cef31c8684e601771552548fc6b9" as const
+
+const instantiate2 = Effect.fn(
+  function*(options: { path: bigint; channel: ChannelId; sender: Ucs05.AnyDisplay }) {
+    const sender = yield* Ucs05.anyDisplayToZkgm(options.sender)
+    const abi = [
+      {
+        name: "path",
+        type: "uint256",
+        internalType: "uint256",
+      },
+      {
+        name: "channelId",
+        type: "uint32",
+        internalType: "uint32",
+      },
+      {
+        name: "sender",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ] as const
+
+    const args = [
+      options.path,
+      options.channel,
+      sender,
+    ] as const
+
+    const encode = Effect.try(() =>
+      encodeAbiParameters(
+        abi,
+        args,
+      )
+    )
+
+    const encoded = yield* encode
+
+    /**
+     * n as BE rep
+     */
+    const u64toBeBytes = (n: bigint) => {
+      const buffer = new ArrayBuffer(8)
+      const view = new DataView(buffer)
+      view.setBigUint64(0, n)
+      return new Uint8Array(view.buffer)
+    }
+
+    const sha256 = (data: any) => globalThis.crypto.subtle.digest("SHA-256", data)
+
+    const salt = keccak256(encoded, "bytes")
+
+    const _args = [
+      ...fromHex(module_hash, "bytes"),
+      ...new TextEncoder().encode("wasm"),
+      0, // null byte
+      ...u64toBeBytes(32n), // checksum len as 64-bit big endian bytes of int
+      ...fromHex(bytecode_base_checksum, "bytes"),
+      ...u64toBeBytes(32n), // creator canonical addr len
+      ...fromHex(canonical_zkgm, "bytes"),
+      ...u64toBeBytes(32n), // len
+      ...salt,
+      ...u64toBeBytes(0n),
+    ] as const
+
+    const data = Uint8Array.from(_args)
+
+    const r = yield* Effect.tryPromise(() => sha256(data))
+
+    const rBytes = bytesToHex(new Uint8Array(r))
+
+    const transform = Ucs05.Bech32FromCanonicalBytesWithPrefix("union")
+
+    const r2 = yield* Schema.decode(transform)(rBytes)
+
+    return Ucs05.CosmosDisplay.make({ address: r2 })
+  },
 )
 
 const sendUnbond = Effect.gen(function*() {
   const ethereumChain = yield* ChainRegistry.byUniversalId(ETHEREUM_CHAIN_ID)
   const unionChain = yield* ChainRegistry.byUniversalId(UNION_CHAIN_ID)
-
-  const eu_staking_hub = yield* Ucs05.anyDisplayToZkgm(EU_STAKING_HUB)
+  const receiver = yield* instantiate2({
+    path: 0n,
+    channel: DESTINATION_CHANNEL_ID,
+    sender: SENDER,
+  })
 
   const tokenOrder = yield* TokenOrder.make({
     source: ethereumChain,
     destination: unionChain,
     sender: SENDER,
-    receiver: ON_ZKGM_CALL_PROXY,
-    baseToken: U_ERC20,
+    receiver,
+    baseToken: EU_ERC20,
     baseAmount: AMOUNT,
-    quoteToken: U_BANK,
+    quoteToken: Token.Cw20.make({ address: EU_LST.address }),
     quoteAmount: AMOUNT,
     kind: "solve",
-    metadata: U_TO_UNION_SOLVER_METADATA,
+    metadata: EU_SOLVER_ON_UNION_METADATA,
     version: 2,
   })
 
+  const increaseAllowanceCall = yield* pipe(
+    {
+      increase_allowance: {
+        spender: EU_STAKING_HUB.address,
+        amount: AMOUNT,
+      },
+    } as const,
+    Schema.encode(JsonFromBase64),
+    Effect.map((msg) => ({
+      wasm: {
+        execute: {
+          contract_addr: EU_LST.address,
+          msg,
+          funds: [],
+        },
+      },
+    } as const)),
+  )
+
   const unbondCall = yield* pipe(
-    { amount: tokenOrder.quoteAmount } as const,
+    {
+      unbond: {
+        staker: receiver.address,
+        amount: tokenOrder.quoteAmount,
+      },
+    } as const,
     Schema.encode(JsonFromBase64),
     Effect.map((msg) => ({
-      contract: eu_staking_hub,
-      msg,
-      funds: [],
-      call_action: "call_proxy",
+      wasm: {
+        execute: {
+          contract_addr: EU_STAKING_HUB.address,
+          msg,
+          funds: [],
+        },
+      },
     } as const)),
-    Effect.flatMap(Schema.decode(HexFromJson)),
+  )
+
+  const calls = yield* pipe(
+    [
+      increaseAllowanceCall,
+      unbondCall,
+    ],
+    Schema.decode(HexFromJson),
     Effect.map((contractCalldata) =>
       Call.make({
         sender: SENDER,
         eureka: false,
-        contractAddress: ON_ZKGM_CALL_PROXY,
+        contractAddress: receiver,
         contractCalldata,
       })
     ),
   )
 
   const batch = Batch.make([
     tokenOrder,
-    unbondCall,
+    calls,
   ])
 
   const request = ZkgmClientRequest.make({
     source: ethereumChain,
     destination: unionChain,
     channelId: SOURCE_CHANNEL_ID,
-    ucs03Address: UCS03_MINTER.address,
+    ucs03Address: UCS03_EVM.address,
     instruction: batch,
   })
 
@@ -123,7 +271,13 @@ const sendUnbond = Effect.gen(function*() {
   )
 
   yield* Effect.log("Receipt:", receipt)
-}).pipe(
+})
+
+pipe(
+  Effect.all([
+    checkAndSubmitAllowance,
+    sendUnbond,
+  ]),
   Effect.provide(EvmZkgmClient.layerWithoutWallet),
   Effect.provide(Evm.WalletClient.Live({
     account: VIEM_ACCOUNT,
@@ -143,8 +297,7 @@ const sendUnbond = Effect.gen(function*() {
       mode: "tty",
     }),
   )),
+  Effect.runPromise,
 )
-
-Effect.runPromise(sendUnbond)
   .then(console.log)
   .catch(console.error)