Chore: Update with operations (#29)

Co-authored-by: Agustincito <agus@poap.io>

Author: PedroAraoz

examples/01-simple-transfer/src/function.ts

@@ -1,10 +1,10 @@
-import { Address, BigInt, ERC20Token, Transfer } from '@mimicprotocol/lib-ts'
+import { Address, ChainId, Optimism, TokenAmount, TransferBuilder } from '@mimicprotocol/lib-ts'
 
 export default function main(): void {
-  const USDC = ERC20Token.fromString('0x7F5c764cBc14f9669B88837ca1490cCa17c31607', 10)
-  const amount = BigInt.fromStringDecimal('1', 6)
   const recipient = Address.fromString('0xbcE3248eDE29116e4bD18416dcC2DFca668Eeb84')
-  const maxFee = BigInt.fromStringDecimal('0.1', 6)
-
-  Transfer.create(USDC, amount, recipient, maxFee).send()
+  const maxFee = TokenAmount.fromStringDecimal(Optimism.USDC, '1')
+  TransferBuilder.forChain(ChainId.OPTIMISM)
+    .addTransferFromStringDecimal(Optimism.USDC, '1', recipient)
+    .build()
+    .send(maxFee)
 }

examples/01-simple-transfer/tests/function.spec.ts

@@ -1,5 +1,5 @@
 import { OpType } from '@mimicprotocol/sdk'
-import { Context, runFunction, Transfer } from '@mimicprotocol/test-ts'
+import { Context, runFunction, TransferOperation } from '@mimicprotocol/test-ts'
 import { expect } from 'chai'
 
 describe('Function', () => {
@@ -16,20 +16,21 @@ describe('Function', () => {
     expect(result.success).to.be.true
     expect(result.timestamp).to.be.equal(context.timestamp)
 
-    const intents = result.intents as Transfer[]
-    expect(intents).to.have.lengthOf(1)
+    expect(result.intents).to.have.lengthOf(1)
+    const intent = result.intents[0]
+    const op = intent.operations[0] as TransferOperation
 
-    expect(intents[0].op).to.be.equal(OpType.Transfer)
-    expect(intents[0].settler).to.be.equal(context.settlers?.[0].address)
-    expect(intents[0].user).to.be.equal(context.user)
-    expect(intents[0].chainId).to.be.equal(10)
-    expect(intents[0].maxFees).to.have.lengthOf(1)
-    expect(intents[0].maxFees[0].token).to.be.equal('0x7f5c764cbc14f9669b88837ca1490cca17c31607')
-    expect(intents[0].maxFees[0].amount).to.be.equal('100000')
+    expect(op.opType).to.be.equal(OpType.Transfer)
+    expect(intent.settler).to.be.equal(context.settlers?.[0].address)
+    expect(op.user).to.be.equal(context.user)
+    expect(op.chainId).to.be.equal(10)
+    expect(intent.maxFees).to.have.lengthOf(1)
+    expect(intent.maxFees[0].token).to.be.equal('0x0b2c639c533813f4aa9d7837caf62653d097ff85')
+    expect(intent.maxFees[0].amount).to.be.equal('1000000')
 
-    expect(intents[0].transfers).to.have.lengthOf(1)
-    expect(intents[0].transfers[0].token).to.be.equal('0x7f5c764cbc14f9669b88837ca1490cca17c31607')
-    expect(intents[0].transfers[0].amount).to.be.equal('1000000')
-    expect(intents[0].transfers[0].recipient).to.be.equal('0xbce3248ede29116e4bd18416dcc2dfca668eeb84')
+    expect(op.transfers).to.have.lengthOf(1)
+    expect(op.transfers[0].token).to.be.equal('0x0b2c639c533813f4aa9d7837caf62653d097ff85')
+    expect(op.transfers[0].amount).to.be.equal('1000000')
+    expect(op.transfers[0].recipient).to.be.equal('0xbce3248ede29116e4bd18416dcc2dfca668eeb84')
   })
 })

examples/02-simple-transfer-with-inputs/src/function.ts

@@ -1,10 +1,10 @@
-import { BigInt, ERC20Token, Transfer } from '@mimicprotocol/lib-ts'
+import { ERC20Token, TokenAmount, TransferBuilder } from '@mimicprotocol/lib-ts'
 
 import { inputs } from './types'
 
 export default function main(): void {
   const token = ERC20Token.fromAddress(inputs.token, inputs.chainId)
-  const amount = BigInt.fromStringDecimal(inputs.amount, token.decimals)
-  const maxFee = BigInt.fromStringDecimal(inputs.maxFee, token.decimals)
-  Transfer.create(token, amount, inputs.recipient, maxFee).send()
+  const amount = TokenAmount.fromStringDecimal(token, inputs.amount)
+  const maxFee = TokenAmount.fromStringDecimal(token, inputs.maxFee)
+  TransferBuilder.forChain(inputs.chainId).addTransferFromTokenAmount(amount, inputs.recipient).build().send(maxFee)
 }

examples/02-simple-transfer-with-inputs/tests/function.spec.ts

@@ -1,5 +1,5 @@
 import { fp, OpType, randomEvmAddress } from '@mimicprotocol/sdk'
-import { Context, EvmCallQueryMock, runFunction, Transfer } from '@mimicprotocol/test-ts'
+import { Context, EvmCallQueryMock, runFunction, TransferOperation } from '@mimicprotocol/test-ts'
 import { expect } from 'chai'
 import { Interface } from 'ethers'
 
@@ -40,20 +40,21 @@ describe('Function', () => {
     expect(result.success).to.be.true
     expect(result.timestamp).to.be.equal(context.timestamp)
 
-    const intents = result.intents as Transfer[]
-    expect(intents).to.have.lengthOf(1)
-
-    expect(intents[0].op).to.be.equal(OpType.Transfer)
-    expect(intents[0].settler).to.be.equal(context.settlers?.[0].address)
-    expect(intents[0].user).to.be.equal(context.user)
-    expect(intents[0].chainId).to.be.equal(inputs.chainId)
-    expect(intents[0].maxFees).to.have.lengthOf(1)
-    expect(intents[0].maxFees[0].token).to.be.equal(inputs.token)
-    expect(intents[0].maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
-
-    expect(intents[0].transfers).to.have.lengthOf(1)
-    expect(intents[0].transfers[0].token).to.be.equal(inputs.token)
-    expect(intents[0].transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
-    expect(intents[0].transfers[0].recipient).to.be.equal(inputs.recipient)
+    expect(result.intents).to.have.lengthOf(1)
+    const intent = result.intents[0]
+    const op = intent.operations[0] as TransferOperation
+
+    expect(op.opType).to.be.equal(OpType.Transfer)
+    expect(intent.settler).to.be.equal(context.settlers?.[0].address)
+    expect(op.user).to.be.equal(context.user)
+    expect(op.chainId).to.be.equal(inputs.chainId)
+    expect(intent.maxFees).to.have.lengthOf(1)
+    expect(intent.maxFees[0].token).to.be.equal(inputs.token)
+    expect(intent.maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
+
+    expect(op.transfers).to.have.lengthOf(1)
+    expect(op.transfers[0].token).to.be.equal(inputs.token)
+    expect(op.transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
+    expect(op.transfers[0].recipient).to.be.equal(inputs.recipient)
   })
 })

examples/03-transfer-balance-threshold/src/function.ts

@@ -1,4 +1,4 @@
-import { BigInt, ERC20Token, Transfer } from '@mimicprotocol/lib-ts'
+import { BigInt, ERC20Token, TokenAmount, TransferBuilder } from '@mimicprotocol/lib-ts'
 
 import { ERC20 } from './types/ERC20'
 import { inputs } from './types'
@@ -10,8 +10,8 @@ export default function main(): void {
   const threshold = BigInt.fromStringDecimal(inputs.threshold, token.decimals)
 
   if (balance.lt(threshold)) {
-    const amount = BigInt.fromStringDecimal(inputs.amount, token.decimals)
-    const maxFee = BigInt.fromStringDecimal(inputs.maxFee, token.decimals)
-    Transfer.create(token, amount, inputs.recipient, maxFee).send()
+    const amount = TokenAmount.fromStringDecimal(token, inputs.amount)
+    const maxFee = TokenAmount.fromStringDecimal(token, inputs.maxFee)
+    TransferBuilder.forChain(inputs.chainId).addTransferFromTokenAmount(amount, inputs.recipient).build().send(maxFee)
   }
 }

examples/03-transfer-balance-threshold/tests/function.spec.ts

@@ -1,5 +1,5 @@
 import { fp, OpType, randomEvmAddress } from '@mimicprotocol/sdk'
-import { Context, EvmCallQueryMock, runFunction, Transfer } from '@mimicprotocol/test-ts'
+import { Context, EvmCallQueryMock, runFunction, TransferOperation } from '@mimicprotocol/test-ts'
 import { expect } from 'chai'
 import { Interface } from 'ethers'
 
@@ -54,21 +54,22 @@ describe('Function', () => {
       expect(result.success).to.be.true
       expect(result.timestamp).to.be.equal(context.timestamp)
 
-      const intents = result.intents as Transfer[]
-      expect(intents).to.have.lengthOf(1)
+      expect(result.intents).to.have.lengthOf(1)
+      const intent = result.intents[0]
+      const op = intent.operations[0] as TransferOperation
 
-      expect(intents[0].op).to.be.equal(OpType.Transfer)
-      expect(intents[0].settler).to.be.equal(context.settlers?.[0].address)
-      expect(intents[0].user).to.be.equal(context.user)
-      expect(intents[0].chainId).to.be.equal(inputs.chainId)
-      expect(intents[0].maxFees).to.have.lengthOf(1)
-      expect(intents[0].maxFees[0].token).to.be.equal(inputs.token)
-      expect(intents[0].maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
+      expect(op.opType).to.be.equal(OpType.Transfer)
+      expect(intent.settler).to.be.equal(context.settlers?.[0].address)
+      expect(op.user).to.be.equal(context.user)
+      expect(op.chainId).to.be.equal(inputs.chainId)
+      expect(intent.maxFees).to.have.lengthOf(1)
+      expect(intent.maxFees[0].token).to.be.equal(inputs.token)
+      expect(intent.maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
 
-      expect(intents[0].transfers).to.have.lengthOf(1)
-      expect(intents[0].transfers[0].token).to.be.equal(inputs.token)
-      expect(intents[0].transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
-      expect(intents[0].transfers[0].recipient).to.be.equal(inputs.recipient)
+      expect(op.transfers).to.have.lengthOf(1)
+      expect(op.transfers[0].token).to.be.equal(inputs.token)
+      expect(op.transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
+      expect(op.transfers[0].recipient).to.be.equal(inputs.recipient)
     })
   })
 

examples/04-transfer-balance-threshold-with-oracles/src/function.ts

@@ -1,4 +1,4 @@
-import { BigInt, ERC20Token, log, TokenAmount, Transfer, USD } from '@mimicprotocol/lib-ts'
+import { ERC20Token, log, TokenAmount, TransferBuilder, USD } from '@mimicprotocol/lib-ts'
 
 import { ERC20 } from './types/ERC20'
 import { inputs } from './types'
@@ -13,8 +13,8 @@ export default function main(): void {
   log.info(`Balance in USD: ${balanceInUsd}`)
 
   if (balanceInUsd.lt(thresholdUsd)) {
-    const amount = BigInt.fromStringDecimal(inputs.amount, token.decimals)
-    const maxFee = BigInt.fromStringDecimal(inputs.maxFee, token.decimals)
-    Transfer.create(token, amount, inputs.recipient, maxFee).send()
+    const amount = TokenAmount.fromStringDecimal(token, inputs.amount)
+    const maxFee = TokenAmount.fromStringDecimal(token, inputs.maxFee)
+    TransferBuilder.forChain(inputs.chainId).addTransferFromTokenAmount(amount, inputs.recipient).build().send(maxFee)
   }
 }

examples/04-transfer-balance-threshold-with-oracles/tests/function.spec.ts

@@ -1,5 +1,5 @@
 import { fp, OpType, randomEvmAddress } from '@mimicprotocol/sdk'
-import { Context, EvmCallQueryMock, runFunction, TokenPriceQueryMock, Transfer } from '@mimicprotocol/test-ts'
+import { Context, EvmCallQueryMock, runFunction, TokenPriceQueryMock, TransferOperation } from '@mimicprotocol/test-ts'
 import { expect } from 'chai'
 import { Interface } from 'ethers'
 
@@ -61,21 +61,22 @@ describe('Function', () => {
       expect(result.success).to.be.true
       expect(result.timestamp).to.be.equal(context.timestamp)
 
-      const intents = result.intents as Transfer[]
-      expect(intents).to.have.lengthOf(1)
-
-      expect(intents[0].op).to.be.equal(OpType.Transfer)
-      expect(intents[0].settler).to.be.equal(context.settlers?.[0].address)
-      expect(intents[0].user).to.be.equal(context.user)
-      expect(intents[0].chainId).to.be.equal(inputs.chainId)
-      expect(intents[0].maxFees.length).to.be.equal(1)
-      expect(intents[0].maxFees[0].token).to.be.equal(inputs.token)
-      expect(intents[0].maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
-
-      expect(intents[0].transfers).to.have.lengthOf(1)
-      expect(intents[0].transfers[0].token).to.be.equal(inputs.token)
-      expect(intents[0].transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
-      expect(intents[0].transfers[0].recipient).to.be.equal(inputs.recipient)
+      expect(result.intents).to.have.lengthOf(1)
+      const intent = result.intents[0]
+      const op = intent.operations[0] as TransferOperation
+
+      expect(op.opType).to.be.equal(OpType.Transfer)
+      expect(intent.settler).to.be.equal(context.settlers?.[0].address)
+      expect(op.user).to.be.equal(context.user)
+      expect(op.chainId).to.be.equal(inputs.chainId)
+      expect(intent.maxFees.length).to.be.equal(1)
+      expect(intent.maxFees[0].token).to.be.equal(inputs.token)
+      expect(intent.maxFees[0].amount).to.be.equal(fp(inputs.maxFee, 6).toString())
+
+      expect(op.transfers).to.have.lengthOf(1)
+      expect(op.transfers[0].token).to.be.equal(inputs.token)
+      expect(op.transfers[0].amount).to.be.equal(fp(inputs.amount, 6).toString())
+      expect(op.transfers[0].recipient).to.be.equal(inputs.recipient)
 
       expect(result.logs).to.have.lengthOf(1)
       expect(result.logs[0]).to.be.equal('[Info] Balance in USD: 9')

examples/05-invest-aave-idle-balance/src/function.ts

@@ -36,5 +36,5 @@ export default function main(): void {
 
   // Use mimic credits to pay for the transaction fee
   const feeWithCredits = TokenAmount.fromStringDecimal(DenominationToken.USD(), inputs.maxFeeUsd)
-  calls.addUser(inputs.smartAccount).addMaxFee(feeWithCredits).build().send()
+  calls.addUser(inputs.smartAccount).build().send(feeWithCredits)
 }

examples/05-invest-aave-idle-balance/tests/function.spec.ts

@@ -1,5 +1,5 @@
-import { EvmCallIntent, OpType, randomEvmAddress } from '@mimicprotocol/sdk'
-import { Context, EvmCallQueryMock, runFunction, TokenPriceQueryMock } from '@mimicprotocol/test-ts'
+import { OpType, randomEvmAddress } from '@mimicprotocol/sdk'
+import { CallOperation, Context, EvmCallQueryMock, runFunction, TokenPriceQueryMock } from '@mimicprotocol/test-ts'
 import { expect } from 'chai'
 import { Interface } from 'ethers'
 
@@ -128,28 +128,29 @@ describe('Function', () => {
       expect(result.success).to.be.true
       expect(result.timestamp).to.be.equal(context.timestamp)
 
-      const intents = result.intents as EvmCallIntent[]
-      expect(intents).to.have.lengthOf(1)
+      expect(result.intents).to.have.lengthOf(1)
+      const intent = result.intents[0]
+      const op = intent.operations[0] as CallOperation
 
-      expect(intents[0].op).to.be.equal(OpType.EvmCall)
-      expect(intents[0].settler).to.be.equal(context.settlers?.[0].address)
-      expect(intents[0].user).to.be.equal(inputs.smartAccount)
-      expect(intents[0].chainId).to.be.equal(inputs.chainId)
+      expect(op.opType).to.be.equal(OpType.EvmCall)
+      expect(intent.settler).to.be.equal(context.settlers?.[0].address)
+      expect(op.user).to.be.equal(inputs.smartAccount)
+      expect(op.chainId).to.be.equal(inputs.chainId)
 
       const expectedApproveData = ERC20Interface.encodeFunctionData('approve', [aavePool, balance])
-      expect(intents[0].calls[0].target).to.be.equal(underlyingToken)
-      expect(intents[0].calls[0].value).to.be.equal('0')
-      expect(intents[0].calls[0].data).to.be.equal(expectedApproveData)
+      expect(op.calls[0].target).to.be.equal(underlyingToken)
+      expect(op.calls[0].value).to.be.equal('0')
+      expect(op.calls[0].data).to.be.equal(expectedApproveData)
 
       const expectedSupplyData = AavePoolInterface.encodeFunctionData('supply(address,uint256,address,uint16)', [
         underlyingToken,
         balance,
         inputs.smartAccount,
         0,
       ])
-      expect(intents[0].calls[1].target).to.be.equal(aavePool)
-      expect(intents[0].calls[1].value).to.be.equal('0')
-      expect(intents[0].calls[1].data).to.be.equal(expectedSupplyData)
+      expect(op.calls[1].target).to.be.equal(aavePool)
+      expect(op.calls[1].value).to.be.equal('0')
+      expect(op.calls[1].data).to.be.equal(expectedSupplyData)
 
       expect(result.logs).to.have.lengthOf(1)
       expect(result.logs[0]).to.be.equal('[Info] Underlying balance in USD: 11')