Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Sweep: Support glob pattern to filer txs by action's type_id in query.transaction.ncTransactions query #87

Closed
1 task done
moreal opened this issue Sep 3, 2023 · 1 comment · May be fixed by #89
Closed
1 task done

Sweep: Support glob pattern to filer txs by action's type_id in query.transaction.ncTransactions query #87

moreal opened this issue Sep 3, 2023 · 1 comment · May be fixed by #89
Labels
sweep Sweep your software chores

Comments

@moreal
Copy link
Owner

moreal commented Sep 3, 2023 •
edited by sweep-ai bot
Loading

There is query.transaction.ncTransactions query in NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs file.

And users can use like the below example:

query {
	transaction {
		ncTransactions(actionType: "transfer_asset4") {
			id
			signer
		}
	}
}

The action type is usually formatted as <action_type: snake case string><action_version: number> and it is changed when the protocol version is upgraded. So users must update the actionType manually when every protocol upgrade. To help this problem, this issue wants to add an argument like actionTypeGlobPattern to filter action types with glob expression like transfer_asset*.

See also

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs

Lines 70 to 107 in f3f91fd

Field<ListGraphType<TransactionType>>(
name: "ncTransactions",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<LongGraphType>>
{ Name = "startingBlockIndex", Description = "start block index for query tx." },
new QueryArgument<NonNullGraphType<LongGraphType>>
{ Name = "limit", Description = "number of block to query." },
new QueryArgument<NonNullGraphType<StringGraphType>>
{ Name = "actionType", Description = "filter tx by having actions' type" }
),
resolve: context =>
{
if (standaloneContext.BlockChain is not { } blockChain)
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
var startingBlockIndex = context.GetArgument<long>("startingBlockIndex");
var limit = context.GetArgument<long>("limit");
var actionType = context.GetArgument<string>("actionType");
var blocks = ListBlocks(blockChain, startingBlockIndex, limit);
var transactions = blocks
.SelectMany(block => block.Transactions)
.Where(tx => tx.Actions.Any(rawAction =>
{
if (rawAction is not Dictionary action || action["type_id"] is not Text typeId)
{
return false;
}
return typeId == actionType;
}));
return transactions;
}
);

Checklist
  • NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs

• Add a new argument to the ncTransactions query named actionTypeGlobPattern. This argument should be of type StringGraphType and its description should explain that it is used to filter transactions based on a glob pattern.
• Update the resolve function of the ncTransactions query to use the actionTypeGlobPattern argument. Specifically, modify the part of the function where the actionType argument is used to filter transactions. Instead of using an exact match, use the actionTypeGlobPattern argument to filter transactions based on a glob pattern.
• Ensure that the ListBlocks method still works as expected after these changes. If necessary, update this method to support glob patterns.
@sweep-ai sweep-ai bot added the sweep Sweep your software chores label Sep 3, 2023
@sweep-ai
Copy link

sweep-ai bot commented Sep 3, 2023 •
edited
Loading

Here's the PR! #89.

⚡ Sweep Free Trial: I used GPT-4 to create this ticket. You have 3 GPT-4 tickets left for the month and 0 for the day. For more GPT-4 tickets, visit our payment portal. To retrigger Sweep, edit the issue.

Step 1: 🔍 Code Search

I found the following snippets in your repository. I will now analyze these snippets and come up with a plan.

Some code snippets I looked at (click to expand). If some file is missing from here, you can mention the path in the ticket description.

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs

