@cosmology/ast/module/encoding/amino/from-amino-json/index.js

Cosmos TypeScript AST generation

import * as t from '@babel/types';
import { arrowFunctionExpression } from '../../../utils';
import { protoFieldsToArray } from '../utils';
import { arrayTypes, fromAmino } from './utils';
import { getFieldOptionality, getOneOfs } from '../../proto';
const needsImplementation = (name, field) => {
    throw new Error(`need to implement fromAmino (${field.type} rules[${field.rule}] name[${name}])`);
};
export const fromAminoParseField = ({ context, field, currentProtoPath, scope: previousScope, fieldPath: previousFieldPath, nested, isOptional }) => {
    const scope = [field.name, ...previousScope];
    const fieldPath = [field, ...previousFieldPath];
    const args = {
        context,
        field,
        currentProtoPath,
        scope,
        fieldPath,
        nested,
        isOptional
    };
    // arrays
    if (field.rule === 'repeated') {
        switch (field.type) {
            case 'string':
                return fromAmino.string(args);
            case 'int64':
            case 'sint64':
            case 'uint64':
            case 'fixed64':
            case 'sfixed64':
                return fromAmino.scalarArray(args, arrayTypes.long);
            case 'double':
            case 'float':
            case 'int32':
            case 'sint32':
            case 'uint32':
            case 'fixed32':
            case 'sfixed32':
            case 'bool':
            case 'bytes':
                return fromAmino.defaultType(args);
        }
        switch (field.parsedType.type) {
            case 'Type':
                return fromAmino.typeArray(args);
            case 'Enum':
                return fromAmino.enumArray(args);
            case 'cosmos.base.v1beta1.Coin':
                return fromAmino.arrayFrom(args);
        }
        return needsImplementation(field.name, field);
    }
    // casting special types
    if (field.type === 'google.protobuf.Any') {
        switch (field.options?.['(cosmos_proto.accepts_interface)']) {
            case 'cosmos.crypto.PubKey':
                return fromAmino.pubkey(args);
        }
    }
    // special types...
    switch (field.type) {
        case 'Timestamp':
        case 'google.protobuf.Timestamp':
            return fromAmino.defaultType(args);
        // TODO check can we just
        // make pieces optional and avoid hard-coding this type?
        case 'ibc.core.client.v1.Height':
        case 'Height':
            return fromAmino.height(args);
        case 'Duration':
        case 'google.protobuf.Duration':
            return fromAmino.duration(args);
        default:
    }
    // Types/Enums
    switch (field.parsedType.type) {
        case 'Type':
            return fromAmino.type(args);
        case 'Enum':
            return fromAmino.enum(args);
    }
    if (field.type === 'bytes') {
        // bytes [RawContractMessage]
        if (field.options?.['(gogoproto.casttype)'] === 'RawContractMessage') {
            return fromAmino.rawBytes(args);
        }
        // bytes [WASMByteCode]
        // TODO use a better option for this in proto source
        if (field.options?.['(gogoproto.customname)'] === 'WASMByteCode') {
            return fromAmino.wasmByteCode(args);
        }
    }
    // scalar types...
    switch (field.type) {
        case 'string':
            return fromAmino.string(args);
        case 'int64':
        case 'sint64':
        case 'uint64':
        case 'fixed64':
        case 'sfixed64':
            return fromAmino.long(args);
        case 'double':
        case 'float':
        case 'int32':
        case 'sint32':
        case 'uint32':
        case 'fixed32':
        case 'sfixed32':
        case 'bool':
            return fromAmino.defaultType(args);
        case 'bytes':
            return fromAmino.defaultType(args);
        default:
            return fromAmino.defaultType(args);
    }
};
export const fromAminoJsonMethod = ({ context, proto }) => {
    const fromAminoParams = t.objectPattern(Object.keys(proto.fields).map((field) => t.objectProperty(t.identifier(context.aminoCaseField(proto.fields[field])), t.identifier(context.aminoCaseField(proto.fields[field])), false, true)));
    fromAminoParams.typeAnnotation = t.tsTypeAnnotation(t.tsIndexedAccessType(t.tsTypeReference(t.identifier(proto.name + 'AminoType')), t.tsLiteralType(t.stringLiteral('value'))));
    const oneOfs = getOneOfs(proto);
    const fields = protoFieldsToArray(proto).map((field) => {
        const isOneOf = oneOfs.includes(field.name);
        const isOptional = getFieldOptionality(context, field, isOneOf);
        const aminoField = fromAminoParseField({
            context,
            field,
            currentProtoPath: context.ref.filename,
            scope: [],
            fieldPath: [],
            nested: 0,
            isOptional
        });
        return {
            ctx: context,
            field: aminoField
        };
    });
    const ctxs = fields.map(({ ctx }) => ctx);
    ctxs.forEach(ctx => {
        // console.log('imports, ', ctx.imports)
    });
    return arrowFunctionExpression([
        fromAminoParams
    ], t.blockStatement([
        t.returnStatement(t.objectExpression(fields.map(({ field }) => field)))
    ]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(proto.name))));
};