Design Contract model

[Keith-CY]

• extends from Store model
• default storage layout
• interfaces
  • deploy(): deploy the contract onto the chain
  • extend(): extends from an existing Contract model for overriding
  • upgrade(): upgrade the contract on the chain
  • run(method: string, params: Array): call a method of the contract to update or get its state(structured data)
  • link(interfaces: Array): instantiate a contract SDK from interfaces
• metadata extends from that of Store
  • API

[felicityin]

Does a virtual machine need to be provided to execute a method of the contract?

[Keith-CY]

Does a virtual machine need to be provided to execute a method of the contract?

A method of a contract model is a state transition function(https://github.com/ckb-js/topics/compare/add-draft-of-kuai-proposal?expand=1#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R31) derives from the logic of the on-chain contract.

Calling the method just outputs a new state but not verifies the transition so a virtual machine is not required.

[felicityin]

Calling the method just outputs a new state but not verifies the transition so a virtual machine is not required.

old state -> compute -> new state

Who will compute? Does the new state can be recomputed by anyone? If not, how to ensure that the new state is correct?

[Keith-CY]

Calling the method just outputs a new state but not verifies the transition so a virtual machine is not required.

old state -> compute -> new state

Who will compute? Does the new state can be recomputed by anyone? If not, how to ensure that the new state is correct?

That's the work of dapp developers.

The framework defines the interface of each component and manages how components work together.

Framework users(dapp developers) follow the convention and implement their own business logic in the components.

How the new state is calculated is determined by framework users, they may adopt various algorithms to generate a new state. And the correctness should be guaranteed by themselves.

[Keith-CY]

How is it going

[yanguoyu]

I only defined three interfaces for Contract, I didn't think of anything else which should be in Contract.

import { OutPointString, State, Store } from "./store";

export default class Contract<T extends State> extends Store<T> {
  create(contract: T) {
    // create a contract cell
  }

  update(key: OutPointString, newContract: T) {
    // update a contract cell
  }

  destory(key: OutPointString) {
    // destory a contract cell
  }
}

[yanguoyu]

Contract maybe like this:

import { ActorURI, MessagePayload } from "../actor";
import Store from "../store";

enum MethodResponseStatus {
  Failed = 0,
  Success
}

interface ContractMethodResponse {
  status: MethodResponseStatus
  reason?: any
  data?: any
}

type MethodType = 'call' | 'cast'

interface ContractMethodInterface {
  [key: ActorURI]: {
    payload: MessagePayload
    result?: ContractMethodResponse
  }
}

export interface State {}

export default class Contract extends Store {

// This is used to update the state when the contract is updated.
  update(oldState: State): State {
    return {}
  }

  run(to: ActorURI, type: 'call' | 'cast', payload: MessagePayload, timeout?: number): Promise<ContractMethodResponse> | void {
    let promise
    switch (type) {
      case 'call':
        promise = this.call(to, payload, timeout)
        break
      case 'cast':
        promise = this.cast(to, payload, timeout)
      default:
        break;
    }
    if (promise) {
      promise.then(res => ({
        status: MethodResponseStatus.Success,
        data: res
      }))
      .catch(err => ({
        status: MethodResponseStatus.Failed,
        reason: err.message ?? err.toString()
      }))
    }
  }

  // link others contracts methods, it may be a service
  link<T extends ContractMethodInterface>(contractAPIs: {
    [P in keyof T]: MethodType
  }) {
    const attacthMethods: Record<ActorURI, PropertyDescriptor> = {}
    Object.keys(contractAPIs).forEach((to: keyof T) => {
      attacthMethods[to as string] = {
        value: (p: any) => this.run(to as string, contractAPIs[to], p),
        enumerable: true
      }
    })
    Object.defineProperties(this, attacthMethods)
    return this as unknown as InstanceType<typeof Contract> & {
      [P in keyof T]: (param: T[P]['payload']) => Promise<T[P]['result']>
    }
  }
}

And the example is like this If I get the .bit contract interface. I can link .bit contract methods

const contract = new Contract()
type BitMethodInterface = {
  'transfter': {
    payload: {
      symbol: symbol
      value: {
        domain: string
      }
    }
    result: ContractMethodResponse
  }
}

const a = contract.link<BitMethodInterface>({
  transfter: 'call'
})
a.transfter({
  symbol: Symbol('c'),
  value: {
    domain: 'aaaa'
  }
})