Lines 1 to 350 in f3f91fd

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using Bencodex;
using Bencodex.Json;
using GraphQL;
using GraphQL.Types;
using Bencodex.Types;
using GraphQL.NewtonsoftJson;
using Lib9c;
using Libplanet.Blockchain;
using Libplanet.Types.Tx;
using Libplanet.Common;
using Libplanet.Types.Assets;
using Libplanet.Explorer.GraphTypes;
using Libplanet.Types.Blocks;
using Libplanet.Crypto;
using Libplanet.Store;
using Nekoyume.Action;
namespace NineChronicles.Headless.GraphTypes
{
class TransactionHeadlessQuery : ObjectGraphType
{
public TransactionHeadlessQuery(StandaloneContext standaloneContext)
{
Field<NonNullGraphType<LongGraphType>>(
name: "nextTxNonce",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<AddressType>> { Name = "address", Description = "Target address to query" }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
Address address = context.GetArgument<Address>("address");
return blockChain.GetNextTxNonce(address);
}
);
Field<TransactionType>(
name: "getTx",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<TxIdType>>
{ Name = "txId", Description = "transaction id." }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
var txId = context.GetArgument<TxId>("txId");
return blockChain.GetTransaction(txId);
}
);
Field<ListGraphType<TransactionType>>(
name: "ncTransactions",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<LongGraphType>>
{ Name = "startingBlockIndex", Description = "start block index for query tx." },
new QueryArgument<NonNullGraphType<LongGraphType>>
{ Name = "limit", Description = "number of block to query." },
new QueryArgument<NonNullGraphType<StringGraphType>>
{ Name = "actionType", Description = "filter tx by having actions' type" }
),
resolve: context =>
{
if (standaloneContext.BlockChain is not { } blockChain)
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
var startingBlockIndex = context.GetArgument<long>("startingBlockIndex");
var limit = context.GetArgument<long>("limit");
var actionType = context.GetArgument<string>("actionType");
var blocks = ListBlocks(blockChain, startingBlockIndex, limit);
var transactions = blocks
.SelectMany(block => block.Transactions)
.Where(tx => tx.Actions.Any(rawAction =>
{
if (rawAction is not Dictionary action || action["type_id"] is not Text typeId)
{
return false;
}
return typeId == actionType;
}));
return transactions;
}
);
Field<NonNullGraphType<StringGraphType>>(
name: "createUnsignedTx",
deprecationReason: "API update with action query. use unsignedTransaction",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "publicKey",
Description = "The base64-encoded public key for Transaction.",
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "plainValue",
Description = "The base64-encoded plain value of action for Transaction.",
},
new QueryArgument<LongGraphType>
{
Name = "nonce",
Description = "The nonce for Transaction.",
}
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
string plainValueString = context.GetArgument<string>("plainValue");
var plainValue = new Bencodex.Codec().Decode(System.Convert.FromBase64String(plainValueString));
var action = NCActionUtils.ToAction(plainValue);
var publicKey = new PublicKey(Convert.FromBase64String(context.GetArgument<string>("publicKey")));
Address signer = publicKey.ToAddress();
long nonce = context.GetArgument<long?>("nonce") ?? blockChain.GetNextTxNonce(signer);
UnsignedTx unsignedTransaction =
new UnsignedTx(
new TxInvoice(
genesisHash: blockChain.Genesis.Hash,
actions: new TxActionList(new[] { action.PlainValue }),
gasLimit: action is ITransferAsset or ITransferAssets ? RequestPledge.DefaultRefillMead : 1L,
maxGasPrice: 1 * Currencies.Mead
),
new TxSigningMetadata(publicKey: publicKey, nonce: nonce)
);
return Convert.ToBase64String(unsignedTransaction.SerializeUnsignedTx().ToArray());
});
Field<NonNullGraphType<StringGraphType>>(
name: "attachSignature",
deprecationReason: "Use signTransaction",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "unsignedTransaction",
Description = "The base64-encoded unsigned transaction to attach the given signature."
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "signature",
Description = "The base64-encoded signature of the given unsigned transaction."
}
),
resolve: context =>
{
byte[] signature = Convert.FromBase64String(context.GetArgument<string>("signature"));
IUnsignedTx unsignedTransaction =
TxMarshaler.DeserializeUnsignedTx(
Convert.FromBase64String(context.GetArgument<string>("unsignedTransaction")));
Transaction signedTransaction = new Transaction(
unsignedTransaction,
signature.ToImmutableArray());
return Convert.ToBase64String(signedTransaction.Serialize());
});
Field<NonNullGraphType<TxResultType>>(
name: "transactionResult",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<TxIdType>>
{ Name = "txId", Description = "transaction id." }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
if (!(standaloneContext.Store is IStore store))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.Store)} was not set yet!");
}
TxId txId = context.GetArgument<TxId>("txId");
if (!(store.GetFirstTxIdBlockHashIndex(txId) is { } txExecutedBlockHash))
{
return blockChain.GetStagedTransactionIds().Contains(txId)
? new TxResult(TxStatus.STAGING, null, null, null, null, null, null, null)
: new TxResult(TxStatus.INVALID, null, null, null, null, null, null, null);
}
try
{
TxExecution execution = blockChain.GetTxExecution(txExecutedBlockHash, txId);
Block txExecutedBlock = blockChain[txExecutedBlockHash];
return execution switch
{
TxSuccess txSuccess => new TxResult(
TxStatus.SUCCESS,
txExecutedBlock.Index,
txExecutedBlock.Hash.ToString(),
null,
null,
txSuccess.UpdatedStates
.Select(kv => new KeyValuePair<Address, IValue>(
kv.Key,
kv.Value))
.ToImmutableDictionary(),
txSuccess.FungibleAssetsDelta,
txSuccess.UpdatedFungibleAssets),
TxFailure txFailure => new TxResult(
TxStatus.FAILURE,
txExecutedBlock.Index,
txExecutedBlock.Hash.ToString(),
txFailure.ExceptionName,
txFailure.ExceptionMetadata,
null,
null,
null),
_ => throw new NotImplementedException(
$"{nameof(execution)} is not expected concrete class.")
};
}
catch (Exception)
{
return new TxResult(TxStatus.INVALID, null, null, null, null, null, null, null);
}
}
);
Field<NonNullGraphType<ByteStringType>>(
name: "unsignedTransaction",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "publicKey",
Description = "The hexadecimal string of public key for Transaction.",
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "plainValue",
Description = "The hexadecimal string of plain value for Action.",
},
new QueryArgument<LongGraphType>
{
Name = "nonce",
Description = "The nonce for Transaction.",
},
new QueryArgument<FungibleAssetValueInputType>
{
Name = "maxGasPrice",
DefaultValue = 1 * Currencies.Mead
}
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
string plainValueString = context.GetArgument<string>("plainValue");
var plainValue = new Bencodex.Codec().Decode(ByteUtil.ParseHex(plainValueString));
var action = NCActionUtils.ToAction(plainValue);
var publicKey = new PublicKey(ByteUtil.ParseHex(context.GetArgument<string>("publicKey")));
Address signer = publicKey.ToAddress();
long nonce = context.GetArgument<long?>("nonce") ?? blockChain.GetNextTxNonce(signer);
long? gasLimit = action is ITransferAsset or ITransferAssets ? RequestPledge.DefaultRefillMead : 1L;
FungibleAssetValue? maxGasPrice = context.GetArgument<FungibleAssetValue?>("maxGasPrice");
UnsignedTx unsignedTransaction =
new UnsignedTx(
new TxInvoice(
genesisHash: blockChain.Genesis.Hash,
actions: new TxActionList(new[] { action.PlainValue }),
gasLimit: gasLimit,
maxGasPrice: maxGasPrice),
new TxSigningMetadata(publicKey, nonce));
return unsignedTransaction.SerializeUnsignedTx().ToArray();
});
Field<NonNullGraphType<ByteStringType>>(
name: "signTransaction",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "unsignedTransaction",
Description = "The hexadecimal string of unsigned transaction to attach the given signature."
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "signature",
Description = "The hexadecimal string of signature of the given unsigned transaction."
}
),
resolve: context =>
{
byte[] signature = ByteUtil.ParseHex(context.GetArgument<string>("signature"));
IUnsignedTx unsignedTransaction =
TxMarshaler.DeserializeUnsignedTx(
ByteUtil.ParseHex(context.GetArgument<string>("unsignedTransaction")));
Transaction signedTransaction =
new Transaction(unsignedTransaction, signature.ToImmutableArray());
return signedTransaction.Serialize();
}
);
}
private IEnumerable<Block> ListBlocks(BlockChain chain, long from, long limit)
{
if (chain.Tip.Index < from)
{
return new List<Block>();
}
var count = (int)Math.Min(limit, chain.Tip.Index - from);
var blocks = Enumerable.Range(0, count)
.ToList()
.AsParallel()
.Select(offset => chain[from + offset])
.OrderBy(block => block.Index);
return blocks;
}
}

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/StandaloneQuery.cs

