Henry Williams

Henry Williams


Set up your own p2p exchange platform with the aid of blockchain specialists

CES has some of the core blockchain specialists in the market working with them who will help set up a p2p exchange platform underpinned by smart contracts escrow, with a goal to benefit both the exchange owner and the users. The state-of-the art smart contracts integration will facilitate seamless, automated payments and takes control over the escrow system to hold and release funds between buyer and seller assuring them guaranteed payments and risk-free trading experience.

What is GEEK

Buddha Community

Set up your own p2p exchange platform with the aid of blockchain specialists
Hermann  Frami

Hermann Frami


A Simple Wrapper Around Amplify AppSync Simulator

This serverless plugin is a wrapper for amplify-appsync-simulator made for testing AppSync APIs built with serverless-appsync-plugin.


npm install serverless-appsync-simulator
# or
yarn add serverless-appsync-simulator


This plugin relies on your serverless yml file and on the serverless-offline plugin.

  - serverless-dynamodb-local # only if you need dynamodb resolvers and you don't have an external dynamodb
  - serverless-appsync-simulator
  - serverless-offline

Note: Order is important serverless-appsync-simulator must go before serverless-offline

To start the simulator, run the following command:

sls offline start

You should see in the logs something like:

Serverless: AppSync endpoint: http://localhost:20002/graphql
Serverless: GraphiQl: http://localhost:20002


Put options under custom.appsync-simulator in your serverless.yml file

| option | default | description | | ------------------------ | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | | apiKey | 0123456789 | When using API_KEY as authentication type, the key to authenticate to the endpoint. | | port | 20002 | AppSync operations port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20002, 20012, 20022, etc.) | | wsPort | 20003 | AppSync subscriptions port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20003, 20013, 20023, etc.) | | location | . (base directory) | Location of the lambda functions handlers. | | refMap | {} | A mapping of resource resolutions for the Ref function | | getAttMap | {} | A mapping of resource resolutions for the GetAtt function | | importValueMap | {} | A mapping of resource resolutions for the ImportValue function | | functions | {} | A mapping of external functions for providing invoke url for external fucntions | | dynamoDb.endpoint | http://localhost:8000 | Dynamodb endpoint. Specify it if you're not using serverless-dynamodb-local. Otherwise, port is taken from dynamodb-local conf | | dynamoDb.region | localhost | Dynamodb region. Specify it if you're connecting to a remote Dynamodb intance. | | dynamoDb.accessKeyId | DEFAULT_ACCESS_KEY | AWS Access Key ID to access DynamoDB | | dynamoDb.secretAccessKey | DEFAULT_SECRET | AWS Secret Key to access DynamoDB | | dynamoDb.sessionToken | DEFAULT_ACCESS_TOKEEN | AWS Session Token to access DynamoDB, only if you have temporary security credentials configured on AWS | | dynamoDb.* | | You can add every configuration accepted by DynamoDB SDK | | rds.dbName | | Name of the database | | rds.dbHost | | Database host | | rds.dbDialect | | Database dialect. Possible values (mysql | postgres) | | rds.dbUsername | | Database username | | rds.dbPassword | | Database password | | rds.dbPort | | Database port | | watch | - *.graphql
- *.vtl | Array of glob patterns to watch for hot-reloading. |


    location: '.webpack/service' # use webpack build directory
      endpoint: 'http://my-custom-dynamo:8000'


By default, the simulator will hot-relad when changes to *.graphql or *.vtl files are detected. Changes to *.yml files are not supported (yet? - this is a Serverless Framework limitation). You will need to restart the simulator each time you change yml files.

Hot-reloading relies on watchman. Make sure it is installed on your system.

You can change the files being watched with the watch option, which is then passed to watchman as the match expression.


      - ["match", "handlers/**/*.vtl", "wholename"] # => array is interpreted as the literal match expression
      - "*.graphql"                                 # => string like this is equivalent to `["match", "*.graphql"]`

