Ledger | A lightweight EventSourcing library for .net

I am curious what database you are using that requires ODBC and does not have a specific provider.

I have divided your code into user interface code and database code. This makes it easier to maintain.

Database objects like Connection, Command, and DataReader must be closed and disposed. Using...End Using blocks take care of this even it there is an error.

You can pass the CommandText and Connection directly to the constructor of the Command.

Don't hold the connection open while you update the user interface. Comparatively, this is a long process and too long to keep a connection open

This doesn't make any sense. You are resetting the DataSource to the same value numerous times. But, it won't work anyway because a DataReader is not a valid DataSource. See https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.datagridview.datasource?view=netframework-4.8&f1url=%3FappId%3DDev16IDEF1%26l%3DEN-US%26k%3Dk(System.Windows.Forms.DataGridView.DataSource)%3Bk(TargetFrameworkMoniker-.NETFramework%2CVersion%253Dv4.8)%3Bk(DevLang-VB)%26rd%3Dtrue#remarks

Since the journal is an immutable history of every transaction ever committed to the ledger, if you use the Outbox pattern with QLDB, your ledger will contain a permanent history of messages that passed through your Outbox table. This is great if you need an unfalsifiable audit history of the messages queued for sending and a record of them being sent ("deleted" from the table). However, if you don't need that, then you'll be paying storage for those messages for the life of the ledger and not getting much value from it.

The typical event-driven approach would be to use QLDB's streaming feature, which associates a Kinesis Data Stream to your ledger. Every time you commit a transaction, QLDB will publish the transaction to the Kinesis Data Stream. This enables you to drive events from transactions occurring in your ledger. With this approach, you commit your business data to the ledger without worrying about the Outbox table. The document should contain the information you would need in your messaging. Upon commit, QLDB pushes the document(s) from the transaction into Kinesis where you process it using a Lambda function that sends the message onward.

One thing to note is that QLDB offers an at-least-once guarantee of delivering data into Kinesis. This means that you'll need to identify and handle (or just tolerate) potential duplicate messaging. You should always be thinking about idempotence in distributed systems anyway, though.

If you don't want to pay for Kinesis and don't need a real-time approach, there are things you can do with scheduled QLDB exports into S3 and some batch processing of the export files, but I'd start with streaming. DM me if you want to hear more about the export approach.

See also:

• https://docs.aws.amazon.com/qldb/latest/developerguide/streams.html
• https://qldb-immersionday.workshop.aws/en/lab4.html

In case the ticket is not replaceable by others of the same type (e.g. concert ticket) you would need a NonFungibleToken. To build a very basic one you would need to do the following steps:

• create a state YourState that extends TokenType (or implements ContractState, if you need to have a contract associated with the state that can be verified with the transaction)
• create a var issuedTokenType = IssuedTokenType(ourIdentity(), YourState). An IssueTokenType associates a TokenType with an Issuer party
• create a var nft = new NonFungibleToken(issuedTokenType, holder, UUID) this creates a Non-Fungible Token issued by Issuer with holder (a Party) as a receiver
• issue the token subFlow(new IssueTokens(listOf(nft)))

There are many other ways, depending on what you need and how rich your State needs to be (it can be QueryableState, SchedulableState etc), and the token-sdk provides many helpers to help you create, issue and redeem tokens. All of them have their pros and cons, it depends on what you need to achieve.

I suggest you go through the sources here below to learn how to use the token-sdk:

• this cordapp example where there is basically what you need. Check out the CouponTokenType that is used to issue NonFungibleTokens in IssueCoupon flow
• the official tutorial, where you will learn how to use token sdk specifically
• the token-sdk repo on github, where there is additional documentation with various standard examples and the architectural design of the type of tokens available in token-sdk
• the samples dedicated to token-sdk available for both Java and Kotlin. All of them create and issue tokens.

With the above sources you will definitely be able to find everything you need to create and issue the type of token you need.

edit your /etc/hosts like these,add the following content:

This should do it:

Bytecode of a smart contract is published in a transaction (that is mined in a block), and then stored in a storage of the network (usually Ethereum or Binance Smart Chain) associated with an address.

So each time when you're interacting with a smart contract, you're interacting with an address that is associated with a storage chunk containing the bytecode. Plus the bytecode points to other storage slots where the values of its variables are stored.

All state changes (including changes of the storage values) are part of the ledger database. The raw blockchain data only contain the state changes (not the current state), but most higher layers return the current state by default (you can still chose to fetch an older state, e.g. the "defaultBlock" param here). And some layers even disallow accessing previous states (e.g. Solidity and Vyper languages for writing smart contracts - you can compile this code to the bytecode).

But how does the the smart contract know when to pay the project team?

A smart contract can access current balance of any address, including its own. It can also have a variable containing the funding goal. Comparing these two values tells you whether the goal has been reached and whether the smart contract should pay the project team.

However, smart contracts currently don't have any native timers (such as cronjobs) or event handlers - and functions are executed after a transaction is sent to the address of the smart contract (data field of the transaction states what function you want to execute and what arguments you're passing).

So you need to either send the transaction (executing the withdraw() function) manually or using some offchain tool (that can watch the current balance and then send the transaction executing the function for you).

Here just need to run one command I hope i it fixed it for someone

https://support.ledger.com/hc/en-us/articles/115005165269-What-if-Ledger-Wallet-is-not-recognized-on-Linux-

The error was produced by Python SDK function chaincode_query.

I have oppened an issue in the Hyperledger Fabric Python SDK. However, to solve the issue I am using chaincode_invoke instead of chaincode_query.

chaincode_invoke

Now, I can generate and retrieve logs from [get] method.

log

... and also verify it:

base64 of the log