Lines 128 to 293 in f3f91fd

TransferNCGHistory ToTransferNCGHistory(TxSuccess txSuccess, string? memo)
{
var rawTransferNcgHistories = txSuccess.FungibleAssetsDelta
.Where(pair => pair.Value.Values.Any(fav => fav.Currency.Ticker == "NCG"))
.Select(pair =>
(pair.Key, pair.Value.Values.First(fav => fav.Currency.Ticker == "NCG")))
.ToArray();
var ((senderAddress, _), (recipientAddress, amount)) =
rawTransferNcgHistories[0].Item2.RawValue > rawTransferNcgHistories[1].Item2.RawValue
? (rawTransferNcgHistories[1], rawTransferNcgHistories[0])
: (rawTransferNcgHistories[0], rawTransferNcgHistories[1]);
return new TransferNCGHistory(
txSuccess.BlockHash,
txSuccess.TxId,
senderAddress,
recipientAddress,
amount,
memo);
}
var histories = filteredTransactions.Select(tx =>
ToTransferNCGHistory((TxSuccess)store.GetTxExecution(blockHash, tx.Id),
((ITransferAsset)ToAction(tx.Actions!.Single())).Memo));
return histories;
});
Field<KeyStoreType>(
name: "keyStore",
deprecationReason: "Use `planet key` command instead. https://www.npmjs.com/package/@planetarium/cli",
resolve: context => standaloneContext.KeyStore
).AuthorizeWithLocalPolicyIf(useSecretToken);
Field<NonNullGraphType<NodeStatusType>>(
name: "nodeStatus",
resolve: _ => new NodeStatusType(standaloneContext)
);
Field<NonNullGraphType<Libplanet.Explorer.Queries.ExplorerQuery>>(
name: "chainQuery",
deprecationReason: "Use /graphql/explorer",
resolve: context => new { }
);
Field<NonNullGraphType<ValidationQuery>>(
name: "validation",
description: "The validation method provider for Libplanet types.",
resolve: context => new ValidationQuery(standaloneContext));
Field<NonNullGraphType<ActivationStatusQuery>>(
name: "activationStatus",
description: "Check if the provided address is activated.",
deprecationReason: "Since NCIP-15, it doesn't care account activation.",
resolve: context => new ActivationStatusQuery(standaloneContext))
.AuthorizeWithLocalPolicyIf(useSecretToken);
Field<NonNullGraphType<PeerChainStateQuery>>(
name: "peerChainState",
description: "Get the peer's block chain state",
resolve: context => new PeerChainStateQuery(standaloneContext));
Field<NonNullGraphType<StringGraphType>>(
name: "goldBalance",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<AddressType>> { Name = "address", Description = "Target address to query" },
new QueryArgument<ByteStringType> { Name = "hash", Description = "Offset block hash for query." }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
Address address = context.GetArgument<Address>("address");
byte[] blockHashByteArray = context.GetArgument<byte[]>("hash");
var blockHash = blockHashByteArray is null
? blockChain.Tip.Hash
: new BlockHash(blockHashByteArray);
Currency currency = new GoldCurrencyState(
(Dictionary)blockChain.GetState(GoldCurrencyState.Address)
).Currency;
return blockChain.GetBalance(
address,
currency,
blockHash
).GetQuantityString();
}
);
Field<NonNullGraphType<LongGraphType>>(
name: "nextTxNonce",
deprecationReason: "The root query is not the best place for nextTxNonce so it was moved. " +
"Use transaction.nextTxNonce()",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<AddressType>> { Name = "address", Description = "Target address to query" }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
Address address = context.GetArgument<Address>("address");
return blockChain.GetNextTxNonce(address);
}
);
Field<TransactionType>(
name: "getTx",
deprecationReason: "The root query is not the best place for getTx so it was moved. " +
"Use transaction.getTx()",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<TxIdType>>
{ Name = "txId", Description = "transaction id." }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
var txId = context.GetArgument<TxId>("txId");
return blockChain.GetTransaction(txId);
}
);
Field<AddressType>(
name: "minerAddress",
description: "Address of current node.",
resolve: context =>
{
if (standaloneContext.NineChroniclesNodeService?.MinerPrivateKey is null)
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.NineChroniclesNodeService)}.{nameof(StandaloneContext.NineChroniclesNodeService.MinerPrivateKey)} is null.");
}
return standaloneContext.NineChroniclesNodeService.MinerPrivateKey.ToAddress();
});
Field<MonsterCollectionStatusType>(
name: nameof(MonsterCollectionStatus),
arguments: new QueryArguments(
new QueryArgument<AddressType>
{
Name = "address",
Description = "agent address.",
DefaultValue = null
}
),
description: "Get monster collection status by address.",
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/StandaloneQuery.cs

Lines 391 to 472 in f3f91fd

Field<NonNullGraphType<StringGraphType>>(
name: "activationKeyNonce",
deprecationReason: "Since NCIP-15, it doesn't care account activation.",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "invitationCode"
}
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is { } blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
ActivationKey activationKey;
try
{
string invitationCode = context.GetArgument<string>("invitationCode");
invitationCode = invitationCode.TrimEnd();
activationKey = ActivationKey.Decode(invitationCode);
}
catch (Exception)
{
throw new ExecutionError("invitationCode format is invalid.");
}
if (blockChain.GetState(activationKey.PendingAddress) is Dictionary dictionary)
{
var pending = new PendingActivationState(dictionary);
return ByteUtil.Hex(pending.Nonce);
}
throw new ExecutionError("invitationCode is invalid.");
}
);
Field<NonNullGraphType<RpcInformationQuery>>(
name: "rpcInformation",
description: "Query for rpc mode information.",
resolve: context => new RpcInformationQuery(publisher)
);
Field<NonNullGraphType<ActionQuery>>(
name: "actionQuery",
description: "Query to create action transaction.",
resolve: context => new ActionQuery(standaloneContext));
Field<NonNullGraphType<ActionTxQuery>>(
name: "actionTxQuery",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "publicKey",
Description = "The hexadecimal string of public key for Transaction.",
},
new QueryArgument<LongGraphType>
{
Name = "nonce",
Description = "The nonce for Transaction.",
},
new QueryArgument<DateTimeOffsetGraphType>
{
Name = "timestamp",
Description = "The time this transaction is created.",
},
new QueryArgument<FungibleAssetValueInputType>
{
Name = "maxGasPrice",
DefaultValue = 1 * Currencies.Mead
}
),
resolve: context => new ActionTxQuery(standaloneContext));
Field<NonNullGraphType<AddressQuery>>(
name: "addressQuery",
description: "Query to get derived address.",
resolve: context => new AddressQuery(standaloneContext));
}
}

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/StandaloneQuery.cs