Or you can opt-out by leaving an empty array or set the option to false

Note: Functions should not require hot-reloading, unless you are using a transpiler or a bundler (such as webpack, babel or typescript), un which case you should delegate hot-reloading to that instead.

Resource CloudFormation functions resolution

This plugin supports some resources resolution from the Ref, Fn::GetAtt and Fn::ImportValue functions in your yaml file. It also supports some other Cfn functions such as Fn::Join, Fb::Sub, etc.

Note: Under the hood, this features relies on the cfn-resolver-lib package. For more info on supported cfn functions, refer to the documentation

Basic usage

You can reference resources in your functions' environment variables (that will be accessible from your lambda functions) or datasource definitions. The plugin will automatically resolve them for you.

      Ref: MyBucket # resolves to `my-bucket-name`

      Type: AWS::DynamoDB::Table
        TableName: myTable
      Type: AWS::S3::Bucket
        BucketName: my-bucket-name

# in your appsync config
    name: dynamosource
        Ref: MyDbTable # resolves to `myTable`

Override (or mock) values

Sometimes, some references cannot be resolved, as they come from an Output from Cloudformation; or you might want to use mocked values in your local environment.

In those cases, you can define (or override) those values using the refMap, getAttMap and importValueMap options.

  • refMap takes a mapping of resource name to value pairs
  • getAttMap takes a mapping of resource name to attribute/values pairs
  • importValueMap takes a mapping of import name to values pairs


      # Override `MyDbTable` resolution from the previous example.
      MyDbTable: 'mock-myTable'
      # define ElasticSearchInstance DomainName
        DomainEndpoint: 'localhost:9200'
      other-service-api-url: 'https://other.api.url.com/graphql'

# in your appsync config
    name: elasticsource
      # endpoint resolves as 'http://localhost:9200'
          - ''
          - - https://
            - Fn::GetAtt:
                - ElasticSearchInstance
                - DomainEndpoint

Key-value mock notation

In some special cases you will need to use key-value mock nottation. Good example can be case when you need to include serverless stage value (${self:provider.stage}) in the import name.

This notation can be used with all mocks - refMap, getAttMap and importValueMap

      Fn::ImportValue: other-service-api-${self:provider.stage}-url

      - key: other-service-api-${self:provider.stage}-url
        value: 'https://other.api.url.com/graphql'


This plugin only tries to resolve the following parts of the yml tree:

  • provider.environment
  • functions[*].environment
  • custom.appSync

If you have the need of resolving others, feel free to open an issue and explain your use case.

For now, the supported resources to be automatically resovled by Ref: are:

  • DynamoDb tables
  • S3 Buckets

Feel free to open a PR or an issue to extend them as well.

External functions

When a function is not defined withing the current serverless file you can still call it by providing an invoke url which should point to a REST method. Make sure you specify "get" or "post" for the method. Default is "get", but you probably want "post".

        url: http://localhost:3016/2015-03-31/functions/addUser/invocations
        method: post
        url: https://jsonplaceholder.typicode.com/posts
        method: post

Supported Resolver types

This plugin supports resolvers implemented by amplify-appsync-simulator, as well as custom resolvers.

From Aws Amplify:

  • NONE

Implemented by this plugin

  • HTTP

Relational Database

Sample VTL for a create mutation

#set( $cols = [] )
#set( $vals = [] )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #set( $discard = $cols.add("$toSnake") )
  #if( $util.isBoolean($ctx.args.input[$entry]) )
      #if( $ctx.args.input[$entry] )
        #set( $discard = $vals.add("1") )
        #set( $discard = $vals.add("0") )
      #set( $discard = $vals.add("'$ctx.args.input[$entry]'") )
#set( $valStr = $vals.toString().replace("[","(").replace("]",")") )
#set( $colStr = $cols.toString().replace("[","(").replace("]",")") )
#if ( $valStr.substring(0, 1) != '(' )
  #set( $valStr = "($valStr)" )
