wasm-ast-types 0.26.4 → 1.1.0

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

@@ -1,331 +0,0 @@
-// 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: _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: _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: _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: _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: _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: _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: _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: _funds
-      })
-    };
-  };
-}"
-`;
-
-exports[`ownershipClass 1`] = `
-"export class OwnershipMessageComposer implements OwnershipMessage {
-  sender: string;
-  contractAddress: string;
-
-  constructor(sender: string, contractAddress: string) {
-    this.sender = sender;
-    this.contractAddress = contractAddress;
-    this.setFactory = this.setFactory.bind(this);
-    this.updateOwnership = this.updateOwnership.bind(this);
-  }
-
-  setFactory = ({
-    newFactory
-  }: {
-    newFactory: string;
-  }, _funds?: Coin[]): MsgExecuteContractEncodeObject => {
-    return {
-      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
-      value: MsgExecuteContract.fromPartial({
-        sender: this.sender,
-        contract: this.contractAddress,
-        msg: toUtf8(JSON.stringify({
-          set_factory: {
-            new_factory: newFactory
-          }
-        })),
-        funds: _funds
-      })
-    };
-  };
-  updateOwnership = (action: Action, _funds?: Coin[]): MsgExecuteContractEncodeObject => {
-    return {
-      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
-      value: MsgExecuteContract.fromPartial({
-        sender: this.sender,
-        contract: this.contractAddress,
-        msg: toUtf8(JSON.stringify({
-          update_ownership: action
-        })),
-        funds: _funds
-      })
-    };
-  };
-}"
-`;
-
-exports[`ownershipInterface 1`] = `
-"export interface OwnershipMessage {
-  contractAddress: string;
-  sender: string;
-  setFactory: ({
-    newFactory
-  }: {
-    newFactory: string;
-  }, _funds?: Coin[]) => MsgExecuteContractEncodeObject;
-  updateOwnership: (action: Action, _funds?: Coin[]) => MsgExecuteContractEncodeObject;
-}"
-`;

package/src/message-composer/index.ts

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

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

@@ -1,46 +0,0 @@
-import execute_msg from "../../../../__fixtures__/basic/execute_msg_for__empty.json";
-import ownership from "../../../../__fixtures__/basic/ownership.json";
-
-import {
-  createMessageComposerClass,
-  createMessageComposerInterface,
-} from "./message-composer";
-import { expectCode, makeContext } from "../../test-utils";
-import * as t from "@babel/types";
-import { createReactQueryMutationHooks } from "../react-query";
-
-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));
-});
-
-it("ownershipClass", () => {
-  const ctx = makeContext(ownership);
-  expectCode(
-    createMessageComposerClass(
-      ctx,
-      "OwnershipMessageComposer",
-      "OwnershipMessage",
-      ownership
-    )
-  );
-});
-
-it("ownershipInterface", () => {
-  const ownershipCtx = makeContext(ownership);
-  expectCode(
-    createMessageComposerInterface(ownershipCtx, "OwnershipMessage", ownership)
-  );
-});

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

@@ -1,262 +0,0 @@
-import * as t from '@babel/types';
-import { Expression } from '@babel/types';
-import { camel } from 'case';
-import {
-  arrowFunctionExpression,
-  bindMethod,
-  classDeclaration,
-  classProperty,
-  getMessageProperties,
-  OPTIONAL_FUNDS_PARAM,
-  typedIdentifier
-} from '../utils';
-import { ExecuteMsg, JSONSchema } from '../types';
-import { createTypedObjectParams } from '../utils/types';
-import { RenderContext } from '../context';
-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 param = createTypedObjectParams(
-    context,
-    jsonschema.properties[underscoreName]
-  );
-  const args = getWasmMethodArgs(
-    context,
-    jsonschema.properties[underscoreName]
-  );
-
-  // what the underscore named property in the message is assigned to
-  let actionValue: Expression;
-  if (param?.type === 'Identifier') {
-    actionValue = t.identifier(param.name);
-  } else {
-    actionValue = t.objectExpression(args);
-  }
-
-  const constantParams = [OPTIONAL_FUNDS_PARAM];
-
-  return t.classProperty(
-    t.identifier(methodName),
-    arrowFunctionExpression(
-      param
-        ? [
-            // props
-            param,
-            ...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),
-                                actionValue
-                              )
-                            ])
-                          ]
-                        )
-                      ])
-                    ),
-                    t.objectProperty(
-                      t.identifier('funds'),
-                      t.identifier('_funds')
-                    )
-                  ])
-                ]
-              )
-            )
-          ])
-        )
-      ]),
-      // 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 = [OPTIONAL_FUNDS_PARAM];
-  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
-    )
-  );
-};

package/src/provider/__snapshots__/provider.spec.ts.snap

@@ -1,49 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`create IContractsContext 1`] = `
-"export interface IContractsContext {
-  whitelist: ISigningClientProvider<WhitelistClient> & IQueryClientProvider<WhitelistQueryClient>;
-  marketplace: ISigningClientProvider<MarketplaceClient>;
-}"
-`;
-
-exports[`create getProviders 1`] = `
-"export const getProviders = (address?: string, cosmWasmClient?: CosmWasmClient, signingCosmWasmClient?: SigningCosmWasmClient) => ({
-  whitelist: new Whitelist({
-    address,
-    cosmWasmClient,
-    signingCosmWasmClient
-  }),
-  marketplace: new Marketplace({
-    address,
-    cosmWasmClient,
-    signingCosmWasmClient
-  })
-});"
-`;
-
-exports[`execute class 1`] = `
-"export class Whitelist extends ContractBase<WhitelistClient, WhitelistQueryClient, WhitelistMessageComposer> {
-  constructor({
-    address,
-    cosmWasmClient,
-    signingCosmWasmClient
-  }: IContractConstructor) {
-    super(address, cosmWasmClient, signingCosmWasmClient, WhitelistClient, WhitelistQueryClient, WhitelistMessageComposer);
-  }
-
-}"
-`;
-
-exports[`execute class without message composer 1`] = `
-"export class Whitelist extends ContractBase<WhitelistClient, WhitelistQueryClient, IEmptyClient> {
-  constructor({
-    address,
-    cosmWasmClient,
-    signingCosmWasmClient
-  }: IContractConstructor) {
-    super(address, cosmWasmClient, signingCosmWasmClient, WhitelistClient, WhitelistQueryClient, undefined);
-  }
-
-}"
-`;

package/src/provider/index.ts

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