wasm-ast-types 0.11.3 → 0.13.0

package/src/message-composer/__snapshots__/message-composer.spec.ts.snap

@@ -0,0 +1,271 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`createMessageComposerInterface 1`] = `
+"export interface SG721Message {
+  contractAddress: string;
+  sender: string;
+  transferNft: ({
+    recipient,
+    tokenId
+  }: {
+    recipient: string;
+    tokenId: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  sendNft: ({
+    contract,
+    msg,
+    tokenId
+  }: {
+    contract: string;
+    msg: Binary;
+    tokenId: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  approve: ({
+    expires,
+    spender,
+    tokenId
+  }: {
+    expires?: Expiration;
+    spender: string;
+    tokenId: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  revoke: ({
+    spender,
+    tokenId
+  }: {
+    spender: string;
+    tokenId: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  approveAll: ({
+    expires,
+    operator
+  }: {
+    expires?: Expiration;
+    operator: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  revokeAll: ({
+    operator
+  }: {
+    operator: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  mint: ({
+    extension,
+    owner,
+    tokenId,
+    tokenUri
+  }: {
+    extension: Empty;
+    owner: string;
+    tokenId: string;
+    tokenUri?: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  burn: ({
+    tokenId
+  }: {
+    tokenId: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+}"
+`;
+
+exports[`execute classes 1`] = `
+"export class SG721MessageComposer implements SG721Message {
+  sender: string;
+  contractAddress: string;
+
+  constructor(sender: string, contractAddress: string) {
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.transferNft = this.transferNft.bind(this);
+    this.sendNft = this.sendNft.bind(this);
+    this.approve = this.approve.bind(this);
+    this.revoke = this.revoke.bind(this);
+    this.approveAll = this.approveAll.bind(this);
+    this.revokeAll = this.revokeAll.bind(this);
+    this.mint = this.mint.bind(this);
+    this.burn = this.burn.bind(this);
+  }
+
+  transferNft = ({
+    recipient,
+    tokenId
+  }: {
+    recipient: string;
+    tokenId: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          transfer_nft: {
+            recipient,
+            token_id: tokenId
+          }
+        })),
+        funds
+      })
+    };
+  };
+  sendNft = ({
+    contract,
+    msg,
+    tokenId
+  }: {
+    contract: string;
+    msg: Binary;
+    tokenId: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          send_nft: {
+            contract,
+            msg,
+            token_id: tokenId
+          }
+        })),
+        funds
+      })
+    };
+  };
+  approve = ({
+    expires,
+    spender,
+    tokenId
+  }: {
+    expires?: Expiration;
+    spender: string;
+    tokenId: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          approve: {
+            expires,
+            spender,
+            token_id: tokenId
+          }
+        })),
+        funds
+      })
+    };
+  };
+  revoke = ({
+    spender,
+    tokenId
+  }: {
+    spender: string;
+    tokenId: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          revoke: {
+            spender,
+            token_id: tokenId
+          }
+        })),
+        funds
+      })
+    };
+  };
+  approveAll = ({
+    expires,
+    operator
+  }: {
+    expires?: Expiration;
+    operator: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          approve_all: {
+            expires,
+            operator
+          }
+        })),
+        funds
+      })
+    };
+  };
+  revokeAll = ({
+    operator
+  }: {
+    operator: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          revoke_all: {
+            operator
+          }
+        })),
+        funds
+      })
+    };
+  };
+  mint = ({
+    extension,
+    owner,
+    tokenId,
+    tokenUri
+  }: {
+    extension: Empty;
+    owner: string;
+    tokenId: string;
+    tokenUri?: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          mint: {
+            extension,
+            owner,
+            token_id: tokenId,
+            token_uri: tokenUri
+          }
+        })),
+        funds
+      })
+    };
+  };
+  burn = ({
+    tokenId
+  }: {
+    tokenId: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          burn: {
+            token_id: tokenId
+          }
+        })),
+        funds
+      })
+    };
+  };
+}"
+`;

package/src/message-composer/index.ts

@@ -0,0 +1 @@
+export * from './message-composer';

package/src/message-composer/message-composer.spec.ts