#if ( $colStr.substring(0, 1) != '(' )
  #set( $colStr = "($colStr)" )
  "version": "2018-05-29",
  "statements":   ["INSERT INTO <name-of-table> $colStr VALUES $valStr", "SELECT * FROM    <name-of-table> ORDER BY id DESC LIMIT 1"]

Sample VTL for an update mutation

#set( $update = "" )
#set( $equals = "=" )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $cur = $ctx.args.input[$entry] )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #if( $util.isBoolean($cur) )
      #if( $cur )
        #set ( $cur = "1" )
        #set ( $cur = "0" )
  #if ( $util.isNullOrEmpty($update) )
      #set($update = "$toSnake$equals'$cur'" )
      #set($update = "$update,$toSnake$equals'$cur'" )
  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> SET $update WHERE id=$ctx.args.input.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.input.id"]

Sample resolver for delete mutation

  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> set deleted_at=NOW() WHERE id=$ctx.args.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.id"]

Sample mutation response VTL with support for handling AWSDateTime

#set ( $index = -1)
#set ( $result = $util.parseJson($ctx.result) )
#set ( $meta = $result.sqlStatementResults[1].columnMetadata)
#foreach ($column in $meta)
    #set ($index = $index + 1)
    #if ( $column["typeName"] == "timestamptz" )
        #set ($time = $result["sqlStatementResults"][1]["records"][0][$index]["stringValue"] )
        #set ( $nowEpochMillis = $util.time.parseFormattedToEpochMilliSeconds("$time.substring(0,19)+0000", "yyyy-MM-dd HH:mm:ssZ") )
        #set ( $isoDateTime = $util.time.epochMilliSecondsToISO8601($nowEpochMillis) )
        $util.qr( $result["sqlStatementResults"][1]["records"][0][$index].put("stringValue", "$isoDateTime") )
#set ( $res = $util.parseJson($util.rds.toJsonString($util.toJson($result)))[1][0] )
#set ( $response = {} )
#foreach($mapKey in $res.keySet())
    #set ( $s = $mapKey.split("_") )
    #set ( $camelCase="" )
    #set ( $isFirst=true )
    #foreach($entry in $s)
        #if ( $isFirst )
          #set ( $first = $entry.substring(0,1) )
          #set ( $first = $entry.substring(0,1).toUpperCase() )
        #set ( $isFirst=false )
        #set ( $stringLength = $entry.length() )
        #set ( $remaining = $entry.substring(1, $stringLength) )
        #set ( $camelCase = "$camelCase$first$remaining" )
    $util.qr( $response.put("$camelCase", $res[$mapKey]) )

Using Variable Map

Variable map support is limited and does not differentiate numbers and strings data types, please inject them directly if needed.

