orders submitting but breaking due to fee send

src/blockchain/orderlib.js

@@ -22,13 +22,17 @@ export const DISTANT_FUTURE = uint32max
 //     Exchange exchange;
 //     uint24 fee;
 // }
-export function newOrder(tokenIn, tokenOut, exchange, fee, amount, amountIsInput, tranches, minAmount=null,
+export function newOrder(tokenIn, tokenOut, exchange, fee, amount, amountIsInput, tranches,
-                         outputToOwner = false, chainOrder = NO_CHAIN) {
+                         minFillAmount=null, outputDirectlyToOwner = false, chainOrder = NO_CHAIN) {
     if (!tranches)
         tranches = [newTranche({marketOrder: true})] // todo this is just a swap: issue warning?
-    if( minAmount === null )
+    if( minFillAmount === null )
-        minAmount = BigInt(amount) / 100n  // default to min trade size of 1%
+        minFillAmount = BigInt(amount) / 100n  // default to min trade size of 1%
-    return [tokenIn, tokenOut, [exchange, fee], amount, minAmount, amountIsInput, outputToOwner, chainOrder, tranches]
+    return {
+        tokenIn, tokenOut, route:{exchange, fee},
+        amount, minFillAmount, amountIsInput,
+        outputDirectlyToOwner, chainOrder, tranches
+    }
 }
 
 // struct Tranche {
@@ -55,23 +59,24 @@ export function newOrder(tokenIn, tokenOut, exchange, fee, amount, amountIsInput
 //     float  maxSlope;
 // }
 export function newTranche({
-                               fraction = MAX_FRACTION,
+                            fraction = MAX_FRACTION,
-                               marketOrder = false,
+                            marketOrder = false,
-                               startTimeIsRelative = false,
+                            startTimeIsRelative = false,
-                               startTime = DISTANT_PAST,
+                            startTime = DISTANT_PAST,
-                               endTimeIsRelative = false,
+                            endTimeIsRelative = false,
-                               endTime = DISTANT_FUTURE,
+                            endTime = DISTANT_FUTURE,
-                               minIsBarrier = false,
+                            minIsBarrier = false,
-                               minIntercept = 0,
+                            minIntercept = 0,
-                               minSlope = 0,
+                            slippage = 0, // may also set minIntercept instead
-                               maxIsBarrier = false,
+                            minSlope = 0,
-                               maxIntercept = 0,
+                            maxIsBarrier = false,
-                               maxSlope = 0,
+                            maxIntercept = 0,
+                            maxSlope = 0,
                            } = {}) {
     if( minIntercept === 0 && minSlope === 0 && maxIntercept === 0 && maxSlope === 0 )
         marketOrder = true
     if( marketOrder )
-        minIntercept = encodeIEE754(minIntercept)  // this is the slippage field for market orders
+        minIntercept = encodeIEE754(slippage)  // this is the slippage field for market orders
     else {
         minIntercept = encodeIEE754(minIntercept)
         minSlope = encodeIEE754(minSlope)

src/blockchain/wallet.js

@@ -3,15 +3,34 @@ import {useStore} from "@/store/store";
 import {socket} from "@/socket.js";
 import {contractOrNull, vaultAddress} from "@/blockchain/contract.js";
 import {vaultAbi} from "@/blockchain/abi.js";
-import {SingletonCoroutine, sleep} from "@/misc.js";
+import {SingletonCoroutine} from "@/misc.js";
+import {defineStore} from "pinia";
+import {ref} from "vue";
+
+
+export const useWalletStore = defineStore('wallet', ()=>{
+  // Pending Order Format
+  // {
+  //   chainId: 31337,  // must never be null, even if no wallet plugin exists.  chosen by app, not wallet.
+  //   placementTime: Date.now(),
+  //   vault: '0x...',  // or null if account not logged in yet
+  //   order: {tokenIn:..., tokenOut:..., ...} // blockchain binary order object
+  // }
+  const pendingOrders = ref([])
+
+  return {
+    pendingOrders,
+  }
+})
 
 
 export function onChainChanged(chainId) {
   chainId = Number(chainId)
   const store = useStore()
-  if( chainId !== store.chainId ) {
+  if( chainId !== store.chainId.value ) {
+    // todo check pending orders and confirm cancellation
     console.log('chain changed', chainId)
-    store.chainId = chainId
+    store.chainId.value = chainId
     store.account = null
     const provider = new ethers.BrowserProvider(window.ethereum, chainId);
     store.provider = provider
@@ -86,12 +105,10 @@ const errorHandlingProxy = {
 }
 
 
-export async function connectWallet() {
+export async function connectWallet(chainId) {
-  await new ethers.BrowserProvider(window.ethereum).getSigner();
+  await new ethers.BrowserProvider(window.ethereum, chainId).getSigner();
 }
 
-let pendingOrders = []
-
 
 function discoverVaults(owner) {
   const s = useStore()
@@ -106,7 +123,7 @@ const doDiscoverVaults = new SingletonCoroutine(_discoverVaults, 50, false)
 async function _discoverVaults(owner) {
   const result = []
   const s = useStore()
-  if( !owner || !s.chainId || !s.account) {
+  if( !owner || !s.chainId.value || !s.account) {
     s.vaults = []
     return
   }
@@ -138,7 +155,7 @@ async function _discoverVaults(owner) {
   }
   if( s.account === owner ) { // double-check the account since it could have changed during our await
     s.vaults = result
-    if( pendingOrders.length )
+    if( useWalletStore().pendingOrders.length )
       if( result.length )
         flushOrders(result[0])
       else
@@ -148,15 +165,21 @@ async function _discoverVaults(owner) {
 
 
 export function ensureVault() {
-  const s = useStore()
+  ensureVaultFunc.invoke()
-  const owner = s.account;
-  console.log('ensureVault', s.chainId.value, owner)
-  if( !owner )
-    return
-  ensureVault2(s.chainId.value, owner, 0)
 }
 
 
+const ensureVaultFunc = new SingletonCoroutine(ensureVault1,1)
+
+
+async function ensureVault1() {
+  const s = useStore()
+  const owner = s.account;
+  if (owner===null)
+    await connectWallet(s.chainId.value)
+  ensureVault2(s.chainId.value, owner, 0)
+}
+
 export function ensureVault2(chainId, owner, num) {
   console.log('ensureVault2', chainId, owner, num)
   if( !chainId ) {
@@ -179,20 +202,19 @@ async function doEnsureVault(chainId, owner, num) {
   // await sleep(5000) // prevent this process from running more than once every 5 seconds
 }
 
-const ensureVaultRoutine = new SingletonCoroutine(doEnsureVault, 100, false)
+const ensureVaultRoutine = new SingletonCoroutine(doEnsureVault, 100)
 
 
 export async function pendOrder(order) {
   console.log('order', JSON.stringify(order))
   const s = useStore()
-  if (!s.vaults.length) {
+  useWalletStore().pendingOrders.push({
-    pendingOrders.push(order)
+    chainId: s.chainId.value,
-    ensureVault()
+    placementTime: new Date(),
-  }
+    vault: s.vaults.length ? s.vaults[0] : null,
-  else {
+    order
-    const vault = s.vaults[0];
+  })
-    pendOrderAsTransaction(vault, order)
+  ensureVault()
-  }
 }
 
 
@@ -220,21 +242,26 @@ export async function cancelAll(vault) {
 }
 
 export function flushOrders(vault) {
-  for( const order of pendingOrders )
+  const ws = useWalletStore();
-    pendOrderAsTransaction(vault, order)
+  for( const order of ws.pendingOrders ) {
-  pendingOrders = []
+    if (order.vault === null)
+      order.vault = vault
+    pendOrderAsTransaction(order)
+  }
+  ws.pendingOrders = []
   flushTransactions()
 }
 
 
-function pendOrderAsTransaction(vault, order) {
+function pendOrderAsTransaction(order) {
   pendTransaction(async (signer)=> {
-    const contract = contractOrNull(vault, vaultAbi, signer)
+    const contract = contractOrNull(order.vault, vaultAbi, signer)
     if( contract === null ) {
-      console.error('vault contract was null while sending order transaction', vault)
+      console.error('vault contract was null while sending order transaction', order.vault)
       return null
     }
-    return await contract.placeOrder(order)
+    console.log('placing order', order)
+    return await contract.placeOrder(order.order) // todo update status
   })
 }
 

src/components/chart/ChartOrder.vue

@@ -18,7 +18,7 @@
                  :color="color" variant="text" @click="order.amountIsTokenA=!order.amountIsTokenA"/>
         </template>
       </v-text-field>
-      <template v-for="b in builders(order)">
+      <template v-for="b in order.builders">
         <builder-factory :order="order" :builder="b"/>
       </template>
       <div class="my-3">
@@ -35,17 +35,12 @@
   </row-bar>
 </template>
 
-<script>
-import {newBuilder} from "@/orderbuild.js";
-const defaultMarketBuilder = newBuilder('MarketBuilder')
-</script>
-
 <script setup>
 
 import BuilderFactory from "@/components/chart/BuilderFactory.vue";
 import {newBuilder, useChartOrderStore} from "@/orderbuild.js";
 import {useOrderStore} from "@/store/store.js";
-import {computed} from "vue";
+import {computed, watch} from "vue";
 import {lightenColor, lightenColor2} from "@/misc.js";
 import {useTheme} from "vuetify";
 import RowBar from "@/components/chart/RowBar.vue";
@@ -56,16 +51,21 @@ const props = defineProps(['order'])
 const co = useChartOrderStore()
 const os = useOrderStore()
 
+const marketBuilder = newBuilder('MarketBuilder')
 console.log('order', props.order)
 function build(order, component, options={}) {
   order.builders.push(newBuilder(component, options))
 }
 
-function builders(order) {
+function marketBuilderWatcher() {
-  let result = order.builders
+  if (props.order.builders.length === 0)
-  return result.length > 0 ? result : [defaultMarketBuilder]
+    props.order.builders.push(marketBuilder)
+  else if (props.order.builders.length>=2 && props.order.builders[0] === marketBuilder)
+    props.order.builders = props.order.builders.filter((b)=>b!==marketBuilder)
 }
 
+watch(props.order, marketBuilderWatcher)
+
 const theme = useTheme().current
 const color = computed(()=>new Color(props.order.buy?theme.value.colors.success:theme.value.colors.error).darken(0.2).string())
 const lightColor = computed(() => lightenColor(color.value))

src/components/chart/ChartOrderPane.vue

@@ -2,7 +2,7 @@
   <div class="d-flex flex-column h-100">
     <toolbar>
       <v-btn variant="flat" prepend-icon="mdi-plus" @click="co.newOrder" v-if="co.orders.length===0">New Order</v-btn>
-      <v-btn variant="text" prepend-icon="mdi-send" :color="orderColor" v-if="co.orders.length>0">Place Order</v-btn>
+      <v-btn variant="text" prepend-icon="mdi-send" @click="placeOrder" :color="orderColor" v-if="co.orders.length>0">Place Order</v-btn>
       <v-btn variant="flat" prepend-icon="mdi-cancel" v-if="co.orders.length>0" @click="cancelOrder">Cancel</v-btn>
     </toolbar>
     <v-dialog v-model="showCancel" max-width="300">
@@ -24,7 +24,7 @@
 </template>
 
 <script setup>
-import {useChartOrderStore} from "@/orderbuild.js";
+import {builderFuncs, useChartOrderStore} from "@/orderbuild.js";
 import {addSymbolChangedCallback, removeSymbolChangedCallback} from "@/charts/chart.js";
 import {computed, onBeforeUnmount, ref} from "vue";
 import {useOrderStore, useStore} from "@/store/store.js";
@@ -33,6 +33,8 @@ import {routeFinder} from "@/blockchain/route.js";
 import ChartOrder from "@/components/chart/ChartOrder.vue";
 import {useTheme} from "vuetify";
 import Toolbar from "@/components/chart/Toolbar.vue";
+import {Exchange, newOrder} from "@/blockchain/orderlib.js";
+import {pendOrder} from "@/blockchain/wallet.js";
 
 const s = useStore()
 const co = useChartOrderStore()
@@ -59,8 +61,48 @@ function cancelOrder() {
   showCancel.value = true
 }
 
-function placeOrder() {
+async function placeOrder() {
-
+  const co = useChartOrderStore();
+  const chartOrders = co.orders;
+  const built = []
+  for (const chartOrder of chartOrders) {
+    console.log('chartOrder', chartOrder)
+    let tranches = []
+    for (const builder of chartOrder.builders) {
+      console.log('builder', builder)
+      const ts = builderFuncs[builder.id]()
+      console.log('tranches', ts)
+      tranches = [...tranches, ...ts]
+    }
+    // struct SwapOrder {
+    //     address tokenIn;
+    //     address tokenOut;
+    //     Route route;
+    //     uint256 amount;
+    //     uint256 minFillAmount;  // if a tranche has less than this amount available to fill, it is considered completed
+    //     bool amountIsInput;
+    //     bool outputDirectlyToOwner;
+    //     uint64 chainOrder; // use NO_CHAIN for no chaining. chainOrder index must be < than this order's index for safety (written first) and chainOrder state must be Template
+    //     Tranche[] tranches;
+    // }
+    const symbol = co.selectedSymbol
+    const fee = co.selectedPool[1]
+    const tokenIn = chartOrder.buy ^ symbol.inverted ? symbol.quote : symbol.base
+    const tokenOut = chartOrder.buy ^ symbol.inverted ? symbol.base : symbol.quote
+    const amountDec = chartOrder.amountIsTokenA ? tokenIn.d : tokenOut.d
+    const amount = Math.trunc(chartOrder.amount * 10 ** amountDec)
+    const amountIsInput = !!(chartOrder.amountIsTokenA ^ chartOrder.buy)
+    const order = newOrder(tokenIn.a, tokenOut.a, Exchange.UniswapV3, fee, amount, amountIsInput, tranches)
+    built.push(order)
+  }
+  co.built = built
+  console.log('place orders', built)
+  if (built.length !== 1) {
+    console.error('Multiple orders not supported')
+  }
+  else {
+    await pendOrder(built[0])
+  }
 }
 
 </script>

src/components/chart/LimitBuilder.vue

@@ -60,9 +60,9 @@
 </template>
 
 <script setup>
-import {computed, onBeforeUnmount, onMounted, watch} from "vue";
+import {computed, onBeforeUnmount, onMounted, onUnmounted, watch} from "vue";
 import {chart} from "@/charts/chart.js";
-import {useChartOrderStore} from "@/orderbuild.js";
+import {applyLine2, builderFuncs, useChartOrderStore} from "@/orderbuild.js";
 import Color from "color";
 import {HLine} from "@/charts/shape.js";
 import {builderDefaults, lightenColor2, lineColor} from "@/misc.js";
@@ -70,6 +70,7 @@ import {useTheme} from "vuetify";
 import {useOrderStore} from "@/store/store.js";
 import RowBar from "@/components/chart/RowBar.vue";
 import ColorBand from "@/components/chart/ColorBand.vue";
+import {MAX_FRACTION, newTranche} from "@/blockchain/orderlib.js";
 
 const os = useOrderStore()
 const co = useChartOrderStore()
@@ -96,6 +97,33 @@ builderDefaults(props, emit, {
   color: defaultColor,
 })
 
+
+function buildTranches() {
+  const builder = props.builder
+  const order = props.order
+  const tranches = []
+  if (!builder || !order) return
+  console.log('buildTranches', builder, order, tranches)
+  const ps = prices.value
+  const ws = weights.value
+  for(let i=0; i<ps.length; i++) {
+    const p = ps[i]
+    const w = ws[i]
+    const t = newTranche({
+      fraction: w * MAX_FRACTION,
+    })
+    const symbol = co.selectedSymbol
+    console.log('symbol', symbol)
+    applyLine2(t, !order.buy, p, 0, symbol.decimals, symbol.inverted)
+    tranches.push(t)
+  }
+  return tranches
+}
+
+onMounted(() => builderFuncs[props.builder.id] = buildTranches)
+onUnmounted(() => delete builderFuncs[props.builder.id])
+
+
 const skew100 = computed( {
   get() {return props.builder.skew*100},
   set(v) {props.builder.skew = v/100; adjustShapes()}
@@ -296,7 +324,7 @@ function allocationText(weight) {
 
 function adjustShapes() {
   // this is where all the lines are created or adjusted
-  console.log('adjustShapes()')
+  // console.log('adjustShapes()')
 
   const limits = prices.value
   const colorStrings = colors.value

src/components/chart/MarketBuilder.vue

@@ -16,11 +16,12 @@
 </template>
 
 <script setup>
-import {useChartOrderStore} from "@/orderbuild.js";
+import {builderFuncs, useChartOrderStore} from "@/orderbuild.js";
 import {builderDefaults} from "@/misc.js";
 import {useOrderStore} from "@/store/store.js";
-import {computed} from "vue";
+import {computed, onMounted, onUnmounted} from "vue";
 import RowBar from "@/components/chart/RowBar.vue";
+import {newTranche} from "@/blockchain/orderlib.js";
 
 const co = useChartOrderStore()
 const props = defineProps(['order', 'builder'])
@@ -34,6 +35,13 @@ const slippage = computed({
 })
 console.log('builder.slippage', props.builder.slippage)
 
+function buildTranches() {
+  return [newTranche({slippage: slippage.value})]
+}
+
+onMounted(() => builderFuncs[props.builder.id] = buildTranches)
+onUnmounted(() => delete builderFuncs[props.builder.id])
+
 </script>
 
 <style scoped lang="scss">

src/orderbuild.js

@@ -25,10 +25,15 @@ const Order = {
 }
 
 
+// the key is order.builder.id and the value is a function() that returns an array of tranches
+export const builderFuncs = {}
+
+
 export const useChartOrderStore = defineStore('chart_orders', () => {
     const chartReady = ref(false)
 
-    const orders = ref([])
+    const orders = ref([])  // order models in UI format
+    const built = ref([])  // orders in blockchain format, ready to send
     const selectedOrder = ref(null)
     const selectedSymbol = ref(null)
     const selectedPool = ref(null)
@@ -38,8 +43,9 @@ export const useChartOrderStore = defineStore('chart_orders', () => {
 
     function newOrder() {
         console.log('cos new order')
-        const order = {id:uuid(), amount:1, amountIsTokenA: true, buy: true, builders:[], }
+        const order = {id:uuid(), amount:1, amountIsTokenA: true, buy: true, builders:[newBuilder('MarketBuilder', {slippage:0.1})], }
         orders.value.push(order)
+        built.value.push({})
         selectedOrder.value = order
     }
 
@@ -129,6 +135,28 @@ export function applyLine(tranche, intercept, slope, isMinimum = null) {
     tranche.marketOrder = false;
 }
 
+
+export function applyLine2(tranche, isMinimum, intercept, slope, poolDecimals, inverted) {
+    // console.log('intercept, slope', intercept, slope)
+    // intercept and slope are still in "human" units of decimal-adjusted prices
+    const scale = 10 ** -poolDecimals
+    let m = inverted ? -scale / slope : slope / scale
+    let b = inverted ? scale / intercept : intercept / scale
+    const cur = b + timestamp() * m
+    console.log('inverted b, m, cur', inverted, b, m, cur)
+    m = encodeIEE754(m)
+    b = encodeIEE754(b)
+    if (isMinimum) {
+        tranche.minIntercept = b;
+        tranche.minSlope = m;
+    } else {
+        tranche.maxIntercept = b;
+        tranche.maxSlope = m;
+    }
+    tranche.marketOrder = false;
+}
+
+
 export function timesliceTranches() {
     const ts = []
     const os = useOrderStore()