@neo-one/smart-contract-compiler/dist/esm/compile/helper/contract/HandleSendHelper.js

NEO•ONE TypeScript smart contract compiler.

import { tsUtils } from '@neo-one/ts-utils';
import ts from 'typescript';
import { ContractPropertyName } from '../../../constants';
import { Types } from '../../constants';
import { Helper } from '../Helper';
import { createWrapParam } from './utils';
export class HandleSendHelper extends Helper {
    constructor({ method, returnType }) {
        super();
        this.method = method;
        this.returnType = returnType;
    }
    emit(sb, node, optionsIn) {
        const options = sb.pushValueOptions(optionsIn);
        const method = this.method;
        if (ts.isPropertyDeclaration(method)) {
            sb.context.reportUnsupported(method);
            return;
        }
        sb.emitSysCall(node, 'System.ExecutionEngine.GetScriptContainer');
        sb.emitSysCall(node, 'Neo.Transaction.GetHash');
        sb.emitHelper(node, options, sb.helpers.isProcessedTransaction);
        sb.emitSysCall(node, 'System.ExecutionEngine.GetScriptContainer');
        sb.emitSysCall(node, 'Neo.Transaction.GetOutputs');
        sb.emitOp(node, 'DUP');
        sb.emitOp(node, 'DUP');
        sb.emitHelper(node, options, sb.helpers.if({
            condition: () => {
                sb.emitOp(node, 'ARRAYSIZE');
                sb.emitPushInt(node, 0);
                sb.emitOp(node, 'LTE');
            },
            whenTrue: () => {
                sb.emitOp(node, 'DROP');
                sb.emitPushBoolean(node, true);
            },
            whenFalse: () => {
                sb.emitPushInt(node, 0);
                sb.emitOp(node, 'PICKITEM');
                sb.emitSysCall(node, 'Neo.Output.GetScriptHash');
                sb.emitSysCall(node, 'System.ExecutionEngine.GetExecutingScriptHash');
                sb.emitOp(node, 'EQUAL');
                sb.emitOp(node, 'NOT');
            },
        }));
        sb.emitOp(node, 'ROT');
        sb.emitOp(node, 'BOOLOR');
        sb.emitSysCall(node, 'System.ExecutionEngine.GetScriptContainer');
        sb.emitSysCall(node, 'Neo.Transaction.GetInputs');
        sb.emitHelper(node, options, sb.helpers.arrEvery({
            map: (innerOptions) => {
                sb.emitOp(node, 'DUP');
                sb.emitSysCall(node, 'Neo.Input.GetHash');
                sb.emitOp(node, 'DUP');
                sb.emitHelper(node, innerOptions, sb.helpers.isProcessedTransaction);
                sb.emitOp(node, 'SWAP');
                sb.emitHelper(node, innerOptions, sb.helpers.isClaimedTransaction);
                sb.emitOp(node, 'NOT');
                sb.emitOp(node, 'ROT');
                sb.emitSysCall(node, 'Neo.Input.GetIndex');
                sb.emitPushInt(node, 0);
                sb.emitOp(node, 'NUMEQUAL');
                sb.emitOp(node, 'NOT');
                sb.emitOp(node, 'BOOLOR');
                sb.emitOp(node, 'BOOLAND');
            },
        }));
        sb.emitOp(node, 'NOT');
        sb.emitOp(node, 'BOOLOR');
        sb.emitOp(node, 'OVER');
        sb.emitHelper(node, options, sb.helpers.getOutputAssetValueMap);
        sb.emitSysCall(node, 'System.ExecutionEngine.GetScriptContainer');
        sb.emitSysCall(node, 'Neo.Transaction.GetReferences');
        sb.emitHelper(node, options, sb.helpers.mergeAssetValueMaps({ add: false }));
        sb.emitHelper(node, optionsIn, sb.helpers.mapEvery({
            each: () => {
                sb.emitOp(node, 'DROP');
                sb.emitPushInt(node, 0);
                sb.emitOp(node, 'NUMEQUAL');
            },
        }));
        sb.emitOp(node, 'NOT');
        sb.emitHelper(node, options, sb.helpers.if({
            condition: () => {
                sb.emitOp(node, 'BOOLOR');
            },
            whenTrue: () => {
                sb.emitOp(node, 'DROP');
                sb.emitPushBoolean(node, false);
            },
            whenFalse: () => {
                sb.emitPushInt(node, 0);
                sb.emitOp(node, 'PICKITEM');
                sb.emitPushInt(node, 1);
                sb.emitHelper(node, options, sb.helpers.getArgument);
                sb.emitOp(node, 'OVER');
                sb.emitOp(node, 'OVER');
                sb.emitOp(node, 'DUP');
                sb.emitHelper(node, options, sb.helpers.if({
                    condition: () => {
                        sb.emitOp(node, 'ARRAYSIZE');
                        sb.emitOp(node, 'DUP');
                        sb.emitPushInt(node, 0);
                        sb.emitOp(node, 'NUMEQUAL');
                    },
                    whenTrue: () => {
                        sb.emitOp(node, 'DROP');
                        sb.emitOp(node, 'DROP');
                        sb.emitOp(node, 'DROP');
                        sb.emitOp(node, 'DROP');
                        sb.emitOp(node, 'DROP');
                        sb.emitPushBoolean(node, false);
                    },
                    whenFalse: () => {
                        sb.emitOp(node, 'DEC');
                        sb.emitOp(node, 'OVER');
                        sb.emitOp(node, 'OVER');
                        sb.emitOp(node, 'PICKITEM');
                        sb.emitOp(node, 'ROT');
                        sb.emitOp(node, 'ROT');
                        sb.emitOp(node, 'REMOVE');
                        sb.emitOp(node, 'NEWMAP');
                        sb.emitOp(node, 'TUCK');
                        sb.emitOp(node, 'OVER');
                        sb.emitPushString(node, 'to');
                        sb.emitOp(node, 'SWAP');
                        sb.emitOp(node, 'SETITEM');
                        sb.emitOp(node, 'ROT');
                        sb.emitOp(node, 'ROT');
                        sb.emitOp(node, 'TUCK');
                        sb.emitPushString(node, 'asset');
                        sb.emitOp(node, 'ROT');
                        sb.emitSysCall(node, 'Neo.Output.GetAssetId');
                        sb.emitOp(node, 'SETITEM');
                        sb.emitOp(node, 'ROT');
                        sb.emitOp(node, 'TUCK');
                        sb.emitOp(node, 'OVER');
                        sb.emitOp(node, 'APPEND');
                        sb.emitPushString(node, 'amount');
                        sb.emitPushInt(node, 4);
                        sb.emitOp(node, 'ROLL');
                        sb.emitSysCall(node, 'Neo.Output.GetValue');
                        sb.emitOp(node, 'SETITEM');
                        sb.withScope(node, options, (innerOptions) => {
                            sb.emitHelper(node, innerOptions, sb.helpers.parameters({
                                params: tsUtils.parametered.getParameters(method),
                                mapParam: createWrapParam(sb),
                            }));
                            sb.emitHelper(node, innerOptions, sb.helpers.invokeSmartContractMethod({ method }));
                            sb.emitHelper(node, innerOptions, sb.helpers.unwrapValRecursive({ type: this.returnType }));
                            sb.emitOp(node, 'SWAP');
                            sb.emitSysCall(node, 'System.ExecutionEngine.GetScriptContainer');
                            sb.emitSysCall(node, 'Neo.Transaction.GetHash');
                            sb.emitHelper(node, innerOptions, sb.helpers.wrapBuffer);
                            sb.emitOp(node, 'SWAP');
                            sb.emitHelper(node, innerOptions, sb.helpers.createStructuredStorage({
                                prefix: ContractPropertyName.claimedTransactions,
                                type: Types.MapStorage,
                            }));
                            sb.emitOp(node, 'ROT');
                            sb.emitOp(node, 'ROT');
                            sb.emitHelper(node, innerOptions, sb.helpers.wrapBuffer);
                            sb.emitHelper(node, options, sb.helpers.setStructuredStorage({
                                type: Types.MapStorage,
                                keyType: undefined,
                                knownKeyType: Types.Buffer,
                            }));
                            sb.emitHelper(node, innerOptions, sb.helpers.setProcessedTransaction);
                        });
                    },
                }));
            },
        }));
    }
}

//# sourceMappingURL=HandleSendHelper.js.map