Will be escaped properly: null, true, and false values.

  "version": "2018-05-29",
  "statements":   [
    "UPDATE <name-of-table> set deleted_at=NOW() WHERE id=:ID",
    "SELECT * FROM <name-of-table> WHERE id=:ID and unix_timestamp > $ctx.args.newerThan"
  variableMap: {
    ":ID": $ctx.args.id,
##    ":TIMESTAMP": $ctx.args.newerThan -- This will be handled as a string!!!


Author: Serverless-appsync
Source Code: https://github.com/serverless-appsync/serverless-appsync-simulator 
License: MIT License

#serverless #sync #graphql 

Mark Anderson

Mark Anderson


Kickstart your business on P2P Lending Software with our Crypto based Platform

Overtake your competitors with unique ideas in the digital marketplace with Blockchain App Factory that offers P2P Lending Software. It contains all the latest features with an efficient engine, stable agreement order and market order, central management system, real-time traceable machine, and much more.

#p2p lending blockchain #p2p lending blockchain platform #p2p lending platforms #peer to peer lending blockchain platform #blockchain-based p2p lending platforms #p2p crypto lending software

Mark Anderson

Mark Anderson


P2P Lending Software Development Services Company | P2P Lending App Development

The P2P lending software has disrupted the financial sector by emerging as a worthy competitor to traditional banks with the instant loan process and extending credit for borrowers with less credit score that would get an opportunity to avail a bank loan. The lending software is highly customizable and dominant in the trade market. It helps to connect borrowers and lenders with an automatic risk evaluation. This platform earns revenue by matchmaking between the borrowers and investors by charging a commission fee.

Attractive Features of P2P Lending Software :

  • Fully automated workflow.
  • Executive dashboard.
  • Cloud-ready application.
  • High-level security system
  • Safe and secure transaction
  • Omni-channel compatibility.
  • Multi-lingual
  • Peer-to-peer network protocol

Efficient benefits of Peer-to-peer Lending Software :

  • Lightning speed processing.
  • Easy to use interface.
  • Flexible and scalable nature.
  • Cost-effective solution.
  • Instant API Integration.
  • Powerful reporting structure.

Lifecycle of Loan Process :

  • The loan origination system provides an easy onboarding process and lightning-fast approval of the loan.
  • Loan management systems offer stringent underwriting, customizable loan products and rule-based automation.
  • Collection Management System enables an automated collection workflow, robust delinquency tracking, instant payment updates and track loan performance.
  • Account Management System ensures in providing accurate accounting, configurable accounting rules and quick update.
  • Reports and dashboards provide predictive analytics and ad-hoc reports.

The Peer-To-Peer lending software is trending in recent years that benefitted millions of users to avail loans in critical situations. It’s high time for investors to consider this platform to reap more business revenue by getting in touch with Blockchain App Factory for better assistance.

#peer to peer lending blockchain platform #p2p lending blockchain #blockchain p2p lending platform #p2p lending blockchain platform #p2p lending platforms #p2p crypto lending software

aaron silva

aaron silva


Exchange your digital assets without any intermediaries via a p2p exchange platform

Overtake your competitors in the industry comfortably by developing a p2p exchange platform. The features provided are a low latency matching engine, acceptance of market order and limit order, an intuitive central management console, a real-time market monitoring mechanism, 24x7 technical support in multiple languages, and lightning-fast processing of transactions.

#p2p exchange platform #p2p crypto exchange script #p2p crypto fiat exchange #peer 2 peer crypto exchange #white label p2p exchange platform

aaron silva

aaron silva


Be informed of how p2p exchange platform development is challenging centralized platforms

With centralized exchanges suffering from repeated hacking attacks, the onus has shifted to p2p exchange platform development that gives high priority to the security and privacy of the traders.

What are the unique features provided by p2p exchange development services?

  • A high-performing matching engine that executes the orders raised by the users with low latency.
  • Spot KYC/AML verification of all the traders in the platform to ensure an authentic user base.
  • Safety measures like two-factor authentication, email authentication, and SSL implementation.
  • An atomic swapping option where assets can be directly exchanged by the users without the presence of middlemen decreasing the chances of a conflict.
  • Preferred trader selection facility where the buyers have full freedom to select their seller and vice-versa.
  • Multilingual technical support is provided round the clock.
  • The acceptance of numerous payment methods to ensure the smooth processing of transactions.

The functioning of a p2p exchange platform

  • Users have to register on the platform.
  • They have to create either a buy or a sell order based on their requirements.
  • Once both the buyers and sellers have negotiated the terms and conditions of the trading deal, the buyer makes the payment to the seller.
  • The seller receives the money from the buyer.
  • The crypto assets will be released from the escrow to the buyer’s wallet.
  • The buyer can transfer it to his personal wallet for more safety.

Hence, a big transformation is happening in the market with the growth of p2p exchange platform development. It offers a friendly user interface and risk-free trading at low fees.

#p2p exchange platform #p2p exchange platform development #p2p cryptocurrency exchange #p2p exchange development services