Lines 1 to 191 in f3f91fd

#nullable enable
using System;
using System.Collections.Generic;
using System.Linq;
using Bencodex;
using Bencodex.Types;
using GraphQL;
using GraphQL.Types;
using Lib9c;
using Libplanet.Blockchain;
using Libplanet.Common;
using Libplanet.Crypto;
using Libplanet.Explorer.GraphTypes;
using Libplanet.Types.Assets;
using Libplanet.Types.Blocks;
using Libplanet.Types.Tx;
using Microsoft.Extensions.Configuration;
using Nekoyume;
using Nekoyume.Action;
using Nekoyume.Model.State;
using Nekoyume.TableData;
using Nekoyume.Model;
using NineChronicles.Headless.GraphTypes.States;
using static NineChronicles.Headless.NCActionUtils;
using Transaction = Libplanet.Types.Tx.Transaction;
namespace NineChronicles.Headless.GraphTypes
{
public class StandaloneQuery : ObjectGraphType
{
public StandaloneQuery(StandaloneContext standaloneContext, IConfiguration configuration, ActionEvaluationPublisher publisher)
{
bool useSecretToken = configuration[GraphQLService.SecretTokenKey] is { };
Field<NonNullGraphType<StateQuery>>(name: "stateQuery", arguments: new QueryArguments(
new QueryArgument<ByteStringType>
{
Name = "hash",
Description = "Offset block hash for query.",
}),
resolve: context =>
{
BlockHash? blockHash = context.GetArgument<byte[]>("hash") switch
{
byte[] bytes => new BlockHash(bytes),
null => standaloneContext.BlockChain?.Tip?.Hash,
};
if (!(standaloneContext.BlockChain is { } chain))
{
return null;
}
return new StateContext(
chain.GetBlockState(blockHash),
blockHash switch
{
BlockHash bh => chain[bh].Index,
null => chain.Tip!.Index,
}
);
}
);
Field<ByteStringType>(
name: "state",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<AddressType>> { Name = "address", Description = "The address of state to fetch from the chain." },
new QueryArgument<ByteStringType> { Name = "hash", Description = "The hash of the block used to fetch state from chain." }
),
resolve: context =>
{
if (!(standaloneContext.BlockChain is BlockChain blockChain))
{
throw new ExecutionError(
$"{nameof(StandaloneContext)}.{nameof(StandaloneContext.BlockChain)} was not set yet!");
}
var address = context.GetArgument<Address>("address");
var blockHashByteArray = context.GetArgument<byte[]>("hash");
var blockHash = blockHashByteArray is null
? blockChain.Tip.Hash
: new BlockHash(blockHashByteArray);
var state = blockChain.GetStates(new[] { address }, blockHash)[0];
return new Codec().Encode(state);
}
);
Field<NonNullGraphType<ListGraphType<NonNullGraphType<TransferNCGHistoryType>>>>(
"transferNCGHistories",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<ByteStringType>>
{
Name = "blockHash"
},
new QueryArgument<AddressType>
{
Name = "recipient"
}
), resolve: context =>
{
BlockHash blockHash = new BlockHash(context.GetArgument<byte[]>("blockHash"));
if (!(standaloneContext.Store is { } store))
{
throw new InvalidOperationException();
}
if (!(store.GetBlockDigest(blockHash) is { } digest))
{
throw new ArgumentException("blockHash");
}
var recipient = context.GetArgument<Address?>("recipient");
IEnumerable<Transaction> txs = digest.TxIds
.Select(b => new TxId(b.ToBuilder().ToArray()))
.Select(store.GetTransaction);
var filteredTransactions = txs.Where(tx =>
tx.Actions!.Count == 1 &&
ToAction(tx.Actions.First()) is ITransferAsset transferAsset &&
(!recipient.HasValue || transferAsset.Recipient == recipient) &&
transferAsset.Amount.Currency.Ticker == "NCG" &&
store.GetTxExecution(blockHash, tx.Id) is TxSuccess);
TransferNCGHistory ToTransferNCGHistory(TxSuccess txSuccess, string? memo)
{
var rawTransferNcgHistories = txSuccess.FungibleAssetsDelta
.Where(pair => pair.Value.Values.Any(fav => fav.Currency.Ticker == "NCG"))
.Select(pair =>
(pair.Key, pair.Value.Values.First(fav => fav.Currency.Ticker == "NCG")))
.ToArray();
var ((senderAddress, _), (recipientAddress, amount)) =
rawTransferNcgHistories[0].Item2.RawValue > rawTransferNcgHistories[1].Item2.RawValue
? (rawTransferNcgHistories[1], rawTransferNcgHistories[0])
: (rawTransferNcgHistories[0], rawTransferNcgHistories[1]);
return new TransferNCGHistory(
txSuccess.BlockHash,
txSuccess.TxId,
senderAddress,
recipientAddress,
amount,
memo);
}
var histories = filteredTransactions.Select(tx =>
ToTransferNCGHistory((TxSuccess)store.GetTxExecution(blockHash, tx.Id),
((ITransferAsset)ToAction(tx.Actions!.Single())).Memo));
return histories;
});
Field<KeyStoreType>(
name: "keyStore",
deprecationReason: "Use `planet key` command instead. https://www.npmjs.com/package/@planetarium/cli",
resolve: context => standaloneContext.KeyStore
).AuthorizeWithLocalPolicyIf(useSecretToken);
Field<NonNullGraphType<NodeStatusType>>(
name: "nodeStatus",
resolve: _ => new NodeStatusType(standaloneContext)
);
Field<NonNullGraphType<Libplanet.Explorer.Queries.ExplorerQuery>>(
name: "chainQuery",
deprecationReason: "Use /graphql/explorer",
resolve: context => new { }
);
Field<NonNullGraphType<ValidationQuery>>(
name: "validation",
description: "The validation method provider for Libplanet types.",
resolve: context => new ValidationQuery(standaloneContext));
Field<NonNullGraphType<ActivationStatusQuery>>(
name: "activationStatus",
description: "Check if the provided address is activated.",
deprecationReason: "Since NCIP-15, it doesn't care account activation.",
resolve: context => new ActivationStatusQuery(standaloneContext))
.AuthorizeWithLocalPolicyIf(useSecretToken);
Field<NonNullGraphType<PeerChainStateQuery>>(
name: "peerChainState",
description: "Get the peer's block chain state",
resolve: context => new PeerChainStateQuery(standaloneContext));
Field<NonNullGraphType<StringGraphType>>(
name: "goldBalance",
arguments: new QueryArguments(

NineChronicles.Headless/NineChronicles.Headless/GraphTypes/StandaloneMutation.cs

Lines 10 to 208 in f3f91fd

using Libplanet.Types.Tx;
using Microsoft.Extensions.Configuration;
using Nekoyume.Action;
using Nekoyume.Model.State;
using Serilog;
using System;
namespace NineChronicles.Headless.GraphTypes
{
public class StandaloneMutation : ObjectGraphType
{
public StandaloneMutation(
StandaloneContext standaloneContext,
NineChroniclesNodeService nodeService,
IConfiguration configuration
)
{
if (configuration[GraphQLService.SecretTokenKey] is { })
{
this.AuthorizeWith(GraphQLService.LocalPolicyKey);
}
Field<KeyStoreMutation>(
name: "keyStore",
deprecationReason: "Use `planet key` command instead. https://www.npmjs.com/package/@planetarium/cli",
resolve: context => standaloneContext.KeyStore);
Field<ActivationStatusMutation>(
name: "activationStatus",
resolve: _ => new ActivationStatusMutation(nodeService),
deprecationReason: "Since NCIP-15, it doesn't care account activation.");
Field<ActionMutation>(
name: "action",
resolve: _ => new ActionMutation(nodeService));
Field<NonNullGraphType<BooleanGraphType>>(
name: "stageTx",
description: "Add a new transaction to staging",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "payload",
Description = "The base64-encoded bytes for new transaction."
}
),
resolve: context =>
{
try
{
byte[] bytes = Convert.FromBase64String(context.GetArgument<string>("payload"));
Transaction tx = Transaction.Deserialize(bytes);
NineChroniclesNodeService? service = standaloneContext.NineChroniclesNodeService;
BlockChain? blockChain = service?.Swarm.BlockChain;
if (blockChain is null)
{
throw new InvalidOperationException($"{nameof(blockChain)} is null.");
}
if (blockChain.Policy.ValidateNextBlockTx(blockChain, tx) is null)
{
blockChain.StageTransaction(tx);
if (service?.Swarm is { } swarm && swarm.Running)
{
swarm.BroadcastTxs(new[] { tx });
}
return true;
}
else
{
context.Errors.Add(new ExecutionError("The given transaction is invalid."));
return false;
}
}
catch (Exception e)
{
context.Errors.Add(new ExecutionError("An unexpected exception occurred.", e));
return false;
}
}
);
Field<NonNullGraphType<TxIdType>>(
name: "stageTxV2",
deprecationReason: "API update with action query. use stageTransaction mutation",
description: "Add a new transaction to staging and return TxId",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "payload",
Description = "The base64-encoded bytes for new transaction."
}
),
resolve: context =>
{
try
{
byte[] bytes = Convert.FromBase64String(context.GetArgument<string>("payload"));
Transaction tx = Transaction.Deserialize(bytes);
NineChroniclesNodeService? service = standaloneContext.NineChroniclesNodeService;
BlockChain? blockChain = service?.Swarm.BlockChain;
if (blockChain is null)
{
throw new InvalidOperationException($"{nameof(blockChain)} is null.");
}
Exception? validationExc = blockChain.Policy.ValidateNextBlockTx(blockChain, tx);
if (validationExc is null)
{
blockChain.StageTransaction(tx);
if (service?.Swarm is { } swarm && swarm.Running)
{
swarm.BroadcastTxs(new[] { tx });
}
return tx.Id;
}
throw new ExecutionError(
$"The given transaction is invalid. (due to: {validationExc.Message})",
validationExc
);
}
catch (Exception e)
{
throw new ExecutionError("An unexpected exception occurred.", e);
}
}
);
Field<TxIdType>(
name: "transfer",
arguments: new QueryArguments(
new QueryArgument<NonNullGraphType<AddressType>>
{
Description = "A hex-encoded value for address of recipient.",
Name = "recipient",
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Description = "A string value of the value to be transferred.",
Name = "amount",
},
new QueryArgument<NonNullGraphType<LongGraphType>>
{
Description = "A sender's transaction counter. You can get it through nextTxNonce().",
Name = "txNonce",
},
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Description = "A hex-encoded value for address of currency to be transferred. The default is the NCG's address.",
// Convert address type to hex string for graphdocs
DefaultValue = GoldCurrencyState.Address.ToHex(),
Name = "currencyAddress"
},
new QueryArgument<StringGraphType>
{
Description = "A 80-max length string to note.",
Name = "memo",
}
),
resolve: context =>
{
if (!(standaloneContext.NineChroniclesNodeService is { } service))
{
throw new InvalidOperationException($"{nameof(NineChroniclesNodeService)} is null.");
}
PrivateKey? privateKey = service.MinerPrivateKey;
if (privateKey is null)
{
// FIXME We should cover this case on unittest.
var msg = "No private key was loaded.";
context.Errors.Add(new ExecutionError(msg));
Log.Error(msg);
return null;
}
BlockChain blockChain = service.BlockChain;
var currency = new GoldCurrencyState(
(Dictionary)blockChain.GetState(new Address(context.GetArgument<string>("currencyAddress")))
).Currency;
FungibleAssetValue amount =
FungibleAssetValue.Parse(currency, context.GetArgument<string>("amount"));
Address recipient = context.GetArgument<Address>("recipient");
string? memo = context.GetArgument<string?>("memo");
Transaction tx = Transaction.Create(
context.GetArgument<long>("txNonce"),
privateKey,
blockChain.Genesis.Hash,
new ActionBase[]
{
new TransferAsset(
privateKey.ToAddress(),

I also found the following external resources that might be helpful:

Summaries of links found in the content:

Step 2: 🧐 Snippet Analysis

From looking through the relevant snippets, I decided to make the following modifications:

File Path Proposed Changes
NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs Modify NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs with contents:
• Add a new argument to the ncTransactions query named actionTypeGlobPattern. This argument should be of type StringGraphType and its description should explain that it is used to filter transactions based on a glob pattern.
• Update the resolve function of the ncTransactions query to use the actionTypeGlobPattern argument. Specifically, modify the part of the function where the actionType argument is used to filter transactions. Instead of using an exact match, use the actionTypeGlobPattern argument to filter transactions based on a glob pattern.
• Ensure that the ListBlocks method still works as expected after these changes. If necessary, update this method to support glob patterns.

Step 3: 📝 Planning

I have created a plan for writing the pull request. I am now working my plan and coding the required changes to address this issue. Here is the planned pull request:

Add support for glob pattern to filter txs by action's type_id in query.transaction.ncTransactions query
sweep/glob-pattern-filtering

Description

This PR adds support for glob patterns to filter transactions by action's type_id in the query.transaction.ncTransactions query in the TransactionHeadlessQuery.cs file. Currently, users can only filter transactions by exact match of the action type, which requires manual updates whenever the protocol version is upgraded. With this PR, users can use glob patterns, such as transfer_asset*, to filter transactions, making it easier to handle protocol upgrades.

Summary of Changes

  • Added a new argument actionTypeGlobPattern to the ncTransactions query in the TransactionHeadlessQuery.cs file. This argument allows users to filter transactions based on a glob pattern for the action type.
  • Modified the resolve function of the ncTransactions query to use the actionTypeGlobPattern argument. The filtering logic has been updated to support glob patterns instead of exact matches.
  • Ensured that the ListBlocks method still works as expected after the changes. If necessary, the method has been updated to support glob patterns.

Please review and merge this PR. Thank you!

Step 4: ⌨️ Coding

File Instructions Progress Error logs
NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs Modify NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs with contents:
• Add a new argument to the ncTransactions query named actionTypeGlobPattern. This argument should be of type StringGraphType and its description should explain that it is used to filter transactions based on a glob pattern.
• Update the resolve function of the ncTransactions query to use the actionTypeGlobPattern argument. Specifically, modify the part of the function where the actionType argument is used to filter transactions. Instead of using an exact match, use the actionTypeGlobPattern argument to filter transactions based on a glob pattern.
• Ensure that the ListBlocks method still works as expected after these changes. If necessary, update this method to support glob patterns.		 ✅ Commit 10dbeae No errors.

Step 5: 🔁 Code Review

Here are my self-reviews of my changes at sweep/glob-pattern-filtering_1.

Here is the 1st review

In the file NineChronicles.Headless/GraphTypes/TransactionHeadlessQuery.cs, there might be a potential issue with the use of the Matches method on the typeId string (lines 98-101). Please ensure that Matches is a valid method for a string in this context and it correctly applies the glob pattern matching as expected. If it's not, you might need to use a different approach for glob pattern matching.

I finished incorporating these changes.

🎉 Latest improvements to Sweep:

  • Use Sweep Map to break large issues into smaller sub-issues, perfect for large tasks like "Sweep (map): migrate from React class components to function components"
  • Getting Sweep to format before committing! Check out Sweep Sandbox Configs to set it up.
  • We released a demo of our chunker, where you can find the corresponding blog and code.

💡 To recreate the pull request edit the issue title or description.
Join Our Discord

@sweep-ai sweep-ai bot mentioned this issue Sep 3, 2023
Open
@moreal moreal closed this as not planned Won't fix, can't repro, duplicate, stale Sep 5, 2023
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
sweep Sweep your software chores
Projects
None yet
Milestone
No milestone
1 participant
@moreal