@@ -0,0 +1,25 @@
+import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import {
+    createMessageComposerClass,
+    createMessageComposerInterface
+} from './message-composer'
+import { expectCode, makeContext } from '../../test-utils';
+
+it('execute classes', () => {
+    const ctx = makeContext(execute_msg);
+    expectCode(createMessageComposerClass(
+        ctx,
+        'SG721MessageComposer',
+        'SG721Message',
+        execute_msg
+    ))
+});
+
+it('createMessageComposerInterface', () => {
+    const ctx = makeContext(execute_msg);
+    expectCode(createMessageComposerInterface(
+        ctx,
+        'SG721Message',
+        execute_msg
+    ))
+});

package/src/message-composer/message-composer.ts

@@ -0,0 +1,305 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import {
+    bindMethod,
+    typedIdentifier,
+    classDeclaration,
+    classProperty,
+    arrowFunctionExpression,
+    getMessageProperties
+} from '../utils'
+import { ExecuteMsg } from '../types';
+import { createTypedObjectParams } from '../utils/types';
+import { JSONSchema } from '../types';
+import { RenderContext } from '../context';
+import { identifier } from '../utils/babel';
+import { getWasmMethodArgs } from '../client/client';
+
+const createWasmExecMethodMessageComposer = (
+    context: RenderContext,
+    jsonschema: any
+) => {
+
+    context.addUtil('Coin');
+    context.addUtil('MsgExecuteContractEncodeObject');
+    context.addUtil('MsgExecuteContract');
+    context.addUtil('toUtf8');
+
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const args = getWasmMethodArgs(
+        context,
+        jsonschema.properties[underscoreName]
+    );
+
+    const constantParams = [
+        identifier('funds', t.tsTypeAnnotation(
+            t.tsArrayType(
+                t.tsTypeReference(
+                    t.identifier('Coin')
+                )
+            )
+        ), true)
+    ];
+
+    return t.classProperty(
+        t.identifier(methodName),
+        arrowFunctionExpression(
+            obj ? [
+                // props
+                obj,
+                ...constantParams
+            ] : constantParams,
+            t.blockStatement(
+                [
+                    t.returnStatement(
+
+                        t.objectExpression([
+                            t.objectProperty(
+                                t.identifier('typeUrl'),
+                                t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')
+                            ),
+                            t.objectProperty(
+                                t.identifier('value'),
+                                t.callExpression(
+                                    t.memberExpression(
+                                        t.identifier('MsgExecuteContract'),
+                                        t.identifier('fromPartial')
+                                    ),
+                                    [
+                                        t.objectExpression([
+                                            t.objectProperty(
+                                                t.identifier('sender'),
+                                                t.memberExpression(
+                                                    t.thisExpression(),
+                                                    t.identifier('sender')
+                                                )
+                                            ),
+                                            t.objectProperty(
+                                                t.identifier('contract'),
+                                                t.memberExpression(
+                                                    t.thisExpression(),
+                                                    t.identifier('contractAddress')
+                                                )
+                                            ),
+                                            t.objectProperty(
+                                                t.identifier('msg'),
+                                                t.callExpression(
+                                                    t.identifier('toUtf8'),
+                                                    [
+                                                        t.callExpression(
+                                                            t.memberExpression(
+                                                                t.identifier('JSON'),
+                                                                t.identifier('stringify')
+                                                            ),
+                                                            [
+                                                                t.objectExpression(
+
+                                                                    [
+                                                                        t.objectProperty(
+                                                                            t.identifier(underscoreName), t.objectExpression(args)
+                                                                        )
+                                                                    ]
+
+                                                                )
+                                                            ]
+                                                        )
+                                                    ]
+                                                )
+                                            ),
+                                            t.objectProperty(
+                                                t.identifier('funds'),
+                                                t.identifier('funds'),
+                                                false,
+                                                true
+                                            ),
+                                        ])
+                                    ]
+                                )
+                            )
+                        ])
+                    )
+                ]
+            ),
+            // return type
+            t.tsTypeAnnotation(
+                t.tsTypeReference(
+                    t.identifier('MsgExecuteContractEncodeObject')
+                )
+            ),
+            false
+        )
+    );
+
+}
+
+export const createMessageComposerClass = (
+    context: RenderContext,
+    className: string,
+    implementsClassName: string,
+    execMsg: ExecuteMsg
+) => {
+
+    const propertyNames = getMessageProperties(execMsg)
+        .map(method => Object.keys(method.properties)?.[0])
+        .filter(Boolean);
+
+    const bindings = propertyNames
+        .map(camel)
+        .map(bindMethod);
+
+    const methods = getMessageProperties(execMsg)
+        .map(schema => {
+            return createWasmExecMethodMessageComposer(context, schema)
+        });
+
+    const blockStmt = [];
+
+    [].push.apply(blockStmt, [
+        t.expressionStatement(
+            t.assignmentExpression(
+                '=',
+                t.memberExpression(
+                    t.thisExpression(),
+                    t.identifier('sender')
+                ),
+                t.identifier('sender')
+            )
+        ),
+        t.expressionStatement(
+            t.assignmentExpression(
+                '=',
+                t.memberExpression(
+                    t.thisExpression(),
+                    t.identifier('contractAddress')
+                ),
+                t.identifier('contractAddress')
+            )
+        ),
+        ...bindings
+    ]);
+
+    return t.exportNamedDeclaration(
+        classDeclaration(className,
+            [
+                // sender
+                classProperty('sender', t.tsTypeAnnotation(
+                    t.tsStringKeyword()
+                )),
+
+                // contractAddress
+                classProperty('contractAddress', t.tsTypeAnnotation(
+                    t.tsStringKeyword()
+                )),
+
+                // constructor
+                t.classMethod('constructor',
+                    t.identifier('constructor'),
+                    [
+                        typedIdentifier('sender', t.tsTypeAnnotation(t.tsStringKeyword())),
+                        typedIdentifier('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()))
+                    ],
+                    t.blockStatement(
+                        blockStmt
+                    )),
+                ...methods
+            ],
+            [
+                t.tSExpressionWithTypeArguments(
+                    t.identifier(implementsClassName)
+                )
+            ],
+            null
+        )
+    );
+}
+
+export const createMessageComposerInterface = (
+    context: RenderContext,
+    className: string,
+    execMsg: ExecuteMsg
+) => {
+
+    const methods = getMessageProperties(execMsg)
+        .map(jsonschema => {
+            const underscoreName = Object.keys(jsonschema.properties)[0];
+            const methodName = camel(underscoreName);
+            return createPropertyFunctionWithObjectParamsForMessageComposer(
+                context,
+                methodName,
+                'MsgExecuteContractEncodeObject',
+                jsonschema.properties[underscoreName]
+            );
+        });
+
+    const extendsAst = [];
+
+    return t.exportNamedDeclaration(
+        t.tsInterfaceDeclaration(
+            t.identifier(className),
+            null,
+            extendsAst,
+            t.tSInterfaceBody(
+                [
+
+                    // contract address
+                    t.tSPropertySignature(
+                        t.identifier('contractAddress'),
+                        t.tsTypeAnnotation(
+                            t.tsStringKeyword()
+                        )
+                    ),
+
+                    // contract address
+                    t.tSPropertySignature(
+                        t.identifier('sender'),
+                        t.tsTypeAnnotation(
+                            t.tsStringKeyword()
+                        )
+                    ),
+
+                    ...methods,
+                ]
+            )
+        )
+    );
+};
+
+const createPropertyFunctionWithObjectParamsForMessageComposer = (
+    context: RenderContext,
+    methodName: string,
+    responseType: string,
+    jsonschema: JSONSchema
+) => {
+    const obj = createTypedObjectParams(context, jsonschema);
+    const fixedParams = [
+        identifier('funds', t.tsTypeAnnotation(
+            t.tsArrayType(
+                t.tsTypeReference(
+                    t.identifier('Coin')
+                )
+            )
+        ), true)
+    ];
+    const func = {
+        type: 'TSFunctionType',
+        typeAnnotation: t.tsTypeAnnotation(t.tsTypeReference(
+            t.identifier(responseType)
+        )),
+        parameters: obj ? [
+            obj,
+            ...fixedParams
+
+        ] : fixedParams
+    }
+
+    return t.tSPropertySignature(
+        t.identifier(methodName),
+        t.tsTypeAnnotation(
+            // @ts-ignore:next-line
+            func
+        )
+    );
+};
+